Add javax.obex library, contributed by Motorola.

Based of a JSR-82 reference implementation.

This check-in is 'as-is' from the source provided June 25.

This code does not conform to Android style and quality guidelines. I will be
working with Motorola to improve it. If it does not see substantial improvement
in the Eclair timeframe it will be deleted.

19 files changed, 7269 insertions, 0 deletions

diff --git a/obex/javax/obex/ApplicationParameter.java b/obex/javax/obex/ApplicationParameter.java
new file mode 100644
index 0000000..8ed4ca6
--- /dev/null
+++ b/obex/javax/obex/ApplicationParameter.java
@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) 2008-2009, Motorola, Inc.
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the Motorola, Inc. nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package javax.obex;
+
+public class ApplicationParameter {
+    private int max_length_ini = 1000;
+
+    private byte[] b_array;
+
+    private int length;
+
+    public static class TRIPLET_TAGID {
+        public static final byte ORDER_TAGID = 0x01;
+
+        public static final byte SEARCH_VALUE_TAGID = 0x02;
+
+        public static final byte SEARCH_ATTRIBUTE_TAGID = 0x03;
+
+        public static final byte MAXLISTCOUNT_TAGID = 0x04;//if equals to "0", PSE only reply number of contacts
+
+        public static final byte LISTSTARTOFFSET_TAGID = 0x05;
+
+        public static final byte FILTER_TAGID = 0x06;
+
+        public static final byte FORMAT_TAGID = 0x07;
+
+        public static final byte PHONEBOOKSIZE_TAGID = 0x08;//only used if max list count = 0
+
+        public static final byte NEWMISSEDCALLS_TAGID = 0x09;//only used in "mch" in response
+    }
+
+    public static class TRIPLET_VALUE {
+        public static class ORDER {
+            public static final byte ORDER_BY_INDEX = 0x00;
+
+            public static final byte ORDER_BY_ALPHANUMERIC = 0x01;
+
+            public static final byte ORDER_BY_PHONETIC = 0x02;
+        }
+
+        public static class SEARCHATTRIBUTE {
+            public static final byte SEARCH_BY_NAME = 0x00;
+
+            public static final byte SEARCH_BY_NUMBER = 0x01;
+
+            public static final byte SEARCH_BY_SOUND = 0x02;
+        }
+
+        public static class FORMAT {
+            public static final byte VCARD_VERSION_21 = 0x00;
+
+            public static final byte VCARD_VERSION_30 = 0x01;
+        }
+    }
+
+    public static class TRIPLET_LENGTH {
+        public static final byte ORDER_LENGTH = 1;
+
+        //public final byte SEARCH_VALUE_LENGTH = 0x02;
+        public static final byte SEARCH_ATTRIBUTE_LENGTH = 1;
+
+        public static final byte MAXLISTCOUNT_LENGTH = 2;
+
+        public static final byte LISTSTARTOFFSET_LENGTH = 2;
+
+        public static final byte FILTER_LENGTH = 8;
+
+        public static final byte FORMAT_LENGTH = 1;
+
+        public static final byte PHONEBOOKSIZE_LENGTH = 2;
+
+        public static final byte NEWMISSEDCALLS_LENGTH = 1;
+    }
+
+    /*
+    public class TRIPLET_STRUCTURE{
+        TRIPLET_TAGID id;
+        TRIPLET_LENGTH length;
+        byte[] value;
+    }
+    */
+    public ApplicationParameter() {
+        b_array = new byte[max_length_ini];
+        length = 0;
+    }
+
+    public void addAPPHeader(byte tag, byte len, byte[] value) {
+        if ((length + len + 2) > max_length_ini) {
+            byte[] array_tmp = new byte[length + 4 * len];
+            System.arraycopy(b_array, 0, array_tmp, 0, length);
+            b_array = array_tmp;
+            max_length_ini = length + 4 * len;
+        }
+        b_array[length++] = tag;
+        b_array[length++] = len;
+        System.arraycopy(value, 0, b_array, length, len);
+        length += len;
+    }
+
+    public byte[] getAPPparam() {
+        byte[] para = new byte[length];
+        System.arraycopy(b_array, 0, para, 0, length);
+        return para;
+    }
+}
diff --git a/obex/javax/obex/Authenticator.java b/obex/javax/obex/Authenticator.java
new file mode 100644
index 0000000..a1729f8
--- /dev/null
+++ b/obex/javax/obex/Authenticator.java
@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) 2008-2009, Motorola, Inc.
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the Motorola, Inc. nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package javax.obex;
+
+/**
+ * This interface provides a way to respond to authentication challenge and
+ * authentication response headers.  When a client or server receives an
+ * authentication challenge or authentication response header, the
+ * <code>onAuthenticationChallenge()</code> or
+ * <code>onAuthenticationResponse()</code> will be called, respectively, by
+ * the implementation.
+ * <P>
+ * For more information on how the authentication procedure works in OBEX,
+ * please review the IrOBEX specification at
+ * <A HREF="http://www.irda.org">http://www.irda.org</A>.
+ * <P>
+ * <STRONG>Authentication Challenges</STRONG>
+ * <P>
+ * When a client or server receives an authentication challenge header, the
+ * <code>onAuthenticationChallenge()</code> method will be invoked by the
+ * OBEX API implementation.  The application will then return the user name
+ * (if needed) and password via a <code>PasswordAuthentication</code> object.
+ * The password in this object is not sent in the authentication response.
+ * Instead, the 16-byte challenge received in the authentication challenge is
+ * combined with the password returned from the
+ * <code>onAuthenticationChallenge()</code> method and passed through the MD5
+ * hash algorithm.  The resulting value is sent in the authentication response
+ * along with the user name if it was provided.
+ * <P>
+ * <STRONG>Authentication Responses</STRONG>
+ * <P>
+ * When a client or server receives an authentication response header, the
+ * <code>onAuthenticationResponse()</code> method is invoked by the API
+ * implementation with the user name received in the authentication response
+ * header.  (The user name will be <code>null</code> if no user name was
+ * provided in the authentication response header.)  The application must
+ * determine the correct password.  This value should be returned from the
+ * <code>onAuthenticationResponse()</code> method.  If the authentication
+ * request should fail without the implementation checking the password,
+ * <code>null</code> should
+ * be returned by the application.  (This is needed for reasons like not
+ * recognizing the user name, etc.)  If the returned value is not
+ * <code>null</code>, the OBEX API implementation will combine the password
+ * returned from the <code>onAuthenticationResponse()</code> method and
+ * challenge sent via the authentication challenge, apply the MD5 hash
+ * algorithm, and compare the result to the response hash received in the
+ * authentication response header.  If the values are not equal, an
+ * <code>IOException</code> will be thrown if the client requested authentication.
+ * If the server requested authentication, the
+ * <code>onAuthenticationFailure()</code> method will be called on the
+ * <code>ServerRequestHandler</code> that failed authentication.  The
+ * connection is <B>not</B> closed if authentication failed.
+ *
+ * @version 0.3 November 28, 2008
+ */
+public interface Authenticator {
+
+    /**
+     * Called when a client or a server receives an authentication challenge
+     * header. It should respond to the challenge with a
+     * <code>PasswordAuthentication</code> that contains the correct user name
+     * and password for the challenge.
+     *
+     * @param description the description of which user name and password
+     * should be used; if no description is provided in the authentication
+     * challenge or the description is encoded in an encoding scheme that is
+     * not supported, an empty string will be provided
+     *
+     * @param isUserIdRequired <code>true</code> if the user ID is required;
+     * <code>false</code> if the user ID is not required
+     *
+     * @param isFullAccess <code>true</code> if full access to the server
+     * will be granted; <code>false</code> if read only access will be
+     * granted
+     *
+     * @return a <code>PasswordAuthentication</code> object containing the
+     * user name and password used for authentication
+     */
+    public PasswordAuthentication onAuthenticationChallenge(String description,
+            boolean isUserIdRequired, boolean isFullAccess);
+
+    /**
+     * Called when a client or server receives an authentication response
+     * header.  This method will provide the user name and expect the correct
+     * password to be returned.
+     *
+     * @param userName the user name provided in the authentication response;
+     * may be <code>null</code>
+     *
+     * @return the correct password for the user name provided; if
+     * <code>null</code> is returned then the authentication request failed
+     */
+    public byte[] onAuthenticationResponse(byte[] userName);
+}
diff --git a/obex/javax/obex/BaseStream.java b/obex/javax/obex/BaseStream.java
new file mode 100644
index 0000000..ffd0b63
--- /dev/null
+++ b/obex/javax/obex/BaseStream.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 2008-2009, Motorola, Inc.
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the Motorola, Inc. nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package javax.obex;
+
+import java.io.*;
+
+/**
+ * This interface defines the methods needed by a parent that uses the
+ * PrivateInputStream and PrivateOutputStream objects defined in this package.
+ *
+ * @version 0.3 November 28, 2008
+ */
+public interface BaseStream {
+
+    /**
+     * Verifies that this object is still open.
+     *
+     * @exception IOException if the object is closed
+     */
+    public void ensureOpen() throws IOException;
+
+    /**
+     * Verifies that additional information may be sent.  In other words, the
+     * operation is not done.
+     *
+     * @exception IOException if the operation is completed
+     */
+    public void ensureNotDone() throws IOException;
+
+    /**
+     * Continues the operation since there is no data to read.
+     *
+     * @param sendEmpty <code>true</code> if the operation should send an
+     * empty packet or not send anything if there is no data to send
+     * @param inStream  <code>true</code> if the stream is input stream or
+     * is output stream
+     * @return <code>true</code> if the operation was completed;
+     * <code>false</code> if no operation took place
+     *
+     * @exception IOException if an IO error occurs
+     */
+    public boolean continueOperation(boolean sendEmpty, boolean inStream) throws IOException;
+
+    /**
+     * Called when the output or input stream is closed.
+     *
+     * @param inStream <code>true</code> if the input stream is closed;
+     * <code>false</code> if the output stream is closed
+     *
+     * @exception IOException if an IO error occurs
+     */
+    public void streamClosed(boolean inStream) throws IOException;
+}
diff --git a/obex/javax/obex/ClientOperation.java b/obex/javax/obex/ClientOperation.java
new file mode 100644
index 0000000..dc4e944
--- /dev/null
+++ b/obex/javax/obex/ClientOperation.java
@@ -0,0 +1,840 @@
+/*
+ * Copyright (c) 2008-2009, Motorola, Inc.
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the Motorola, Inc. nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package javax.obex;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.ByteArrayOutputStream;
+
+/**
+ * This class implements the <code>Operation</code> interface.  It will read
+ * and write data via puts and gets.
+ *
+ * @version 0.3 November 28, 2008
+ */
+public class ClientOperation implements Operation, BaseStream {
+
+    /**
+     * Defines the basic packet length used by OBEX.  Event OBEX packet has the
+     * same basic format:<BR>
+     * Byte 0: Request or Response Code
+     * Byte 1&2: Length of the packet.
+     */
+    private static final int BASE_PACKET_LENGTH = 3;
+
+    private ClientSession parent;
+
+    private InputStream socketInput;
+
+    private PrivateInputStream privateInput;
+
+    private PrivateOutputStream privateOutput;
+
+    private boolean isClosed;
+
+    private String exceptionMessage;
+
+    private int maxPacketSize;
+
+    private boolean isDone;
+
+    private boolean isGet;
+
+    private HeaderSet requestHeaders;
+
+    private HeaderSet replyHeaders;
+
+    private boolean isEndOfBodySent;
+
+    private boolean inputStreamOpened;
+
+    private boolean outputStreamOpened;
+
+    private boolean isValidateConnected;
+
+    /** 
+     * Creates new OperationImpl to read and write data to a server
+     *
+     * @param in the input stream to read from
+     *
+     * @param maxSize the maximum packet size
+     *
+     * @param p the parent to this object
+     *
+     * @param headers the headers to set in the initial request
+     *
+     * @param type <code>true</code> if this is a get request;
+     * <code>false</code. if this is a put request
+     *
+     * @exception IOExcpetion if the an IO error occured
+     */
+    public ClientOperation(InputStream in, int maxSize, ClientSession p, HeaderSet header,
+            boolean type) throws IOException {
+
+        parent = p;
+        isEndOfBodySent = false;
+        socketInput = in;
+        isClosed = false;
+        isDone = false;
+        maxPacketSize = maxSize;
+        isGet = type;
+
+        inputStreamOpened = false;
+        outputStreamOpened = false;
+        isValidateConnected = false;
+
+        privateInput = null;
+        privateOutput = null;
+
+        replyHeaders = new HeaderSet();
+
+        requestHeaders = new HeaderSet();
+
+        int[] headerList = header.getHeaderList();
+
+        if (headerList != null) {
+
+            for (int i = 0; i < headerList.length; i++) {
+                requestHeaders.setHeader(headerList[i], header.getHeader(headerList[i]));
+            }
+        }
+
+        if ((header).authChall != null) {
+            requestHeaders.authChall = new byte[(header).authChall.length];
+            System.arraycopy((header).authChall, 0, requestHeaders.authChall, 0,
+                    (header).authChall.length);
+        }
+
+        if ((header).authResp != null) {
+            requestHeaders.authResp = new byte[(header).authResp.length];
+            System.arraycopy((header).authResp, 0, requestHeaders.authResp, 0,
+                    (header).authResp.length);
+
+        }
+        //        requestHeaders = (HeaderSet)header;
+    }
+
+    /**
+     * Sends an ABORT message to the server.  By calling this method, the
+     * corresponding input and output streams will be closed along with this
+     * object.
+     *
+     * @exception IOException if the transaction has already ended or if an
+     * OBEX server called this method
+     */
+    public synchronized void abort() throws IOException {
+        ensureOpen();
+        // need check again .
+        //	if(isDone) {
+        //	     throw new IOException("Operation has already ended");
+        //	}
+
+        //no compatible with sun-ri
+        if ((isDone) && (replyHeaders.responseCode != OBEXConstants.OBEX_HTTP_CONTINUE)) {
+            throw new IOException("Operation has already ended");
+        }
+
+        exceptionMessage = "Operation aborted";
+        if ((!isDone) && (replyHeaders.responseCode == OBEXConstants.OBEX_HTTP_CONTINUE)) {
+            isDone = true;
+            /*
+             * Since we are not sending any headers or returning any headers then
+             * we just need to write and read the same bytes
+             */
+            parent.sendRequest(0xFF, null, replyHeaders, null);
+
+            if (replyHeaders.responseCode != ResponseCodes.OBEX_HTTP_OK) {
+                throw new IOException("Invalid response code from server");
+            }
+
+            exceptionMessage = null;
+        }
+
+        close();
+    }
+
+    /**
+     * Retrieves the response code retrieved from the server.  Response codes
+     * are defined in the <code>ResponseCodes</code> interface.
+     *
+     * @return the response code retrieved from the server
+     *
+     * @exception IOException if an error occurred in the transport layer during
+     * the transaction; if this method is called on a <code>HeaderSet</code>
+     * object created by calling <code>createHeaderSet</code> in a
+     * <code>ClientSession</code> object
+     */
+    public synchronized int getResponseCode() throws IOException {
+        //avoid dup validateConnection
+        if ((replyHeaders.responseCode == -1)
+                || (replyHeaders.responseCode == OBEXConstants.OBEX_HTTP_CONTINUE)) {
+            validateConnection();
+        }
+
+        return replyHeaders.responseCode;
+    }
+
+    /**
+     * This method will always return <code>null</code>
+     *
+     * @return <code>null</code>
+     */
+    public String getEncoding() {
+        return null;
+    }
+
+    /**
+     * Returns the type of content that the resource connected to is providing.
+     * E.g. if the connection is via HTTP, then the value of the content-type
+     * header field is returned.
+     *
+     * @return the content type of the resource that the URL references, or
+     * <code>null</code> if not known
+     */
+    public String getType() {
+        try {
+            return (String)replyHeaders.getHeader(HeaderSet.TYPE);
+        } catch (IOException e) {
+            return null;
+        }
+    }
+
+    /**
+     * Returns the length of the content which is being provided. E.g. if the
+     * connection is via HTTP, then the value of the content-length header
+     * field is returned.
+     *
+     * @return the content length of the resource that this connection's URL
+     * references, or -1 if the content length is not known
+     */
+    public long getLength() {
+        try {
+            Long temp = (Long)replyHeaders.getHeader(HeaderSet.LENGTH);
+
+            if (temp == null) {
+                return -1;
+            } else {
+                return temp.longValue();
+            }
+        } catch (IOException e) {
+            return -1;
+        }
+    }
+
+    /**
+     * Open and return an input stream for a connection.
+     *
+     * @return an input stream
+     *
+     * @exception IOException if an I/O error occurs
+     */
+    public InputStream openInputStream() throws IOException {
+        // TODO: this mode is not set yet.
+        // if ((parent.mode & Connector.READ) == 0)
+        // throw new IOException("write-only connection");
+
+        ensureOpen();
+
+        if (inputStreamOpened)
+            throw new IOException("no more input streams available");
+        if (isGet) {
+            // send the GET request here
+            validateConnection();
+            isValidateConnected = true;
+        } else {
+            if (privateInput == null) {
+                privateInput = new PrivateInputStream(this);
+            }
+        }
+
+        inputStreamOpened = true;
+
+        return privateInput;
+    }
+
+    /**8
+     * Open and return a data input stream for a connection.
+     *
+     * @return an input stream
+     *
+     * @exception IOException if an I/O error occurs
+     */
+    public DataInputStream openDataInputStream() throws IOException {
+        return new DataInputStream(openInputStream());
+    }
+
+    /**
+     * Open and return an output stream for a connection.
+     *
+     * @return an output stream
+     *
+     * @exception IOException if an I/O error occurs
+     */
+    public OutputStream openOutputStream() throws IOException {
+        // TODO: this mode is not set yet.
+        //    	if ((parent.mode & Connector.WRITE) == 0)
+        //    		throw new IOException("read-only connection");
+        ensureOpen();
+        ensureNotDone();
+
+        if (outputStreamOpened)
+            throw new IOException("no more output streams available");
+
+        if (privateOutput == null) {
+            // there are 3 bytes operation headers and 3 bytes body headers //
+            privateOutput = new PrivateOutputStream(this, maxPacketSize - 6);
+        }
+
+        outputStreamOpened = true;
+
+        return privateOutput;
+    }
+
+    public int getMaxPacketSize() {
+        return maxPacketSize - 6;
+    }
+
+    /**
+     * Open and return a data output stream for a connection.
+     *
+     * @return an output stream
+     *
+     * @exception IOException if an I/O error occurs
+     */
+    public DataOutputStream openDataOutputStream() throws IOException {
+        return new DataOutputStream(openOutputStream());
+    }
+
+    /**
+     * Closes the connection and ends the transaction
+     *
+     * @exception IOException if the operation has already ended or is closed
+     */
+    public void close() throws IOException {
+        isClosed = true;
+        inputStreamOpened = false;
+        outputStreamOpened = false;
+        parent.setInactive();
+    }
+
+    /**
+     * Returns the headers that have been received during the operation.
+     * Modifying the object returned has no effect on the headers that are
+     * sent or retrieved.
+     *
+     * @return the headers received during this <code>Operation</code>
+     *
+     * @exception IOException if this <code>Operation</code> has been closed
+     */
+    public HeaderSet getReceivedHeaders() throws IOException {
+        ensureOpen();
+
+        return replyHeaders;
+    }
+
+    /**
+     * Specifies the headers that should be sent in the next OBEX message that
+     * is sent.
+     *
+     * @param headers the headers to send in the next message
+     *
+     * @exception IOException  if this <code>Operation</code> has been closed
+     * or the transaction has ended and no further messages will be exchanged
+     *
+     * @exception IllegalArgumentException if <code>headers</code> was not created
+     * by a call to <code>ServerRequestHandler.createHeaderSet()</code>
+     *
+     * @exception NullPointerException if <code>headers</code> is <code>null</code>
+     */
+    public void sendHeaders(HeaderSet headers) throws IOException {
+        ensureOpen();
+        if (isDone) {
+            throw new IOException("Operation has already exchanged all data");
+        }
+
+        if (headers == null) {
+            throw new NullPointerException("Headers may not be null");
+        }
+
+        int[] headerList = headers.getHeaderList();
+        if (headerList != null) {
+            for (int i = 0; i < headerList.length; i++) {
+                requestHeaders.setHeader(headerList[i], headers.getHeader(headerList[i]));
+            }
+        }
+    }
+
+    /**
+     * Reads a response from the server.  It will populate the appropriate body
+     * and headers.
+     *
+     * @return <code>true</code> if the transaction should end;
+     * <code>false</code> if the transaction should not end
+     *
+     * @exception IOException if an IO error occurred
+     */
+    private boolean readResponse() throws IOException {
+        replyHeaders.responseCode = socketInput.read();
+        int packetLength = socketInput.read();
+        packetLength = (packetLength << 8) + socketInput.read();
+
+        if (packetLength > OBEXConstants.MAX_PACKET_SIZE_INT) {
+            if (exceptionMessage != null) {
+                abort();
+            }
+            throw new IOException("Received a packet that was too big");
+        }
+
+        if (packetLength > BASE_PACKET_LENGTH) {
+            int dataLength = packetLength - BASE_PACKET_LENGTH;
+            byte[] data = new byte[dataLength];
+            int readLength = socketInput.read(data);
+            if (readLength != dataLength) {
+                throw new IOException("Received a packet without data as decalred length");
+            }
+            byte[] body = OBEXHelper.updateHeaderSet(replyHeaders, data);
+
+            if (body != null) {
+                privateInput.writeBytes(body, 1);
+
+                /*
+                 * Determine if a body (0x48) header or an end of body (0x49)
+                 * was received.  If we received an end of body and
+                 * a response code of OBEX_HTTP_OK, then the operation should
+                 * end.
+                 */
+                if ((body[0] == 0x49) && (replyHeaders.responseCode == ResponseCodes.OBEX_HTTP_OK)) {
+                    return false;
+                }
+            }
+        }
+
+        if (replyHeaders.responseCode == OBEXConstants.OBEX_HTTP_CONTINUE) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * Verifies that additional information may be sent.  In other words, the
+     * operation is not done.
+     *
+     * @exception IOException if the operation is completed
+     */
+    public void ensureNotDone() throws IOException {
+        if (isDone) {
+            throw new IOException("Operation has completed");
+        }
+    }
+
+    /**
+     * Verifies that the connection is open and no exceptions should be thrown.
+     *
+     * @exception IOException if an exception needs to be thrown
+     */
+    public void ensureOpen() throws IOException {
+        parent.ensureOpen();
+
+        if (exceptionMessage != null) {
+            throw new IOException(exceptionMessage);
+        }
+        if (isClosed) {
+            throw new IOException("Operation has already ended");
+        }
+    }
+
+    /**
+     * Verifies that the connection is open and the proper data has been read.
+     *
+     * @exception IOException if an IO error occurs
+     */
+    private void validateConnection() throws IOException {
+        ensureOpen();
+
+        // to sure only one privateInput object exist.
+        if (privateInput == null) {
+            startProcessing();
+        }
+    }
+
+    /**
+     * Sends a request to the client of the specified type
+     *
+     * @param response the response code to send back to the client
+     *
+     * @return <code>true</code> if there is more data to send;
+     * <code>false</code> if there is no more data to send
+     *
+     * @exception IOException if an IO error occurs
+     */
+    protected boolean sendRequest(int type) throws IOException {
+        boolean returnValue = false;
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        int bodyLength = -1;
+        byte[] headerArray = OBEXHelper.createHeader(requestHeaders, true);
+        if (privateOutput != null) {
+            bodyLength = privateOutput.size();
+        }
+
+        /*
+         * Determine if there is space to add a body request.  At present
+         * this method checks to see if there is room for at least a 17
+         * byte body header.  This number needs to be at least 6 so that
+         * there is room for the header ID and length and the reply ID and
+         * length, but it is a waste of resources if we can't send much of
+         * the body.
+         */
+        if ((BASE_PACKET_LENGTH + headerArray.length) > maxPacketSize) {
+            int end = 0;
+            int start = 0;
+            // split & send the headerArray in multiple packets.
+
+            while (end != headerArray.length) {
+                //split the headerArray
+                end = OBEXHelper.findHeaderEnd(headerArray, start, maxPacketSize
+                        - BASE_PACKET_LENGTH);
+                // can not split 
+                if (end == -1) {
+                    isDone = true;
+                    abort();
+                    // isDone = true;
+                    exceptionMessage = "Header larger then can be sent in a packet";
+                    isClosed = true;
+
+                    if (privateInput != null) {
+                        privateInput.close();
+                    }
+
+                    if (privateOutput != null) {
+                        privateOutput.close();
+                    }
+                    throw new IOException("OBEX Packet exceeds max packet size");
+                }
+
+                byte[] sendHeader = new byte[end - start];
+                System.arraycopy(headerArray, start, sendHeader, 0, sendHeader.length);
+                if (!parent.sendRequest(type, sendHeader, replyHeaders, privateInput)) {
+                    return false;
+                }
+
+                if (replyHeaders.responseCode != OBEXConstants.OBEX_HTTP_CONTINUE) {
+                    return false;
+                }
+
+                start = end;
+            }
+
+            if (bodyLength > 0) {
+                return true;
+            } else {
+                return false;
+            }
+        } else {
+            out.write(headerArray);
+        }
+
+        if (bodyLength > 0) {
+            /*
+             * Determine if I can send the whole body or just part of
+             * the body.  Remember that there is the 3 bytes for the
+             * response message and 3 bytes for the header ID and length
+             */
+            if (bodyLength > (maxPacketSize - headerArray.length - 6)) {
+                returnValue = true;
+
+                bodyLength = maxPacketSize - headerArray.length - 6;
+            }
+
+            byte[] body = privateOutput.readBytes(bodyLength);
+
+            /*
+             * Since this is a put request if the final bit is set or
+             * the output stream is closed we need to send the 0x49
+             * (End of Body) otherwise, we need to send 0x48 (Body)
+             */
+            if ((privateOutput.isClosed()) && (!returnValue) && (!isEndOfBodySent)
+                    && ((type & 0x80) != 0)) {
+                out.write(0x49);
+                isEndOfBodySent = true;
+            } else {
+                out.write(0x48);
+            }
+
+            bodyLength += 3;
+            out.write((byte)(bodyLength >> 8));
+            out.write((byte)bodyLength);
+
+            if (body != null) {
+                out.write(body);
+            }
+        }
+
+        if (outputStreamOpened && bodyLength <= 0 && !isEndOfBodySent) {
+            // only 0x82 or 0x83 can send 0x49
+            if ((type & 0x80) == 0) {
+                out.write(0x48);
+            } else {
+                out.write(0x49);
+                isEndOfBodySent = true;
+
+            }
+
+            bodyLength = 3;
+            out.write((byte)(bodyLength >> 8));
+            out.write((byte)bodyLength);
+        }
+
+        if (out.size() == 0) {
+            if (!parent.sendRequest(type, null, replyHeaders, privateInput)) {
+                return false;
+            }
+            return returnValue;
+        }
+        if ((out.size() > 0)
+                && (!parent.sendRequest(type, out.toByteArray(), replyHeaders, privateInput))) {
+            return false;
+        }
+
+        // send all of the output data in 0x48, 
+        // send 0x49 with empty body
+        if ((privateOutput != null) && (privateOutput.size() > 0))
+            returnValue = true;
+
+        return returnValue;
+    }
+
+    /**
+     * This method starts the processing thread results.  It will send the
+     * initial request.  If the response takes more then one packet, a thread
+     * will be started to handle additional requests
+     *
+     * @exception IOException if an IO error occurs
+     */
+    private synchronized void startProcessing() throws IOException {
+
+        if (privateInput == null) {
+            privateInput = new PrivateInputStream(this);
+        }
+        boolean more = true;
+
+        if (isGet) {
+            if (!isDone) {
+                replyHeaders.responseCode = OBEXConstants.OBEX_HTTP_CONTINUE;
+                while ((more) && (replyHeaders.responseCode == OBEXConstants.OBEX_HTTP_CONTINUE)) {
+                    more = sendRequest(0x03);
+                }
+
+                if (replyHeaders.responseCode == OBEXConstants.OBEX_HTTP_CONTINUE) {
+                    parent.sendRequest(0x83, null, replyHeaders, privateInput);
+                }
+                if (replyHeaders.responseCode != OBEXConstants.OBEX_HTTP_CONTINUE) {
+                    isDone = true;
+                }
+            }
+        } else {
+
+            if (!isDone) {
+                replyHeaders.responseCode = OBEXConstants.OBEX_HTTP_CONTINUE;
+                while ((more) && (replyHeaders.responseCode == OBEXConstants.OBEX_HTTP_CONTINUE)) {
+                    more = sendRequest(0x02);
+
+                }
+            }
+
+            if (replyHeaders.responseCode == OBEXConstants.OBEX_HTTP_CONTINUE) {
+                parent.sendRequest(0x82, null, replyHeaders, privateInput);
+            }
+
+            if (replyHeaders.responseCode != OBEXConstants.OBEX_HTTP_CONTINUE) {
+                isDone = true;
+            }
+        }
+    }
+
+    /**
+     * Continues the operation since there is no data to read.
+     *
+     * @param sendEmpty <code>true</code> if the operation should send an
+     * empty packet or not send anything if there is no data to send
+     * @param inStream  <code>true</code> if the stream is input stream or
+     * is output stream
+     * @exception IOException if an IO error occurs
+     */
+    public synchronized boolean continueOperation(boolean sendEmpty, boolean inStream)
+            throws IOException {
+
+        if (isGet) {
+            if ((inStream) && (!isDone)) {
+                // to deal with inputstream in get operation
+                parent.sendRequest(0x83, null, replyHeaders, privateInput);
+                /*
+                  * Determine if that was not the last packet in the operation
+                  */
+                if (replyHeaders.responseCode != OBEXConstants.OBEX_HTTP_CONTINUE) {
+                    isDone = true;
+                }
+
+                return true;
+
+            } else if ((!inStream) && (!isDone)) {
+                // to deal with outputstream in get operation
+
+                if (privateInput == null) {
+                    privateInput = new PrivateInputStream(this);
+                }
+                sendRequest(0x03);
+                return true;
+
+            } else if (isDone) {
+                return false;
+            }
+
+        } else {
+            if ((!inStream) && (!isDone)) {
+                // to deal with outputstream in put operation
+                if (replyHeaders.responseCode == -1) {
+                    replyHeaders.responseCode = OBEXConstants.OBEX_HTTP_CONTINUE;
+                }
+                sendRequest(0x02);
+                return true;
+            } else if ((inStream) && (!isDone)) {
+                // How to deal with inputstream  in put operation ?
+                return false;
+
+            } else if (isDone) {
+                return false;
+            }
+
+        }
+        return false;
+    }
+
+    /**
+     * Called when the output or input stream is closed.
+     *
+     * @param inStream <code>true</code> if the input stream is closed;
+     * <code>false</code> if the output stream is closed
+     *
+     * @exception IOException if an IO error occurs
+     */
+    public void streamClosed(boolean inStream) throws IOException {
+        if (!isGet) {
+            if ((!inStream) && (!isDone)) {
+                // to deal with outputstream in put operation
+
+                boolean more = true;
+
+                if ((privateOutput != null) && (privateOutput.size() <= 0)) {
+                    byte[] headerArray = OBEXHelper.createHeader(requestHeaders, false);
+                    if (headerArray.length <= 0)
+                        more = false;
+                }
+                // If have not sent any data so send  all now
+                if (replyHeaders.responseCode == -1) {
+                    replyHeaders.responseCode = OBEXConstants.OBEX_HTTP_CONTINUE;
+                }
+
+                while ((more) && (replyHeaders.responseCode == OBEXConstants.OBEX_HTTP_CONTINUE)) {
+                    more = sendRequest(0x02);
+                }
+
+                /*
+                 * According to the IrOBEX specification, after the final put, you
+                 * only have a single reply to send.  so we don't need the while
+                 * loop.
+                 */
+                while (replyHeaders.responseCode == OBEXConstants.OBEX_HTTP_CONTINUE) {
+
+                    sendRequest(0x82);
+                }
+                isDone = true;
+            } else if ((inStream) && (isDone)) {
+                // how to deal with input stream in put stream ?
+                isDone = true;
+            }
+        } else {
+            isValidateConnected = false;
+            if ((inStream) && (!isDone)) {
+
+                // to deal with inputstream in get operation
+                // Have not sent any data so send it all now
+
+                if (replyHeaders.responseCode == -1) {
+                    replyHeaders.responseCode = OBEXConstants.OBEX_HTTP_CONTINUE;
+                }
+
+                while (replyHeaders.responseCode == OBEXConstants.OBEX_HTTP_CONTINUE) {
+                    if (!sendRequest(0x83)) {
+                        break;
+                    }
+                }
+                while (replyHeaders.responseCode == OBEXConstants.OBEX_HTTP_CONTINUE) {
+                    parent.sendRequest(0x83, null, replyHeaders, privateInput);
+                }
+                isDone = true;
+            } else if ((!inStream) && (!isDone)) {
+                // to deal with outputstream in get operation
+                // part of the data may have been sent in continueOperation.
+
+                boolean more = true;
+
+                if ((privateOutput != null) && (privateOutput.size() <= 0)) {
+                    byte[] headerArray = OBEXHelper.createHeader(requestHeaders, false);
+                    if (headerArray.length <= 0)
+                        more = false;
+                }
+
+                if (privateInput == null) {
+                    privateInput = new PrivateInputStream(this);
+                }
+                if ((privateOutput != null) && (privateOutput.size() <= 0))
+                    more = false;
+
+                replyHeaders.responseCode = OBEXConstants.OBEX_HTTP_CONTINUE;
+                while ((more) && (replyHeaders.responseCode == OBEXConstants.OBEX_HTTP_CONTINUE)) {
+                    more = sendRequest(0x03);
+                }
+                sendRequest(0x83);
+                //                parent.sendRequest(0x83, null, replyHeaders, privateInput);
+                if (replyHeaders.responseCode != OBEXConstants.OBEX_HTTP_CONTINUE) {
+                    isDone = true;
+                }
+
+            }
+        }
+    }
+}
diff --git a/obex/javax/obex/ClientSession.java b/obex/javax/obex/ClientSession.java
new file mode 100644
index 0000000..c624c30
--- /dev/null
+++ b/obex/javax/obex/ClientSession.java
@@ -0,0 +1,783 @@
+/*
+ * Copyright (c) 2008-2009, Motorola, Inc.
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the Motorola, Inc. nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package javax.obex;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+/**
+ * This class implements the <code>Operation</code> interface.  It will read
+ * and write data via puts and gets.
+ *
+ * @version 0.3 November 28, 2008
+ */
+public class ClientSession implements ObexSession {
+    //protected StreamConnection client;
+    protected Authenticator authenticator;
+
+    protected boolean connectionOpen = false;
+
+    protected boolean isConnected; // Determines if an OBEX layer connection
+
+    // has been established
+    private byte[] connectionID = null;
+
+    byte[] challengeDigest = null;
+
+    protected InputStream input = null;
+
+    protected OutputStream output = null;
+
+    protected ObexTransport trans = null;
+
+    public int mode;
+
+    /*
+    * The max Packet size must be at least 256 according to the OBEX
+    * specification.
+    */
+    private int maxPacketSize = 256;
+
+    protected boolean isActive;
+
+    /* public ClientSession() {
+              connectionOpen = false;
+    }*/
+
+    public ClientSession(ObexTransport trans) {
+        try {
+            this.trans = trans;
+            input = trans.openInputStream();
+            output = trans.openOutputStream();
+            connectionOpen = true;
+        } catch (IOException ioe) {
+        }
+
+    }
+
+    /* comment out as not used internally
+    public boolean isClosed() {
+      //  if (client instanceof BTConnection)
+      //      return ((BTConnection)client).isClosed();
+      //  else
+           return false;
+    }    
+    
+    public int getConnectionHandle() {
+       //if (client instanceof BTConnection)
+       //    return ((BTConnection)client).getConnectionHandle();
+       //else
+           return -1;
+    }
+
+    public RemoteDevice getRemoteDevice() {
+        if (client instanceof BTConnection)
+            return ((BTConnection)client).getRemoteDevice();
+        else
+            return null;
+    }
+    */
+
+    public HeaderSet connect(HeaderSet header) throws java.io.IOException {
+        ensureOpen();
+        if (isConnected) {
+            throw new IOException("Already connected to server");
+        }
+        synchronized (this) {
+            if (isActive) {
+                throw new IOException("OBEX request is already being performed");
+            }
+            isActive = true;
+        }
+        int totalLength = 4;
+        byte[] head = null;
+
+        // Determine the header byte array
+        if (header != null) {
+            if ((header).nonce != null) {
+                challengeDigest = new byte[16];
+                System.arraycopy((header).nonce, 0, challengeDigest, 0, 16);
+            }
+            head = OBEXHelper.createHeader(header, false);
+            totalLength += head.length;
+        }
+        /*
+        * Write the OBEX CONNECT packet to the server.
+        * Byte 0: 0x80
+        * Byte 1&2: Connect Packet Length
+        * Byte 3: OBEX Version Number (Presently, 0x10)
+        * Byte 4: Flags (For TCP 0x00)
+        * Byte 5&6: Max OBEX Packet Length (Defined in MAX_PACKET_SIZE)
+        * Byte 7 to n: headers
+        */
+        byte[] requestPacket = new byte[totalLength];
+        // We just need to start at  byte 3 since the sendRequest() method will
+        // handle the length and 0x80.
+        requestPacket[0] = (byte)0x10;
+        requestPacket[1] = (byte)0x00;
+        requestPacket[2] = (byte)(OBEXConstants.MAX_PACKET_SIZE_INT >> 8);
+        requestPacket[3] = (byte)(OBEXConstants.MAX_PACKET_SIZE_INT & 0xFF);
+        if (head != null) {
+            System.arraycopy(head, 0, requestPacket, 4, head.length);
+        }
+
+        // check with local max packet size
+        if ((requestPacket.length + 3) > OBEXConstants.MAX_PACKET_SIZE_INT) {
+            throw new IOException("Packet size exceeds max packet size");
+        }
+
+        HeaderSet returnHeaderSet = new HeaderSet();
+        sendRequest(0x80, requestPacket, returnHeaderSet, null);
+
+        /*
+        * Read the response from the OBEX server.
+        * Byte 0: Response Code (If successful then OBEX_HTTP_OK)
+        * Byte 1&2: Packet Length
+        * Byte 3: OBEX Version Number
+        * Byte 4: Flags3
+        * Byte 5&6: Max OBEX packet Length
+        * Byte 7 to n: Optional HeaderSet
+        */
+        if (returnHeaderSet.responseCode == ResponseCodes.OBEX_HTTP_OK) {
+            isConnected = true;
+        }
+        synchronized (this) {
+            isActive = false;
+        }
+
+        return returnHeaderSet;
+    }
+
+    public Operation get(HeaderSet header) throws java.io.IOException {
+
+        if (!isConnected) {
+            throw new IOException("Not connected to the server");
+        }
+        synchronized (this) {
+            if (isActive) {
+                throw new IOException("OBEX request is already being performed");
+            }
+            isActive = true;
+        }
+        ensureOpen();
+
+        if (header == null) {
+            header = new HeaderSet();
+        } else {
+            if ((header).nonce != null) {
+                challengeDigest = new byte[16];
+                System.arraycopy((header).nonce, 0, challengeDigest, 0, 16);
+            }
+        }
+        // Add the connection ID if one exists
+        if (connectionID != null) {
+            (header).connectionID = new byte[4];
+            System.arraycopy(connectionID, 0, (header).connectionID, 0, 4);
+        }
+
+        //      this.mode = javax.microedition.io.Connector.READ ;
+        return new ClientOperation(input, maxPacketSize, this, header, true);
+    }
+
+    /**
+    *  0xCB Connection Id an identifier used for OBEX connection multiplexing
+    */
+    public void setConnectionID(long id) {
+        if ((id < 0) || (id > 0xFFFFFFFFL)) {
+            throw new IllegalArgumentException("Connection ID is not in a valid range");
+        }
+        connectionID = OBEXHelper.convertToByteArray(id);
+    }
+
+    public HeaderSet createHeaderSet() {
+        return new HeaderSet();
+    }
+
+    public HeaderSet delete(HeaderSet headers) throws java.io.IOException {
+
+        Operation op = put(headers);
+        op.getResponseCode();
+        HeaderSet returnValue = op.getReceivedHeaders();
+        op.close();
+
+        return returnValue;
+    }
+
+    public HeaderSet disconnect(HeaderSet header) throws java.io.IOException {
+        if (!isConnected) {
+            throw new IOException("Not connected to the server");
+        }
+        synchronized (this) {
+            if (isActive) {
+                throw new IOException("OBEX request is already being performed");
+            }
+            isActive = true;
+        }
+        ensureOpen();
+        // Determine the header byte array
+        byte[] head = null;
+        if (header != null) {
+            if ((header).nonce != null) {
+                challengeDigest = new byte[16];
+                System.arraycopy((header).nonce, 0, challengeDigest, 0, 16);
+            }
+            // Add the connection ID if one exists
+            if (connectionID != null) {
+                (header).connectionID = new byte[4];
+                System.arraycopy(connectionID, 0, (header).connectionID, 0, 4);
+            }
+            head = OBEXHelper.createHeader(header, false);
+
+            if ((head.length + 3) > maxPacketSize) {
+                throw new IOException("Packet size exceeds max packet size");
+            }
+        } else {
+            // Add the connection ID if one exists
+            if (connectionID != null) {
+                head = new byte[5];
+                head[0] = (byte)0xCB;
+                System.arraycopy(connectionID, 0, head, 1, 4);
+            }
+        }
+
+        HeaderSet returnHeaderSet = new HeaderSet();
+        sendRequest(0x81, head, returnHeaderSet, null);
+
+        /*
+        * An OBEX DISCONNECT reply from the server:
+        * Byte 1: Response code
+        * Bytes 2 & 3: packet size
+        * Bytes 4 & up: headers
+        */
+
+        /* response code , and header are ignored
+         * */
+
+        synchronized (this) {
+            isConnected = false;
+            isActive = false;
+        }
+
+        return returnHeaderSet;
+    }
+
+    public long getConnectionID() {
+
+        if (connectionID == null) {
+            return -1;
+        }
+        return OBEXHelper.convertToLong(connectionID);
+    }
+
+    public Operation put(HeaderSet header) throws java.io.IOException {
+        if (!isConnected) {
+            throw new IOException("Not connected to the server");
+        }
+        synchronized (this) {
+            if (isActive) {
+                throw new IOException("OBEX request is already being performed");
+            }
+            isActive = true;
+        }
+
+        ensureOpen();
+
+        if (header == null) {
+            header = new HeaderSet();
+        } else {
+            // when auth is initated by client ,save the digest 
+            if ((header).nonce != null) {
+                challengeDigest = new byte[16];
+                System.arraycopy((header).nonce, 0, challengeDigest, 0, 16);
+            }
+        }
+
+        // Add the connection ID if one exists
+        if (connectionID != null) {
+
+            (header).connectionID = new byte[4];
+            System.arraycopy(connectionID, 0, (header).connectionID, 0, 4);
+        }
+
+        //       this.mode = javax.microedition.io.Connector.WRITE ;
+        return new ClientOperation(input, maxPacketSize, this, header, false);
+    }
+
+    public void setAuthenticator(Authenticator auth) {
+        if (auth == null) {
+            throw new NullPointerException("Authenticator may not be null");
+        }
+        authenticator = auth;
+    }
+
+    public HeaderSet setPath(HeaderSet header, boolean backup, boolean create)
+            throws java.io.IOException {
+        if (!isConnected) {
+            throw new IOException("Not connected to the server");
+        }
+        synchronized (this) {
+            if (isActive) {
+                throw new IOException("OBEX request is already being performed");
+            }
+            isActive = true;
+        }
+
+        ensureOpen();
+
+        int totalLength = 2;
+        byte[] head = null;
+
+        if (header == null) {
+            header = new HeaderSet();
+        } else {
+            if ((header).nonce != null) {
+                challengeDigest = new byte[16];
+                System.arraycopy((header).nonce, 0, challengeDigest, 0, 16);
+            }
+        }
+
+        // when auth is initiated by client ,save the digest
+        if ((header).nonce != null) {
+            challengeDigest = new byte[16];
+            System.arraycopy((header).nonce, 0, challengeDigest, 0, 16);
+        }
+
+        // Add the connection ID if one exists
+        if (connectionID != null) {
+            (header).connectionID = new byte[4];
+            System.arraycopy(connectionID, 0, (header).connectionID, 0, 4);
+        }
+
+        head = OBEXHelper.createHeader(header, false);
+        totalLength += head.length;
+
+        if (totalLength > maxPacketSize) {
+            throw new IOException("Packet size exceeds max packet size");
+        }
+
+        int flags = 0;
+        /*
+         * The backup flag bit is bit 0 so if we add 1, this will set that bit
+         */
+        if (backup) {
+            flags++;
+        }
+        /*
+         * The create bit is bit 1 so if we or with 2 the bit will be set.
+         */
+        if (!create) {
+            flags |= 2;
+        }
+
+        /*
+         * An OBEX SETPATH packet to the server:
+         * Byte 1: 0x85
+         * Byte 2 & 3: packet size
+         * Byte 4: flags
+         * Byte 5: constants
+         * Byte 6 & up: headers
+         */
+        byte[] packet = new byte[totalLength];
+        packet[0] = (byte)flags;
+        packet[1] = (byte)0x00;
+        if (header != null) {
+            System.arraycopy(head, 0, packet, 2, head.length);
+        }
+
+        HeaderSet returnHeaderSet = new HeaderSet();
+        sendRequest(0x85, packet, returnHeaderSet, null);
+
+        /*
+         * An OBEX SETPATH reply from the server:
+         * Byte 1: Response code
+         * Bytes 2 & 3: packet size
+         * Bytes 4 & up: headers
+         */
+
+        synchronized (this) {
+            isActive = false;
+        }
+
+        return returnHeaderSet;
+    }
+
+    /**
+     * Verifies that the connection is open.
+     *
+     * @exception IOException if the connection is closed
+     */
+    public synchronized void ensureOpen() throws IOException {
+        if (!connectionOpen) {
+            throw new IOException("Connection closed");
+        }
+    }
+
+    /**
+     * Sets the active mode to off.  This allows Put and get operation objects
+     * to tell this object when they are done.
+     */
+    public void setInactive() {
+        synchronized (this) {
+            isActive = false;
+        }
+    }
+
+    /**
+     * Sends a standard request to the client.  It will then wait for the reply
+     * and update the header set object provided.  If any authentication
+     * headers (i.e. authentication challenge or authentication response) are
+     * received, they will be processed.
+     *
+     * @param code the type of request to send to the client
+     *
+     * @param head the headers to send to the server
+     *
+     * @param challenge the nonce that was sent in the authentication
+     * challenge header located in <code>head</code>; <code>null</code>
+     * if no authentication header is included in <code>head</code>
+     *
+     * @param headers the header object to update with the response
+     *
+     * @param input the input stream used by the Operation object; null if this
+     * is called on a CONNECT, SETPATH or DISCONNECT
+     *
+     * return <code>true</code> if the operation completed successfully;
+     * <code>false</code> if an authentication response failed to pass
+     *
+     * @exception IOException if an IO error occurs
+     */
+    public boolean sendRequest(int code, byte[] head, HeaderSet headers,
+            PrivateInputStream privateInput) throws IOException {
+        //check header length with local max size
+        if (head != null) {
+            if ((head.length + 3) > OBEXConstants.MAX_PACKET_SIZE_INT) {
+                throw new IOException("header too large ");
+            }
+        }
+        //byte[] nonce;
+        int bytesReceived;
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        out.write((byte)code);
+
+        // Determine if there are any headers to send
+        if (head == null) {
+            out.write(0x00);
+            out.write(0x03);
+        } else {
+            out.write((byte)((head.length + 3) >> 8));
+            out.write((byte)(head.length + 3));
+            out.write(head);
+        }
+
+        // Write the request to the output stream and flush the stream
+        output.write(out.toByteArray());
+        output.flush();
+
+        headers.responseCode = input.read();
+
+        int length = ((input.read() << 8) | (input.read()));
+
+        if (length > OBEXConstants.MAX_PACKET_SIZE_INT) {
+            throw new IOException("Packet received exceeds packet size limit");
+        }
+        if (length > 3) {
+            byte[] data = null;
+            if (code == 0x80) {
+                int version = input.read();
+                int flags = input.read();
+                maxPacketSize = (input.read() << 8) + input.read();
+
+                //check with local max size
+                if (maxPacketSize > OBEXConstants.MAX_PACKET_SIZE_INT) {
+                    maxPacketSize = OBEXConstants.MAX_PACKET_SIZE_INT;
+                }
+
+                if (length > 7) {
+                    data = new byte[length - 7];
+
+                    bytesReceived = input.read(data);
+                    while (bytesReceived != (length - 7)) {
+                        bytesReceived += input.read(data, bytesReceived, data.length
+                                - bytesReceived);
+                    }
+                } else {
+                    return true;
+                }
+            } else {
+                data = new byte[length - 3];
+                bytesReceived = input.read(data);
+
+                while (bytesReceived != (length - 3)) {
+                    bytesReceived += input.read(data, bytesReceived, data.length - bytesReceived);
+                }
+                if (code == 0xFF) {
+                    return true;
+                }
+            }
+
+            byte[] body = OBEXHelper.updateHeaderSet(headers, data);
+            if ((privateInput != null) && (body != null)) {
+                privateInput.writeBytes(body, 1);
+            }
+
+            if (headers.connectionID != null) {
+                connectionID = new byte[4];
+                System.arraycopy(headers.connectionID, 0, connectionID, 0, 4);
+            }
+
+            if (headers.authResp != null) {
+                if (!handleAuthResp(headers.authResp)) {
+                    setInactive();
+                    throw new IOException("Authentication Failed");
+                }
+            }
+
+            if ((headers.responseCode == ResponseCodes.OBEX_HTTP_UNAUTHORIZED)
+                    && (headers.authChall != null)) {
+
+                if (handleAuthChall(headers)) {
+                    out.write((byte)0x4E);
+                    out.write((byte)((headers.authResp.length + 3) >> 8));
+                    out.write((byte)(headers.authResp.length + 3));
+                    out.write(headers.authResp);
+                    headers.authChall = null;
+                    headers.authResp = null;
+
+                    byte[] sendHeaders = new byte[out.size() - 3];
+                    System.arraycopy(out.toByteArray(), 3, sendHeaders, 0, sendHeaders.length);
+
+                    return sendRequest(code, sendHeaders, headers, privateInput);
+                }
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Called when the client received an authentication challenge header.  This
+     * will cause the authenticator to handle the authentication challenge.
+     *
+     * @param header the header with the authentication challenge
+     *
+     * @return <code>true</code> if the last request should be resent;
+     * <code>false</code> if the last request should not be resent
+     */
+    protected boolean handleAuthChall(HeaderSet header) {
+
+        if (authenticator == null) {
+            return false;
+        }
+
+        /*
+         * An authentication challenge is made up of one required and two
+         * optional tag length value triplets.  The tag 0x00 is required to be
+         * in the authentication challenge and it represents the challenge
+         * digest that was received.  The tag 0x01 is the options tag.  This
+         * tag tracks if user ID is required and if full access will be
+         * granted.  The tag 0x02 is the realm, which provides a description of
+         * which user name and password to use.
+         */
+        byte[] challenge = OBEXHelper.getTagValue((byte)0x00, header.authChall);
+        byte[] option = OBEXHelper.getTagValue((byte)0x01, header.authChall);
+        byte[] description = OBEXHelper.getTagValue((byte)0x02, header.authChall);
+
+        String realm = "";
+        if (description != null) {
+            byte[] realmString = new byte[description.length - 1];
+            System.arraycopy(description, 1, realmString, 0, realmString.length);
+
+            switch (description[0] & 0xFF) {
+
+                case 0x00:
+                    // ASCII encoding
+                    // Fall through
+                case 0x01:
+                    // ISO-8859-1 encoding
+                    try {
+                        realm = new String(realmString, "ISO8859_1");
+                    } catch (Exception e) {
+                        throw new RuntimeException("Unsupported Encoding Scheme");
+                    }
+                    break;
+
+                case 0xFF:
+                    // UNICODE Encoding
+                    realm = OBEXHelper.convertToUnicode(realmString, false);
+                    break;
+
+                case 0x02:
+                    // ISO-8859-2 encoding
+                    // Fall through
+                case 0x03:
+                    // ISO-8859-3 encoding
+                    // Fall through
+                case 0x04:
+                    // ISO-8859-4 encoding
+                    // Fall through
+                case 0x05:
+                    // ISO-8859-5 encoding
+                    // Fall through
+                case 0x06:
+                    // ISO-8859-6 encoding
+                    // Fall through
+                case 0x07:
+                    // ISO-8859-7 encoding
+                    // Fall through
+                case 0x08:
+                    // ISO-8859-8 encoding
+                    // Fall through
+                case 0x09:
+                    // ISO-8859-9 encoding
+                    // Fall through
+                default:
+                    throw new RuntimeException("Unsupported Encoding Scheme");
+            }
+        }
+
+        boolean isUserIDRequired = false;
+        boolean isFullAccess = true;
+        if (option != null) {
+            if ((option[0] & 0x01) != 0) {
+                isUserIDRequired = true;
+            }
+
+            if ((option[0] & 0x02) != 0) {
+                isFullAccess = false;
+            }
+        }
+
+        PasswordAuthentication result = null;
+        header.authChall = null;
+
+        try {
+            result = authenticator.onAuthenticationChallenge(realm, isUserIDRequired, isFullAccess);
+        } catch (Exception e) {
+            return false;
+        }
+
+        /*
+         * If no password was provided then do not resend the request
+         */
+        if (result == null) {
+            return false;
+        }
+
+        byte[] password = result.getPassword();
+        if (password == null) {
+            return false;
+        }
+
+        byte[] userName = result.getUserName();
+
+        /*
+         * Create the authentication response header.  It includes 1 required
+         * and 2 option tag length value triples.  The required triple has a
+         * tag of 0x00 and is the response digest.  The first optional tag is
+         * 0x01 and represents the user ID.  If no user ID is provided, then
+         * no user ID will be sent.  The second optional tag is 0x02 and is the
+         * challenge that was received.  This will always be sent
+         */
+        if (userName != null) {
+            header.authResp = new byte[38 + userName.length];
+            header.authResp[36] = (byte)0x01;
+            header.authResp[37] = (byte)userName.length;
+            System.arraycopy(userName, 0, header.authResp, 38, userName.length);
+        } else {
+            header.authResp = new byte[36];
+        }
+
+        // Create the secret String
+        byte[] digest = new byte[challenge.length + password.length];
+        System.arraycopy(challenge, 0, digest, 0, challenge.length);
+        System.arraycopy(password, 0, digest, challenge.length, password.length);
+
+        // Add the Response Digest
+        header.authResp[0] = (byte)0x00;
+        header.authResp[1] = (byte)0x10;
+
+        byte[] responseDigest = OBEXHelper.computeMD5Hash(digest);
+        System.arraycopy(responseDigest, 0, header.authResp, 2, 16);
+
+        // Add the challenge
+        header.authResp[18] = (byte)0x02;
+        header.authResp[19] = (byte)0x10;
+        System.arraycopy(challenge, 0, header.authResp, 20, 16);
+
+        return true;
+    }
+
+    /**
+     * Called when the client received an authentication response header.  This
+     * will cause the authenticator to handle the authentication response.
+     *
+     * @param authResp the authentication response
+     *
+     * @return <code>true</code> if the response passed; <code>false</code> if
+     * the response failed
+     */
+    protected boolean handleAuthResp(byte[] authResp) {
+        if (authenticator == null) {
+            return false;
+        }
+
+        byte[] correctPassword = authenticator.onAuthenticationResponse(OBEXHelper.getTagValue(
+                (byte)0x01, authResp));
+        if (correctPassword == null) {
+            return false;
+        }
+
+        byte[] temp = new byte[correctPassword.length + 16];
+        System.arraycopy(challengeDigest, 0, temp, 0, 16);
+        System.arraycopy(correctPassword, 0, temp, 16, correctPassword.length);
+
+        byte[] correctResponse = OBEXHelper.computeMD5Hash(temp);
+        byte[] actualResponse = OBEXHelper.getTagValue((byte)0x00, authResp);
+        for (int i = 0; i < 16; i++) {
+            if (correctResponse[i] != actualResponse[i]) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    public void close() throws IOException {
+        connectionOpen = false;
+        input.close();
+        output.close();
+        //client.close();
+    }
+}
diff --git a/obex/javax/obex/HeaderSet.java b/obex/javax/obex/HeaderSet.java
new file mode 100644
index 0000000..07abe15
--- /dev/null
+++ b/obex/javax/obex/HeaderSet.java
@@ -0,0 +1,610 @@
+/*
+ * Copyright (c) 2008-2009, Motorola, Inc.
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the Motorola, Inc. nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package javax.obex;
+
+import java.io.*;
+import java.util.*;
+
+/**
+ * This class implements the javax.obex.HeaderSet interface for OBEX over
+ * RFCOMM.
+ *
+ * @version 0.3 November 28, 2008
+ */
+public final class HeaderSet {
+
+    /**
+     * Represents the OBEX Count header.  This allows the connection statement
+     * to tell the server how many objects it plans to send or retrieve.
+     * <P>
+     * The value of <code>COUNT</code> is 0xC0 (192).
+     */
+    public static final int COUNT = 0xC0;
+
+    /**
+     * Represents the OBEX Name header.  This specifies the name of the object.
+     * <P>
+     * The value of <code>NAME</code> is 0x01 (1).
+     */
+    public static final int NAME = 0x01;
+
+    /**
+     * Represents the OBEX Type header.  This allows a request to specify the
+     * type of the object (e.g. text, html, binary, etc.).
+     * <P>
+     * The value of <code>TYPE</code> is 0x42 (66).
+     */
+    public static final int TYPE = 0x42;
+
+    /**
+     * Represents the OBEX Length header.  This is the length of the object in
+     * bytes.
+     * <P>
+     * The value of <code>LENGTH</code> is 0xC3 (195).
+     */
+    public static final int LENGTH = 0xC3;
+
+    /**
+     * Represents the OBEX Time header using the ISO 8601 standards.  This is
+     * the preferred time header.
+     * <P>
+     * The value of <code>TIME_ISO_8601</code> is 0x44 (68).
+     */
+    public static final int TIME_ISO_8601 = 0x44;
+
+    /**
+     * Represents the OBEX Time header using the 4 byte representation.  This
+     * is only included for backwards compatibility.  It represents the number
+     * of seconds since January 1, 1970.
+     * <P>
+     * The value of <code>TIME_4_BYTE</code> is 0xC4 (196).
+     */
+    public static final int TIME_4_BYTE = 0xC4;
+
+    /**
+     * Represents the OBEX Description header.  This is a text description of
+     * the object.
+     * <P>
+     * The value of <code>DESCRIPTION</code> is 0x05 (5).
+     */
+    public static final int DESCRIPTION = 0x05;
+
+    /**
+     * Represents the OBEX Target header.  This is the name of the service an
+     * operation is targeted to.
+     * <P>
+     * The value of <code>TARGET</code> is 0x46 (70).
+     */
+    public static final int TARGET = 0x46;
+
+    /**
+     * Represents the OBEX HTTP header.  This allows an HTTP 1.X header to be
+     * included in a request or reply.
+     * <P>
+     * The value of <code>HTTP</code> is 0x47 (71).
+     */
+    public static final int HTTP = 0x47;
+
+    /**
+     * Represents the OBEX Who header.  Identifies the OBEX application to
+     * determine if the two peers are talking to each other.
+     * <P>
+     * The value of <code>WHO</code> is 0x4A (74).
+     */
+    public static final int WHO = 0x4A;
+
+    /**
+     * Represents the OBEX Object Class header.  This header specifies the
+     * OBEX object class of the object.
+     * <P>
+     * The value of <code>OBJECT_CLASS</code> is 0x4F (79).
+     */
+    public static final int OBJECT_CLASS = 0x4F;
+
+    /**
+     * Represents the OBEX Application Parameter header.  This header specifies
+     * additional application request and response information.
+     * <P>
+     * The value of <code>APPLICATION_PARAMETER</code> is 0x4C (76).
+     */
+    public static final int APPLICATION_PARAMETER = 0x4C;
+
+    private Long count; // 4 byte unsigned integer
+
+    private String name; // null terminated Unicode text string
+
+    private String type; // null terminated ASCII text string
+
+    private Long length; // 4 byte unsigend integer
+
+    private Calendar isoTime; // String of the form YYYYMMDDTHHMMSSZ
+
+    private Calendar byteTime; // 4 byte unsigned integer
+
+    private String description; // null terminated Unicode text String
+
+    private byte[] target; // byte sequence
+
+    private byte[] http; // byte sequence
+
+    private byte[] who; // length prefixed byte sequence
+
+    private byte[] appParam; // byte sequence of the form tag length
+
+    //value
+    public byte[] authChall; // The authentication challenge header
+
+    public byte[] authResp; // The authentication response header
+
+    public byte[] connectionID; // THe connection ID
+
+    private byte[] objectClass; // byte sequence
+
+    private String[] unicodeUserDefined; //null terminated unicode string
+
+    private byte[][] sequenceUserDefined; // byte sequence user defined
+
+    private Byte[] byteUserDefined; // 1 byte
+
+    private Long[] integerUserDefined; // 4 byte unsigned integer
+
+    public int responseCode;
+
+    public byte[] nonce;
+
+    private Random random;
+
+    /**
+     * Creates new <code>HeaderSet</code> object.
+     *
+     * @param size the max packet size for this connection
+     */
+    public HeaderSet() {
+        unicodeUserDefined = new String[16];
+        sequenceUserDefined = new byte[16][];
+        byteUserDefined = new Byte[16];
+        integerUserDefined = new Long[16];
+        responseCode = -1;
+        random = new Random();
+    }
+
+    /**
+     * Sets the value of the header identifier to the value provided.  The type
+     * of object must correspond to the Java type defined in the description of
+     * this interface.  If <code>null</code> is passed as the
+     * <code>headerValue</code> then the header will be removed from the set of
+     * headers to include in the next request.
+     *
+     * @param headerID the identifier to include in the message
+     *
+     * @param headerValue the value of the header identifier
+     *
+     * @exception IllegalArgumentException if the header identifier provided is
+     * not one defined in this interface or a user-defined header; if the type of
+     * <code>headerValue</code> is not the correct Java type as defined in the
+     * description of this interface\
+     */
+    public void setHeader(int headerID, Object headerValue) {
+        long temp = -1;
+
+        switch (headerID) {
+            case COUNT:
+                if (!(headerValue instanceof Long)) {
+                    if (headerValue == null) {
+                        count = null;
+                        break;
+                    }
+                    throw new IllegalArgumentException("Count must be a Long");
+                }
+                temp = ((Long)headerValue).longValue();
+                if ((temp < 0L) || (temp > 0xFFFFFFFFL)) {
+                    throw new IllegalArgumentException("Count must be between 0 and 0xFFFFFFFF");
+                }
+                count = (Long)headerValue;
+                break;
+            case NAME:
+                if ((headerValue != null) && (!(headerValue instanceof String))) {
+                    throw new IllegalArgumentException("Name must be a String");
+                }
+                name = (String)headerValue;
+                break;
+            case TYPE:
+                if ((headerValue != null) && (!(headerValue instanceof String))) {
+                    throw new IllegalArgumentException("Type must be a String");
+                }
+                type = (String)headerValue;
+                break;
+            case LENGTH:
+                if (!(headerValue instanceof Long)) {
+                    if (headerValue == null) {
+                        length = null;
+                        break;
+                    }
+                    throw new IllegalArgumentException("Length must be a Long");
+                }
+                temp = ((Long)headerValue).longValue();
+                if ((temp < 0L) || (temp > 0xFFFFFFFFL)) {
+                    throw new IllegalArgumentException("Length must be between 0 and 0xFFFFFFFF");
+                }
+                length = (Long)headerValue;
+                break;
+            case TIME_ISO_8601:
+                if ((headerValue != null) && (!(headerValue instanceof Calendar))) {
+                    throw new IllegalArgumentException("Time ISO 8601 must be a Calendar");
+                }
+                isoTime = (Calendar)headerValue;
+                break;
+            case TIME_4_BYTE:
+                if ((headerValue != null) && (!(headerValue instanceof Calendar))) {
+                    throw new IllegalArgumentException("Time 4 Byte must be a Calendar");
+                }
+                byteTime = (Calendar)headerValue;
+                break;
+            case DESCRIPTION:
+                if ((headerValue != null) && (!(headerValue instanceof String))) {
+                    throw new IllegalArgumentException("Description must be a String");
+                }
+                description = (String)headerValue;
+                break;
+            case TARGET:
+                if (headerValue == null) {
+                    target = null;
+                } else {
+                    if (!(headerValue instanceof byte[])) {
+                        throw new IllegalArgumentException("Target must be a byte array");
+                    } else {
+                        target = new byte[((byte[])headerValue).length];
+                        System.arraycopy(headerValue, 0, target, 0, target.length);
+                    }
+                }
+                break;
+            case HTTP:
+                if (headerValue == null) {
+                    http = null;
+                } else {
+                    if (!(headerValue instanceof byte[])) {
+                        throw new IllegalArgumentException("HTTP must be a byte array");
+                    } else {
+                        http = new byte[((byte[])headerValue).length];
+                        System.arraycopy(headerValue, 0, http, 0, http.length);
+                    }
+                }
+                break;
+            case WHO:
+                if (headerValue == null) {
+                    who = null;
+                } else {
+                    if (!(headerValue instanceof byte[])) {
+                        throw new IllegalArgumentException("WHO must be a byte array");
+                    } else {
+                        who = new byte[((byte[])headerValue).length];
+                        System.arraycopy(headerValue, 0, who, 0, who.length);
+                    }
+                }
+                break;
+            case OBJECT_CLASS:
+                if (headerValue == null) {
+                    objectClass = null;
+                } else {
+                    if (!(headerValue instanceof byte[])) {
+                        throw new IllegalArgumentException("Object Class must be a byte array");
+                    } else {
+                        objectClass = new byte[((byte[])headerValue).length];
+                        System.arraycopy(headerValue, 0, objectClass, 0, objectClass.length);
+                    }
+                }
+                break;
+            case APPLICATION_PARAMETER:
+                if (headerValue == null) {
+                    appParam = null;
+                } else {
+                    if (!(headerValue instanceof byte[])) {
+                        throw new IllegalArgumentException(
+                                "Application Parameter must be a byte array");
+                    } else {
+                        appParam = new byte[((byte[])headerValue).length];
+                        System.arraycopy(headerValue, 0, appParam, 0, appParam.length);
+                    }
+                }
+                break;
+            default:
+                // Verify that it was not a Unicode String user Defined
+                if ((headerID >= 0x30) && (headerID <= 0x3F)) {
+                    if ((headerValue != null) && (!(headerValue instanceof String))) {
+                        throw new IllegalArgumentException(
+                                "Unicode String User Defined must be a String");
+                    }
+                    unicodeUserDefined[headerID - 0x30] = (String)headerValue;
+
+                    break;
+                }
+                // Verify that it was not a byte sequence user defined value
+                if ((headerID >= 0x70) && (headerID <= 0x7F)) {
+
+                    if (headerValue == null) {
+                        sequenceUserDefined[headerID - 0x70] = null;
+                    } else {
+                        if (!(headerValue instanceof byte[])) {
+                            throw new IllegalArgumentException(
+                                    "Byte Sequence User Defined must be a byte array");
+                        } else {
+                            sequenceUserDefined[headerID - 0x70] = new byte[((byte[])headerValue).length];
+                            System.arraycopy(headerValue, 0, sequenceUserDefined[headerID - 0x70],
+                                    0, sequenceUserDefined[headerID - 0x70].length);
+                        }
+                    }
+                    break;
+                }
+                // Verify that it was not a Byte user Defined
+                if ((headerID >= 0xB0) && (headerID <= 0xBF)) {
+                    if ((headerValue != null) && (!(headerValue instanceof Byte))) {
+                        throw new IllegalArgumentException("ByteUser Defined must be a Byte");
+                    }
+                    byteUserDefined[headerID - 0xB0] = (Byte)headerValue;
+
+                    break;
+                }
+                // Verify that is was not the 4 byte unsigned integer user
+                // defined header
+                if ((headerID >= 0xF0) && (headerID <= 0xFF)) {
+                    if (!(headerValue instanceof Long)) {
+                        if (headerValue == null) {
+                            integerUserDefined[headerID - 0xF0] = null;
+                            break;
+                        }
+                        throw new IllegalArgumentException("Integer User Defined must be a Long");
+                    }
+                    temp = ((Long)headerValue).longValue();
+                    if ((temp < 0L) || (temp > 0xFFFFFFFFL)) {
+                        throw new IllegalArgumentException(
+                                "Integer User Defined must be between 0 and 0xFFFFFFFF");
+                    }
+                    integerUserDefined[headerID - 0xF0] = (Long)headerValue;
+                    break;
+                }
+                throw new IllegalArgumentException("Invalid Header Identifier");
+        }
+    }
+
+    /**
+     * Retrieves the value of the header identifier provided.  The type of the
+     * Object returned is defined in the description of this interface.
+     *
+     * @param headerID the header identifier whose value is to be returned
+     *
+     * @return the value of the header provided or <code>null</code> if the
+     * header identifier specified is not part of this <code>HeaderSet</code>
+     * object
+     *
+     * @exception IllegalArgumentException if the <code>headerID</code> is not
+     * one defined in this interface or any of the user-defined headers
+     *
+     * @exception IOException if an error occurred in the transport layer during
+     * the operation or if the connection has been closed
+     */
+    public Object getHeader(int headerID) throws IOException {
+
+        switch (headerID) {
+            case COUNT:
+                return count;
+            case NAME:
+                return name;
+            case TYPE:
+                return type;
+            case LENGTH:
+                return length;
+            case TIME_ISO_8601:
+                return isoTime;
+            case TIME_4_BYTE:
+                return byteTime;
+            case DESCRIPTION:
+                return description;
+            case TARGET:
+                return target;
+            case HTTP:
+                return http;
+            case WHO:
+                return who;
+            case OBJECT_CLASS:
+                return objectClass;
+            case APPLICATION_PARAMETER:
+                return appParam;
+            default:
+                // Verify that it was not a Unicode String user Defined
+                if ((headerID >= 0x30) && (headerID <= 0x3F)) {
+                    return unicodeUserDefined[headerID - 0x30];
+                }
+                // Verify that it was not a byte sequence user defined header
+                if ((headerID >= 0x70) && (headerID <= 0x7F)) {
+                    return sequenceUserDefined[headerID - 0x70];
+                }
+                // Verify that it was not a byte user defined header
+                if ((headerID >= 0xB0) && (headerID <= 0xBF)) {
+                    return byteUserDefined[headerID - 0xB0];
+                }
+                // Verify that it was not a itneger user defined header
+                if ((headerID >= 0xF0) && (headerID <= 0xFF)) {
+                    return integerUserDefined[headerID - 0xF0];
+                }
+                throw new IllegalArgumentException("Invalid Header Identifier");
+        }
+    }
+
+    /**
+     * Retrieves the list of headers that may be retrieved via the
+     * <code>getHeader</code> method that will not return <code>null</code>.
+     * In other words, this method returns all the headers that are available
+     * in this object.
+     *
+     * @see #getHeader
+     *
+     * @return the array of headers that are set in this object or
+     * <code>null</code> if no headers are available
+     *
+     * @exception IOException if an error occurred in the transport layer during
+     * the operation or the connection has been closed
+     */
+    public int[] getHeaderList() throws IOException {
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+
+        if (count != null) {
+            out.write(COUNT);
+        }
+        if (name != null) {
+            out.write(NAME);
+        }
+        if (type != null) {
+            out.write(TYPE);
+        }
+        if (length != null) {
+            out.write(LENGTH);
+        }
+        if (isoTime != null) {
+            out.write(TIME_ISO_8601);
+        }
+        if (byteTime != null) {
+            out.write(TIME_4_BYTE);
+        }
+        if (description != null) {
+            out.write(DESCRIPTION);
+        }
+        if (target != null) {
+            out.write(TARGET);
+        }
+        if (http != null) {
+            out.write(HTTP);
+        }
+        if (who != null) {
+            out.write(WHO);
+        }
+        if (appParam != null) {
+            out.write(APPLICATION_PARAMETER);
+        }
+        if (objectClass != null) {
+            out.write(OBJECT_CLASS);
+        }
+
+        for (int i = 0x30; i < 0x40; i++) {
+            if (unicodeUserDefined[i - 0x30] != null) {
+                out.write(i);
+            }
+        }
+
+        for (int i = 0x70; i < 0x80; i++) {
+            if (sequenceUserDefined[i - 0x70] != null) {
+                out.write(i);
+            }
+        }
+
+        for (int i = 0xB0; i < 0xC0; i++) {
+            if (byteUserDefined[i - 0xB0] != null) {
+                out.write(i);
+            }
+        }
+
+        for (int i = 0xF0; i < 0x100; i++) {
+            if (integerUserDefined[i - 0xF0] != null) {
+                out.write(i);
+            }
+        }
+
+        byte[] headers = out.toByteArray();
+        out.close();
+
+        if ((headers == null) || (headers.length == 0)) {
+            return null;
+        }
+
+        int[] result = new int[headers.length];
+        for (int i = 0; i < headers.length; i++) {
+            // Convert the byte to a positive integer.  That is, an integer
+            // between 0 and 256.
+            result[i] = headers[i] & 0xFF;
+        }
+
+        return result;
+    }
+
+    /**
+     * Sets the authentication challenge header.  The <code>realm</code> will
+     * be encoded based upon the default encoding scheme used by the
+     * implementation to encode strings.  Therefore, the encoding scheme used
+     * to encode the <code>realm</code> is application dependent.
+     *
+     * @param realm a short description that describes what password to use; if
+     * <code>null</code> no realm will be sent in the authentication challenge
+     * header
+     *
+     * @param userID if <code>true</code>, a user ID is required in the reply;
+     * if <code>false</code>, no user ID is required
+     *
+     * @param access if <code>true</code> then full access will be granted if
+     * successful; if <code>false</code> then read-only access will be granted
+     * if successful
+     */
+    public void createAuthenticationChallenge(String realm, boolean userID, boolean access) {
+
+        try {
+            nonce = new byte[16];
+            for (int i = 0; i < 16; i++) {
+                nonce[i] = (byte)random.nextInt();
+            }
+
+            authChall = OBEXHelper.computeAuthenticationChallenge(nonce, realm, access, userID);
+        } catch (IOException e) {
+            throw new RuntimeException(e.getMessage());
+        }
+    }
+
+    /**
+     * Returns the response code received from the server.  Response codes
+     * are defined in the <code>ResponseCodes</code> class.
+     *
+     * @see ResponseCodes
+     *
+     * @return the response code retrieved from the server
+     *
+     * @exception IOException if an error occurred in the transport layer during
+     * the transaction; if this method is called on a <code>HeaderSet</code>
+     * object created by calling <code>createHeaderSet()</code> in a
+     * <code>ClientSession</code> object; if this object was created by an OBEX
+     * server
+     */
+    public int getResponseCode() throws IOException {
+        if (responseCode == -1) {
+            throw new IOException("May not be called on a server");
+        } else {
+            return responseCode;
+        }
+    }
+}
diff --git a/obex/javax/obex/OBEXConstants.java b/obex/javax/obex/OBEXConstants.java
new file mode 100644
index 0000000..2da5f30
--- /dev/null
+++ b/obex/javax/obex/OBEXConstants.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2008-2009, Motorola, Inc.
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the Motorola, Inc. nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package javax.obex;
+
+/**
+ * This class implements the <code>Operation</code> interface.  It will read
+ * and write data via puts and gets.
+ *
+ * @version 0.3 November 28, 2008
+ */
+public class OBEXConstants {
+    /**
+     * Defines the OBEX CONTINUE response code.
+     * <P>
+     * The value of <code>OBEX_HTTP_CONTINUE</code> is 0x90 (144).
+     */
+    public static final int OBEX_HTTP_CONTINUE = 0x90;
+
+    /**
+     * The maximum packet size for OBEX packets that this client can handle.
+     * At present, this must be changed for each port.
+     *
+     * OPTIMIZATION: The max packet size should be the Max incoming MTU minus
+     * OPTIMIZATION: L2CAP package headers and RFCOMM package headers.
+     *
+     * OPTIMIZATION: Retrieve the max incoming MTU from
+     * OPTIMIZATION: LocalDevice.getProperty().
+     */
+    /** android note
+     *  set as 0xFFFE to match remote MPS
+     */
+    //public static final byte[] MAX_PACKET_SIZE = {0x01, 0x00};  // To be removed
+    //public static final int MAX_PACKET_SIZE_INT = 667*6;//0x0100; 
+    public static final int MAX_PACKET_SIZE_INT = 0xFFFE;
+
+    /**
+     * The number of server parser threads that may be active at one time.
+     * This should be changed for each port.
+     *
+     * OPTIMIZATION: Retrieve this value by a native call to the KOSI layer.
+     */
+    public static final int MAX_PARSER_THREADS = 5;
+
+}
diff --git a/obex/javax/obex/OBEXHelper.java b/obex/javax/obex/OBEXHelper.java
new file mode 100644
index 0000000..5c413af
--- /dev/null
+++ b/obex/javax/obex/OBEXHelper.java
@@ -0,0 +1,1326 @@
+/*
+ * Copyright (c) 2008-2009, Motorola, Inc.
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the Motorola, Inc. nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package javax.obex;
+
+import java.io.*;
+import java.util.*;
+
+/**
+ * This class defines a set of helper methods for the implementation of OBEX.
+ *
+ * @version 0.3 November 28, 2008
+ */
+public class OBEXHelper {
+
+    /**
+     * Creates new OBEXHelper
+     */
+    private OBEXHelper() {
+    }
+
+    private static final String TAG = "OBEXHelper";
+
+    /**
+     * Updates the HeaderSet with the headers received in the byte array
+     * provided.  Invalid headers are ignored.
+     * <P>
+     * The first two bits of an OBEX Header specifies the type of object that
+     * is being sent.  The table below specifies the meaning of the high
+     * bits.
+     * <TABLE>
+     * <TR><TH>Bits 8 and 7</TH><TH>Value</TH><TH>Description</TH></TR>
+     * <TR><TD>00</TD><TD>0x00</TD><TD>Null Terminated Unicode text, prefixed
+     * with 2 byte unsigned integer</TD></TR>
+     * <TR><TD>01</TD><TD>0x40</TD><TD>Byte Sequence, length prefixed with
+     * 2 byte unsigned integer</TD></TR>
+     * <TR><TD>10</TD><TD>0x80</TD><TD>1 byte quantity</TD></TR>
+     * <TR><TD>11</TD><TD>0xC0</TD><TD>4 byte quantity - transmitted in
+     * network byte order (high byte first</TD></TR>
+     * </TABLE>
+     * This method uses the information in this table to determine the type of
+     * Java object to create and passes that object with the full header
+     * to setHeader() to update the HeaderSet object.  Invalid headers will
+     * cause an exception to be thrown.  When it is thrown, it is ignored.
+     *
+     * @param header the HeaderSet to update
+     *
+     * @param headerArray the byte array containing headers
+     *
+     * @return the result of the last start body or end body header provided;
+     * the first byte in the result will specify if a body or end of body is
+     * received
+     *
+     * @exception IOException if an invalid header was found
+     */
+    public static byte[] updateHeaderSet(HeaderSet header, byte[] headerArray) throws IOException {
+        int index = 0;
+        int length = 0;
+        int headerID;
+        byte[] value = null;
+        byte[] body = null;
+        HeaderSet headerImpl = header;
+        try {
+            while (index < headerArray.length) {
+                headerID = 0xFF & headerArray[index];
+                switch (headerID & (0xC0)) {
+
+                    /*
+                     * 0x00 is a unicode null terminate string with the first
+                     * two bytes after the header identifier being the length
+                     */
+                    case 0x00:
+                        // Fall through
+                        /*
+                         * 0x40 is a byte sequence with the first
+                         * two bytes after the header identifier being the length
+                         */
+                    case 0x40:
+                        boolean trimTail = true;
+                        index++;
+                        length = 0xFF & headerArray[index];
+                        length = length << 8;
+                        index++;
+                        length += 0xFF & headerArray[index];
+                        length -= 3;
+                        index++;
+                        value = new byte[length];
+                        System.arraycopy(headerArray, index, value, 0, length);
+                        if (length == 0 || (length > 0 && (value[length - 1] != 0))) {
+                            trimTail = false;
+                        }
+                        switch (headerID) {
+                            case HeaderSet.TYPE:
+                                try {
+                                    // Remove trailing null
+                                    if (trimTail == false) {
+                                        headerImpl.setHeader(headerID, new String(value, 0,
+                                                value.length, "ISO8859_1"));
+                                    } else {
+                                        headerImpl.setHeader(headerID, new String(value, 0,
+                                                value.length - 1, "ISO8859_1"));
+                                    }
+                                } catch (UnsupportedEncodingException e) {
+                                    throw new RuntimeException("ISO8859_1 is not supported"
+                                            + e.getMessage());
+                                }
+                                break;
+
+                            // This is the constant for the authentication challenge header
+                            // This header does not have a constant defined in the Java
+                            // OBEX API
+                            case 0x4D:
+                                headerImpl.authChall = new byte[length];
+                                System.arraycopy(headerArray, index, headerImpl.authChall, 0,
+                                        length);
+                                break;
+
+                            // This is the constant for the authentication response header
+                            // This header does not have a constant defined in the Java
+                            // OBEX API
+                            case 0x4E:
+                                headerImpl.authResp = new byte[length];
+                                System
+                                        .arraycopy(headerArray, index, headerImpl.authResp, 0,
+                                                length);
+                                break;
+
+                            /*
+                            * These two case statements are for the body (0x48)
+                             * and end of body (0x49) headers.
+                            */
+                            case 0x48:
+                                /* Fall Through */
+                            case 0x49:
+                                body = new byte[length + 1];
+                                body[0] = (byte)headerID;
+                                System.arraycopy(headerArray, index, body, 1, length);
+                                break;
+
+                            case HeaderSet.TIME_ISO_8601:
+                                try {
+                                    String dateString = new String(value, "ISO8859_1");
+                                    Calendar temp = Calendar.getInstance();
+                                    if ((dateString.length() == 16)
+                                            && (dateString.charAt(15) == 'Z')) {
+                                        temp.setTimeZone(TimeZone.getTimeZone("UTC"));
+                                    }
+                                    temp.set(Calendar.YEAR, Integer.parseInt(dateString.substring(
+                                            0, 4)));
+                                    temp.set(Calendar.MONTH, Integer.parseInt(dateString.substring(
+                                            4, 6)));
+                                    temp.set(Calendar.DAY_OF_MONTH, Integer.parseInt(dateString
+                                            .substring(6, 8)));
+                                    temp.set(Calendar.HOUR_OF_DAY, Integer.parseInt(dateString
+                                            .substring(9, 11)));
+                                    temp.set(Calendar.MINUTE, Integer.parseInt(dateString
+                                            .substring(11, 13)));
+                                    temp.set(Calendar.SECOND, Integer.parseInt(dateString
+                                            .substring(13, 15)));
+                                    headerImpl.setHeader(HeaderSet.TIME_ISO_8601, temp);
+                                } catch (UnsupportedEncodingException e) {
+                                    throw new RuntimeException("ISO8859_1 is not supported"
+                                            + e.getMessage());
+                                } catch (Exception e) {
+                                    throw new IOException(
+                                            "Time Header does not follow ISO 8601 standard");
+                                }
+                                break;
+
+                            default:
+                                try {
+                                    if ((headerID & 0xC0) == 0x00) {
+                                        headerImpl.setHeader(headerID, OBEXHelper.convertToUnicode(
+                                                value, true));
+                                    } else {
+                                        headerImpl.setHeader(headerID, value);
+                                    }
+                                } catch (Exception e) {
+                                    // Not a valid header so ignore
+                                }
+                        }
+
+                        index += length;
+                        break;
+
+                    /*
+                     * 0x80 is a byte header.  The only valid byte headers are
+                     * the 16 user defined byte headers.
+                     */
+                    case 0x80:
+                        index++;
+                        try {
+                            headerImpl.setHeader(headerID, Byte.valueOf(headerArray[index]));
+                        } catch (Exception e) {
+                            // Not a valid header so ignore
+                        }
+                        index++;
+                        break;
+
+                    /*
+                     * 0xC0 is a 4 byte unsigned integer header and with the
+                     * exception of TIME_4_BYTE will be converted to a Long
+                     * and added.
+                     */
+                    case 0xC0:
+                        index++;
+                        value = new byte[4];
+                        System.arraycopy(headerArray, index, value, 0, 4);
+                        try {
+                            if (headerID != HeaderSet.TIME_4_BYTE) {
+                                // Determine if it is a connection ID.  These
+                                // need to be handled differently
+                                if (headerID == 0xCB) {
+                                    headerImpl.connectionID = new byte[4];
+                                    System.arraycopy(value, 0, headerImpl.connectionID, 0, 4);
+                                } else {
+                                    headerImpl.setHeader(headerID, Long
+                                            .valueOf(convertToLong(value)));
+                                }
+                            } else {
+                                Calendar temp = Calendar.getInstance();
+                                temp.setTime(new Date(convertToLong(value) * 1000L));
+                                headerImpl.setHeader(HeaderSet.TIME_4_BYTE, temp);
+                            }
+                        } catch (Exception e) {
+                            // Not a valid header so ignore
+                            throw new IOException("Header was not formatted properly");
+                        }
+                        index += 4;
+                        break;
+                }
+
+            }
+        } catch (IOException e) {
+            throw new IOException("Header was not formatted properly");
+        }
+
+        return body;
+    }
+
+    /**
+     * Creates the header part of OBEX packet based on the header provided.
+     *
+     * OPTIMIZATION: Could use getHeaderList() to get the array of headers to
+     * OPTIMIZATION: include and then use the high two bits to determine the
+     * OPTIMIZATION: the type of the object and construct the byte array from
+     * OPTIMIZATION: that.  This will make the size smaller.
+     *
+     * @param head the header used to construct the byte array
+     *
+     * @param nullOut <code>true</code> if the header should be set to
+     * <code>null</code> once it is added to the array or <code>false</code>
+     * if it should not be nulled out
+     *
+     * @return the header of an OBEX packet
+     */
+    public static byte[] createHeader(HeaderSet head, boolean nullOut) {
+        Long intHeader = null;
+        String stringHeader = null;
+        Calendar dateHeader = null;
+        Byte byteHeader = null;
+        StringBuffer buffer = null;
+        byte[] value = null;
+        byte[] result = null;
+        byte[] lengthArray = new byte[2];
+        int length;
+        HeaderSet headImpl = null;
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        if (!(head instanceof HeaderSet)) {
+            throw new IllegalArgumentException("Header not created by createHeaderSet");
+        }
+        headImpl = head;
+
+        try {
+            /*
+             * Determine if there is a connection ID to send.  If there is,
+             * then it should be the first header in the packet.
+             */
+            if ((headImpl.connectionID != null) && (headImpl.getHeader(HeaderSet.TARGET) == null)) {
+
+                out.write((byte)0xCB);
+                out.write(headImpl.connectionID);
+            }
+
+            // Count Header
+            intHeader = (Long)headImpl.getHeader(HeaderSet.COUNT);
+            if (intHeader != null) {
+                out.write((byte)HeaderSet.COUNT);
+                value = OBEXHelper.convertToByteArray(intHeader.longValue());
+                out.write(value);
+                if (nullOut) {
+                    headImpl.setHeader(HeaderSet.COUNT, null);
+                }
+            }
+
+            // Name Header
+            stringHeader = (String)headImpl.getHeader(HeaderSet.NAME);
+            if (stringHeader != null) {
+                out.write((byte)HeaderSet.NAME);
+                value = OBEXHelper.convertToUnicodeByteArray(stringHeader);
+                length = value.length + 3;
+                lengthArray[0] = (byte)(255 & (length >> 8));
+                lengthArray[1] = (byte)(255 & length);
+                out.write(lengthArray);
+                out.write(value);
+                if (nullOut) {
+                    headImpl.setHeader(HeaderSet.NAME, null);
+                }
+            }
+
+            // Type Header
+            stringHeader = (String)headImpl.getHeader(HeaderSet.TYPE);
+            if (stringHeader != null) {
+                out.write((byte)HeaderSet.TYPE);
+                try {
+                    value = stringHeader.getBytes("ISO8859_1");
+                } catch (UnsupportedEncodingException e) {
+                    throw new RuntimeException("Unsupported Encoding Scheme: " + e.getMessage());
+                }
+
+                length = value.length + 4;
+                lengthArray[0] = (byte)(255 & (length >> 8));
+                lengthArray[1] = (byte)(255 & length);
+                out.write(lengthArray);
+                out.write(value);
+                out.write(0x00);
+                if (nullOut) {
+                    headImpl.setHeader(HeaderSet.TYPE, null);
+                }
+            }
+
+            // Length Header
+            intHeader = (Long)headImpl.getHeader(HeaderSet.LENGTH);
+            if (intHeader != null) {
+                out.write((byte)HeaderSet.LENGTH);
+                value = OBEXHelper.convertToByteArray(intHeader.longValue());
+                out.write(value);
+                if (nullOut) {
+                    headImpl.setHeader(HeaderSet.LENGTH, null);
+                }
+            }
+
+            // Time ISO Header
+            dateHeader = (Calendar)headImpl.getHeader(HeaderSet.TIME_ISO_8601);
+            if (dateHeader != null) {
+
+                /*
+                 * The ISO Header should take the form YYYYMMDDTHHMMSSZ.  The
+                 * 'Z' will only be included if it is a UTC time.
+                 */
+                buffer = new StringBuffer();
+                int temp = dateHeader.get(Calendar.YEAR);
+                for (int i = temp; i < 1000; i = i * 10) {
+                    buffer.append("0");
+                }
+                buffer.append(temp);
+                temp = dateHeader.get(Calendar.MONTH);
+                if (temp < 10) {
+                    buffer.append("0");
+                }
+                buffer.append(temp);
+                temp = dateHeader.get(Calendar.DAY_OF_MONTH);
+                if (temp < 10) {
+                    buffer.append("0");
+                }
+                buffer.append(temp);
+                buffer.append("T");
+                temp = dateHeader.get(Calendar.HOUR_OF_DAY);
+                if (temp < 10) {
+                    buffer.append("0");
+                }
+                buffer.append(temp);
+                temp = dateHeader.get(Calendar.MINUTE);
+                if (temp < 10) {
+                    buffer.append("0");
+                }
+                buffer.append(temp);
+                temp = dateHeader.get(Calendar.SECOND);
+                if (temp < 10) {
+                    buffer.append("0");
+                }
+                buffer.append(temp);
+
+                if (dateHeader.getTimeZone().getID().equals("UTC")) {
+                    buffer.append("Z");
+                }
+
+                try {
+                    value = buffer.toString().getBytes("ISO8859_1");
+                } catch (UnsupportedEncodingException e) {
+                    throw new RuntimeException("UnsupportedEncodingException: " + e.getMessage());
+                }
+
+                length = value.length + 3;
+                lengthArray[0] = (byte)(255 & (length >> 8));
+                lengthArray[1] = (byte)(255 & length);
+                out.write(HeaderSet.TIME_ISO_8601);
+                out.write(lengthArray);
+                out.write(value);
+                if (nullOut) {
+                    headImpl.setHeader(HeaderSet.TIME_ISO_8601, null);
+                }
+            }
+
+            // Time 4 Byte Header
+            dateHeader = (Calendar)headImpl.getHeader(HeaderSet.TIME_4_BYTE);
+            if (dateHeader != null) {
+                out.write(HeaderSet.TIME_4_BYTE);
+
+                /*
+                 * Need to call getTime() twice.  The first call will return
+                 * a java.util.Date object.  The second call returns the number
+                 * of milliseconds since January 1, 1970.  We need to convert
+                 * it to seconds since the TIME_4_BYTE expects the number of
+                 * seconds since January 1, 1970.
+                 */
+                value = OBEXHelper.convertToByteArray(dateHeader.getTime().getTime() / 1000L);
+                out.write(value);
+                if (nullOut) {
+                    headImpl.setHeader(HeaderSet.TIME_4_BYTE, null);
+                }
+            }
+
+            // Description Header
+            stringHeader = (String)headImpl.getHeader(HeaderSet.DESCRIPTION);
+            if (stringHeader != null) {
+                out.write((byte)HeaderSet.DESCRIPTION);
+                value = OBEXHelper.convertToUnicodeByteArray(stringHeader);
+                length = value.length + 3;
+                lengthArray[0] = (byte)(255 & (length >> 8));
+                lengthArray[1] = (byte)(255 & length);
+                out.write(lengthArray);
+                out.write(value);
+                if (nullOut) {
+                    headImpl.setHeader(HeaderSet.DESCRIPTION, null);
+                }
+            }
+
+            // Target Header
+            value = (byte[])headImpl.getHeader(HeaderSet.TARGET);
+            if (value != null) {
+                out.write((byte)HeaderSet.TARGET);
+                length = value.length + 3;
+                lengthArray[0] = (byte)(255 & (length >> 8));
+                lengthArray[1] = (byte)(255 & length);
+                out.write(lengthArray);
+                out.write(value);
+                if (nullOut) {
+                    headImpl.setHeader(HeaderSet.TARGET, null);
+                }
+            }
+
+            // HTTP Header
+            value = (byte[])headImpl.getHeader(HeaderSet.HTTP);
+            if (value != null) {
+                out.write((byte)HeaderSet.HTTP);
+                length = value.length + 3;
+                lengthArray[0] = (byte)(255 & (length >> 8));
+                lengthArray[1] = (byte)(255 & length);
+                out.write(lengthArray);
+                out.write(value);
+                if (nullOut) {
+                    headImpl.setHeader(HeaderSet.HTTP, null);
+                }
+            }
+
+            // Who Header
+            value = (byte[])headImpl.getHeader(HeaderSet.WHO);
+            if (value != null) {
+                out.write((byte)HeaderSet.WHO);
+                length = value.length + 3;
+                lengthArray[0] = (byte)(255 & (length >> 8));
+                lengthArray[1] = (byte)(255 & length);
+                out.write(lengthArray);
+                out.write(value);
+                if (nullOut) {
+                    headImpl.setHeader(HeaderSet.WHO, null);
+                }
+            }
+
+            // Connection ID Header
+            value = (byte[])headImpl.getHeader(HeaderSet.APPLICATION_PARAMETER);
+            if (value != null) {
+                out.write((byte)HeaderSet.APPLICATION_PARAMETER);
+                length = value.length + 3;
+                lengthArray[0] = (byte)(255 & (length >> 8));
+                lengthArray[1] = (byte)(255 & length);
+                out.write(lengthArray);
+                out.write(value);
+                if (nullOut) {
+                    headImpl.setHeader(HeaderSet.APPLICATION_PARAMETER, null);
+                }
+            }
+
+            // Object Class Header
+            value = (byte[])headImpl.getHeader(HeaderSet.OBJECT_CLASS);
+            if (value != null) {
+                out.write((byte)HeaderSet.OBJECT_CLASS);
+                length = value.length + 3;
+                lengthArray[0] = (byte)(255 & (length >> 8));
+                lengthArray[1] = (byte)(255 & length);
+                out.write(lengthArray);
+                out.write(value);
+                if (nullOut) {
+                    headImpl.setHeader(HeaderSet.OBJECT_CLASS, null);
+                }
+            }
+
+            // Check User Defined Headers
+            for (int i = 0; i < 16; i++) {
+
+                //Unicode String Header
+                stringHeader = (String)headImpl.getHeader(i + 0x30);
+                if (stringHeader != null) {
+                    out.write((byte)i + 0x30);
+                    value = OBEXHelper.convertToUnicodeByteArray(stringHeader);
+                    length = value.length + 3;
+                    lengthArray[0] = (byte)(255 & (length >> 8));
+                    lengthArray[1] = (byte)(255 & length);
+                    out.write(lengthArray);
+                    out.write(value);
+                    if (nullOut) {
+                        headImpl.setHeader(i + 0x30, null);
+                    }
+                }
+
+                // Byte Sequence Header
+                value = (byte[])headImpl.getHeader(i + 0x70);
+                if (value != null) {
+                    out.write((byte)i + 0x70);
+                    length = value.length + 3;
+                    lengthArray[0] = (byte)(255 & (length >> 8));
+                    lengthArray[1] = (byte)(255 & length);
+                    out.write(lengthArray);
+                    out.write(value);
+                    if (nullOut) {
+                        headImpl.setHeader(i + 0x70, null);
+                    }
+                }
+
+                // Byte Header
+                byteHeader = (Byte)headImpl.getHeader(i + 0xB0);
+                if (byteHeader != null) {
+                    out.write((byte)i + 0xB0);
+                    out.write(byteHeader.byteValue());
+                    if (nullOut) {
+                        headImpl.setHeader(i + 0xB0, null);
+                    }
+                }
+
+                // Integer header
+                intHeader = (Long)headImpl.getHeader(i + 0xF0);
+                if (intHeader != null) {
+                    out.write((byte)i + 0xF0);
+                    out.write(OBEXHelper.convertToByteArray(intHeader.longValue()));
+                    if (nullOut) {
+                        headImpl.setHeader(i + 0xF0, null);
+                    }
+                }
+            }
+
+            // Add the authentication challenge header
+            if (headImpl.authChall != null) {
+                out.write((byte)0x4D);
+                length = headImpl.authChall.length + 3;
+                lengthArray[0] = (byte)(255 & (length >> 8));
+                lengthArray[1] = (byte)(255 & length);
+                out.write(lengthArray);
+                out.write(headImpl.authChall);
+                if (nullOut) {
+                    headImpl.authChall = null;
+                }
+            }
+
+            // Add the authentication response header
+            if (headImpl.authResp != null) {
+                out.write((byte)0x4E);
+                length = headImpl.authResp.length + 3;
+                lengthArray[0] = (byte)(255 & (length >> 8));
+                lengthArray[1] = (byte)(255 & length);
+                out.write(lengthArray);
+                out.write(headImpl.authResp);
+                if (nullOut) {
+                    headImpl.authResp = null;
+                }
+            }
+
+        } catch (IOException e) {
+        } finally {
+            result = out.toByteArray();
+            try {
+                out.close();
+            } catch (Exception ex) {
+            }
+        }
+
+        return result;
+
+    }
+
+    /**
+     * Determines where the maximum divide is between headers.  This method is
+     * used by put and get operations to separate headers to a size that meets
+     * the max packet size allowed.
+     *
+     * @param headerArray the headers to separate
+     *
+     * @param start the starting index to search
+     *
+     * @param maxSize the maximum size of a packet
+     *
+     * @return the index of the end of the header block to send or -1 if the
+     * header could not be divided because the header is too large
+     */
+    public static int findHeaderEnd(byte[] headerArray, int start, int maxSize) {
+
+        int fullLength = 0;
+        int lastLength = -1;
+        int index = start;
+        int length = 0;
+
+        while ((fullLength < maxSize) && (index < headerArray.length)) {
+            int headerID = (headerArray[index] < 0 ? headerArray[index] + 256 : headerArray[index]);
+            lastLength = fullLength;
+
+            switch (headerID & (0xC0)) {
+
+                case 0x00:
+                    // Fall through
+                case 0x40:
+
+                    index++;
+                    length = (headerArray[index] < 0 ? headerArray[index] + 256
+                            : headerArray[index]);
+                    length = length << 8;
+                    index++;
+                    length += (headerArray[index] < 0 ? headerArray[index] + 256
+                            : headerArray[index]);
+                    length -= 3;
+                    index++;
+                    index += length;
+                    fullLength += length + 3;
+                    break;
+
+                case 0x80:
+
+                    index++;
+                    index++;
+                    fullLength += 2;
+                    break;
+
+                case 0xC0:
+
+                    index += 5;
+                    fullLength += 5;
+                    break;
+
+            }
+
+        }
+
+        /*
+         * Determine if this is the last header or not
+         */
+        if (lastLength == 0) {
+            /*
+             * Since this is the last header, check to see if the size of this
+             * header is less then maxSize.  If it is, return the length of the
+             * header, otherwise return -1.  The length of the header is
+             * returned since it would be the start of the next header
+             */
+            if (fullLength < maxSize) {
+                return headerArray.length;
+            } else {
+                return -1;
+            }
+        } else {
+            return lastLength + start;
+        }
+    }
+
+    /**
+     * Converts the byte array to a long.
+     *
+     * @param b the byte array to convert to a long
+     *
+     * @return the byte array as a long
+     */
+    public static long convertToLong(byte[] b) {
+        long result = 0;
+        long value = 0;
+        long power = 0;
+
+        for (int i = (b.length - 1); i >= 0; i--) {
+            value = b[i];
+            if (value < 0) {
+                value += 256;
+            }
+
+            result = result | (value << power);
+            power += 8;
+        }
+
+        return result;
+    }
+
+    /**
+     * Converts the long to a 4 byte array.  The long must be non negative.
+     *
+     * @param l the long to convert
+     *
+     * @return a byte array that is the same as the long
+     */
+    public static byte[] convertToByteArray(long l) {
+        byte[] b = new byte[4];
+
+        b[0] = (byte)(255 & (l >> 24));
+        b[1] = (byte)(255 & (l >> 16));
+        b[2] = (byte)(255 & (l >> 8));
+        b[3] = (byte)(255 & l);
+
+        return b;
+    }
+
+    /**
+     * Converts the String to a UNICODE byte array.  It will also add the ending
+     * null characters to the end of the string.
+     *
+     * @param s the string to convert
+     *
+     * @return the unicode byte array of the string
+     */
+    public static byte[] convertToUnicodeByteArray(String s) {
+        if (s == null) {
+            return null;
+        }
+
+        char c[] = s.toCharArray();
+        byte[] result = new byte[(c.length * 2) + 2];
+        for (int i = 0; i < c.length; i++) {
+            result[(i * 2)] = (byte)(c[i] >> 8);
+            result[((i * 2) + 1)] = (byte)c[i];
+        }
+
+        // Add the UNICODE null character
+        result[result.length - 2] = 0;
+        result[result.length - 1] = 0;
+
+        return result;
+    }
+
+    /**
+     * Retrieves the value from the byte array for the tag value specified.  The
+     * array should be of the form Tag - Length - Value triplet.
+     *
+     * @param tag the tag to retrieve from the byte array
+     *
+     * @param triplet the byte sequence containing the tag length value form
+     *
+     * @return the value of the specified tag
+     */
+    public static byte[] getTagValue(byte tag, byte[] triplet) {
+
+        int index = findTag(tag, triplet);
+        if (index == -1) {
+            return null;
+        }
+
+        index++;
+        int length = triplet[index] & 0xFF;
+
+        byte[] result = new byte[length];
+        index++;
+        System.arraycopy(triplet, index, result, 0, length);
+
+        return result;
+    }
+
+    /**
+     * Finds the index that starts the tag value pair in the byte array provide.
+     *
+     * @param tag the tag to look for
+     *
+     * @param value the byte array to search
+     *
+     * @return the starting index of the tag or -1 if the tag could not be found
+     */
+    public static int findTag(byte tag, byte[] value) {
+        int length = 0;
+
+        if (value == null) {
+            return -1;
+        }
+
+        int index = 0;
+
+        while ((index < value.length) && (value[index] != tag)) {
+            length = value[index + 1] & 0xFF;
+            index += length + 2;
+        }
+
+        if (index >= value.length) {
+            return -1;
+        }
+
+        return index;
+    }
+
+    /**
+     * Converts the byte array provided to a unicode string.
+     *
+     * @param b the byte array to convert to a string
+     *
+     * @param includesNull determine if the byte string provided contains the
+     * UNICODE null character at the end or not;  if it does, it will be
+     * removed
+     *
+     * @return a Unicode string
+     *
+     * @param IllegalArgumentException if the byte array has an odd length
+     */
+    public static String convertToUnicode(byte[] b, boolean includesNull) {
+        if (b == null) {
+            return null;
+        }
+        int arrayLength = b.length;
+        if (!((arrayLength % 2) == 0)) {
+            throw new IllegalArgumentException("Byte array not of a valid form");
+        }
+        arrayLength = (arrayLength >> 1);
+        if (includesNull) {
+            arrayLength -= 1;
+        }
+
+        char[] c = new char[arrayLength];
+        for (int i = 0; i < arrayLength; i++) {
+            int upper = b[2 * i];
+            int lower = b[(2 * i) + 1];
+            if (upper < 0) {
+                upper += 256;
+            }
+            if (lower < 0) {
+                lower += 256;
+            }
+
+            c[i] = (char)((upper << 8) | lower);
+        }
+
+        return new String(c);
+    }
+
+    /**
+     * Computes the MD5 hash algorithm on the byte array provided.  This
+     * implementation of MD5 is optimized for OBEX in that it provides for a
+     * single entry and exist and thus does not build up the input before
+     * applying the hash.
+     *
+     * OPTIMIZATION: Embedd MD5 algorithm in this method.  This will make the
+     * OPTIMIZATION: size smaller.
+     *
+     * @param in the byte array to hash
+     *
+     * @return the MD5 hash of the byte array
+     */
+    public static byte[] computeMD5Hash(byte[] in) {
+
+        MD5Hash hash = new MD5Hash(in);
+        return hash.computeDigest();
+    }
+
+    /**
+     * Computes an authentication challenge header.
+     *
+     *
+     * @param nonce the challenge that will be provided to the peer;  the
+     * challenge must be 16 bytes long
+     *
+     * @param realm a short description that describes what password to use
+     *
+     * @param access if <code>true</code> then full access will be granted if
+     * successful; if <code>false</code> then read only access will be granted
+     * if successful
+     *
+     * @param userID if <code>true</code>, a user ID is required in the reply;
+     * if <code>false</code>, no user ID is required
+     *
+     * @exception IllegalArgumentException if the challenge is not 16 bytes
+     * long; if the realm can not be encoded in less then 255 bytes
+     *
+     * @exception IOException if the encoding scheme ISO 8859-1 is not supported
+     */
+    public static byte[] computeAuthenticationChallenge(byte[] nonce, String realm, boolean access,
+            boolean userID) throws IOException {
+        byte[] authChall = null;
+
+        if (nonce.length != 16) {
+            throw new IllegalArgumentException("Nonce must be 16 bytes long");
+        }
+
+        /*
+         * The authentication challenge is a byte sequence of the following form
+         * byte 0: 0x00 - the tag for the challenge
+         * byte 1: 0x10 - the length of the challenge; must be 16
+         * byte 2-17: the authentication challenge
+         * byte 18: 0x01 - the options tag; this is optional in the spec, but
+         *                 we are going to include it in every message
+         * byte 19: 0x01 - length of the options; must be 1
+         * byte 20: the value of the options; bit 0 is set if user ID is
+         *          required; bit 1 is set if access mode is read only
+         * byte 21: 0x02 - the tag for authentication realm; only included if
+         *                 an authentication realm is specified
+         * byte 22: the length of the authentication realm; only included if
+         *          the authentication realm is specified
+         * byte 23: the encoding scheme of the authentication realm; we will use
+         *          the ISO 8859-1 encoding scheme since it is part of the KVM
+         * byte 24 & up: the realm if one is specified.
+         */
+        if (realm == null) {
+            authChall = new byte[21];
+        } else {
+            if (realm.length() >= 255) {
+                throw new IllegalArgumentException("Realm must be less then 255 bytes");
+            }
+            authChall = new byte[24 + realm.length()];
+            authChall[21] = 0x02;
+            authChall[22] = (byte)(realm.length() + 1);
+            authChall[23] = 0x01; // ISO 8859-1 Encoding
+            System.arraycopy(realm.getBytes("ISO8859_1"), 0, authChall, 24, realm.length());
+        }
+
+        // Include the nonce field in the header
+        authChall[0] = 0x00;
+        authChall[1] = 0x10;
+        System.arraycopy(nonce, 0, authChall, 2, 16);
+
+        // Include the options header
+        authChall[18] = 0x01;
+        authChall[19] = 0x01;
+        authChall[20] = 0x00;
+
+        if (!access) {
+            authChall[20] = (byte)(authChall[20] | 0x02);
+        }
+        if (userID) {
+            authChall[20] = (byte)(authChall[20] | 0x01);
+        }
+
+        return authChall;
+    }
+}
+
+/**
+ * This class will complete an MD5 hash of the buffer provided.
+ */
+class MD5Hash {
+
+    // Constants for MD5Transform routine.
+    private static final int A1 = 7;
+
+    private static final int A2 = 12;
+
+    private static final int A3 = 17;
+
+    private static final int A4 = 22;
+
+    private static final int B1 = 5;
+
+    private static final int B2 = 9;
+
+    private static final int B3 = 14;
+
+    private static final int B4 = 20;
+
+    private static final int C1 = 4;
+
+    private static final int C2 = 11;
+
+    private static final int C3 = 16;
+
+    private static final int C4 = 23;
+
+    private static final int D1 = 6;
+
+    private static final int D2 = 10;
+
+    private static final int D3 = 15;
+
+    private static final int D4 = 21;
+
+    private int state[];
+
+    private int count[];
+
+    /**
+     * Keeps the present digest
+     */
+    private byte buffer[];
+
+    /**
+     * Completes a hash on the data provided.
+     *
+     * @param data the byte array to hash
+     */
+    public MD5Hash(byte data[]) {
+        buffer = new byte[64];
+        state = new int[4];
+        count = new int[2];
+
+        state[0] = 0x67452301;
+        state[1] = 0xefcdab89;
+        state[2] = 0x98badcfe;
+        state[3] = 0x10325476;
+
+        count[0] = 0;
+        count[1] = 0;
+
+        MD5Update(data, 0, data.length);
+    }
+
+    /**
+    * Updates the MD5 hash buffer.
+    *
+    * @param input byte array of data
+     *
+    * @param offset offset into the array to start the digest calculation
+     *
+    * @param inputLen the length of the byte array
+    */
+    private void MD5Update(byte input[], int offset, int inputLen) {
+        int i, index, partLen;
+
+        // Compute number of bytes mod 64
+        index = (count[0] >>> 3) & 0x3F;
+
+        // Update number of bits
+        int slen = inputLen << 3;
+        if ((count[0] += slen) < slen) {
+            count[1]++;
+        }
+
+        count[1] += (inputLen >>> 29);
+
+        partLen = 64 - index;
+        // Transform as many times as possible.
+        if (inputLen >= partLen) {
+            copy(index, input, offset, partLen);
+
+            MD5Transform(buffer, 0, 0);
+
+            for (i = partLen; i + 63 < inputLen; i += 64) {
+                MD5Transform(input, offset, i);
+            }
+
+            index = 0;
+        } else {
+            i = 0;
+        }
+
+        copy(index, input, i + offset, inputLen - i);
+    }
+
+    /**
+     * Computes the final MD5 digest
+     *
+     * @return the MD5 digest
+     */
+    public byte[] computeDigest() {
+        byte bits[];
+        byte digest[];
+        int index;
+        int length;
+
+        // Save number of bits
+        bits = MD5Encode(count, 8);
+
+        // Pad out to 56 mod 64.
+        index = ((count[0] >>> 3) & 0x3f);
+        length = (index < 56) ? (56 - index) : (120 - index);
+
+        // build padding buffer.
+        if (length > 0) {
+            byte padding[] = new byte[length];
+            padding[0] = (byte)0x80;
+            for (int i = 1; i < length; i++) {
+                padding[i] = 0;
+            }
+
+            MD5Update(padding, 0, length);
+        }
+
+        // Append length
+        MD5Update(bits, 0, 8);
+
+        // Store state in digest
+        digest = MD5Encode(state, 16);
+
+        return digest;
+    }
+
+    /**
+     * Copies the input array into the local objects buffer.  It performs a
+     * check to verify that data is available to copy.
+     *
+     * @param startIndex the offset into the local buffer to copy
+     *
+     * @param input the array to copy into the local buffer
+     *
+     * @param index the index to start copying from
+     *
+     * @param length the amount of data to copy
+     */
+    private void copy(int startIndex, byte input[], int index, int length) {
+        if (index == input.length)
+            return;
+        System.arraycopy(input, index, buffer, startIndex, length);
+    }
+
+    /**
+     * Rotates the bytes in <code>x</code> <code>n</code> times to the left.
+     * The rotation wraps the bits around.
+     *
+     * @param x the integer to rotate
+     *
+     * @param n the number of bits to rotate
+     *
+     * @return <code>x</code> rotated to the left <code>n</code> times
+     */
+    private int rotate(int x, int n) {
+        return (((x) << (n)) | ((x) >>> (32 - (n))));
+    }
+
+    /**
+     * Completes a single step in the MD5 hash algorithm.
+     */
+    private int MD5Step(int a, int b, int c, int d, int x, int s, int ac, int round) {
+        switch (round) {
+            case 1:
+                a += (((b) & (c)) | ((~b) & (d))) + (x) + (ac);
+                break;
+            case 2:
+                a += (((b) & (d)) | ((c) & (~d))) + (x) + (ac);
+                break;
+            case 3:
+                a += ((b) ^ (c) ^ (d)) + (x) + (ac);
+                break;
+            case 4:
+                a += ((c) ^ ((b) | (~d))) + (x) + (ac);
+                break;
+        }
+        a = rotate(a, (s));
+        a += (b);
+        return a;
+    }
+
+    /**
+     * Performs the core MD5 algorithm.  This method will add the data provided
+     * and recompute the hash.
+     *
+     * @param data the block of data to add
+     *
+     * @param index the starting index into the data to start processing
+     *
+     * @param length the length of the byte array to process
+     */
+    private void MD5Transform(byte data[], int index, int length) {
+        int a = state[0];
+        int b = state[1];
+        int c = state[2];
+        int d = state[3];
+        int x[];
+
+        x = MD5Decode(data, index, length, 64);
+
+        // Round 1
+        a = MD5Step(a, b, c, d, x[0], A1, 0xd76aa478, 1);
+        d = MD5Step(d, a, b, c, x[1], A2, 0xe8c7b756, 1);
+        c = MD5Step(c, d, a, b, x[2], A3, 0x242070db, 1);
+        b = MD5Step(b, c, d, a, x[3], A4, 0xc1bdceee, 1);
+        a = MD5Step(a, b, c, d, x[4], A1, 0xf57c0faf, 1);
+        d = MD5Step(d, a, b, c, x[5], A2, 0x4787c62a, 1);
+        c = MD5Step(c, d, a, b, x[6], A3, 0xa8304613, 1);
+        b = MD5Step(b, c, d, a, x[7], A4, 0xfd469501, 1);
+        a = MD5Step(a, b, c, d, x[8], A1, 0x698098d8, 1);
+        d = MD5Step(d, a, b, c, x[9], A2, 0x8b44f7af, 1);
+        c = MD5Step(c, d, a, b, x[10], A3, 0xffff5bb1, 1);
+        b = MD5Step(b, c, d, a, x[11], A4, 0x895cd7be, 1);
+        a = MD5Step(a, b, c, d, x[12], A1, 0x6b901122, 1);
+        d = MD5Step(d, a, b, c, x[13], A2, 0xfd987193, 1);
+        c = MD5Step(c, d, a, b, x[14], A3, 0xa679438e, 1);
+        b = MD5Step(b, c, d, a, x[15], A4, 0x49b40821, 1);
+
+        // Round 2
+        a = MD5Step(a, b, c, d, x[1], B1, 0xf61e2562, 2);
+        d = MD5Step(d, a, b, c, x[6], B2, 0xc040b340, 2);
+        c = MD5Step(c, d, a, b, x[11], B3, 0x265e5a51, 2);
+        b = MD5Step(b, c, d, a, x[0], B4, 0xe9b6c7aa, 2);
+        a = MD5Step(a, b, c, d, x[5], B1, 0xd62f105d, 2);
+        d = MD5Step(d, a, b, c, x[10], B2, 0x2441453, 2);
+        c = MD5Step(c, d, a, b, x[15], B3, 0xd8a1e681, 2);
+        b = MD5Step(b, c, d, a, x[4], B4, 0xe7d3fbc8, 2);
+        a = MD5Step(a, b, c, d, x[9], B1, 0x21e1cde6, 2);
+        d = MD5Step(d, a, b, c, x[14], B2, 0xc33707d6, 2);
+        c = MD5Step(c, d, a, b, x[3], B3, 0xf4d50d87, 2);
+        b = MD5Step(b, c, d, a, x[8], B4, 0x455a14ed, 2);
+        a = MD5Step(a, b, c, d, x[13], B1, 0xa9e3e905, 2);
+        d = MD5Step(d, a, b, c, x[2], B2, 0xfcefa3f8, 2);
+        c = MD5Step(c, d, a, b, x[7], B3, 0x676f02d9, 2);
+        b = MD5Step(b, c, d, a, x[12], B4, 0x8d2a4c8a, 2);
+
+        // Round 3
+        a = MD5Step(a, b, c, d, x[5], C1, 0xfffa3942, 3);
+        d = MD5Step(d, a, b, c, x[8], C2, 0x8771f681, 3);
+        c = MD5Step(c, d, a, b, x[11], C3, 0x6d9d6122, 3);
+        b = MD5Step(b, c, d, a, x[14], C4, 0xfde5380c, 3);
+        a = MD5Step(a, b, c, d, x[1], C1, 0xa4beea44, 3);
+        d = MD5Step(d, a, b, c, x[4], C2, 0x4bdecfa9, 3);
+        c = MD5Step(c, d, a, b, x[7], C3, 0xf6bb4b60, 3);
+        b = MD5Step(b, c, d, a, x[10], C4, 0xbebfbc70, 3);
+        a = MD5Step(a, b, c, d, x[13], C1, 0x289b7ec6, 3);
+        d = MD5Step(d, a, b, c, x[0], C2, 0xeaa127fa, 3);
+        c = MD5Step(c, d, a, b, x[3], C3, 0xd4ef3085, 3);
+        b = MD5Step(b, c, d, a, x[6], C4, 0x4881d05, 3);
+        a = MD5Step(a, b, c, d, x[9], C1, 0xd9d4d039, 3);
+        d = MD5Step(d, a, b, c, x[12], C2, 0xe6db99e5, 3);
+        c = MD5Step(c, d, a, b, x[15], C3, 0x1fa27cf8, 3);
+        b = MD5Step(b, c, d, a, x[2], C4, 0xc4ac5665, 3);
+
+        // Round 4
+        a = MD5Step(a, b, c, d, x[0], D1, 0xf4292244, 4);
+        d = MD5Step(d, a, b, c, x[7], D2, 0x432aff97, 4);
+        c = MD5Step(c, d, a, b, x[14], D3, 0xab9423a7, 4);
+        b = MD5Step(b, c, d, a, x[5], D4, 0xfc93a039, 4);
+        a = MD5Step(a, b, c, d, x[12], D1, 0x655b59c3, 4);
+        d = MD5Step(d, a, b, c, x[3], D2, 0x8f0ccc92, 4);
+        c = MD5Step(c, d, a, b, x[10], D3, 0xffeff47d, 4);
+        b = MD5Step(b, c, d, a, x[1], D4, 0x85845dd1, 4);
+        a = MD5Step(a, b, c, d, x[8], D1, 0x6fa87e4f, 4);
+        d = MD5Step(d, a, b, c, x[15], D2, 0xfe2ce6e0, 4);
+        c = MD5Step(c, d, a, b, x[6], D3, 0xa3014314, 4);
+        b = MD5Step(b, c, d, a, x[13], D4, 0x4e0811a1, 4);
+        a = MD5Step(a, b, c, d, x[4], D1, 0xf7537e82, 4);
+        d = MD5Step(d, a, b, c, x[11], D2, 0xbd3af235, 4);
+        c = MD5Step(c, d, a, b, x[2], D3, 0x2ad7d2bb, 4);
+        b = MD5Step(b, c, d, a, x[9], D4, 0xeb86d391, 4);
+
+        state[0] += a;
+        state[1] += b;
+        state[2] += c;
+        state[3] += d;
+    }
+
+    /**
+     * Encodes the input array.  <code>input</code> must be a multiple of
+     * four.
+     *
+     * @param input the array to encode
+     *
+     * @param length the length of the array to encode
+     */
+    private byte[] MD5Encode(int input[], int length) {
+        int i, j;
+        byte output[] = new byte[length];
+
+        for (i = 0, j = 0; j < length; i++, j += 4) {
+            output[j] = (byte)(input[i] & 0xff);
+            output[j + 1] = (byte)((input[i] >>> 8) & 0xff);
+            output[j + 2] = (byte)((input[i] >>> 16) & 0xff);
+            output[j + 3] = (byte)((input[i] >>> 24) & 0xff);
+        }
+
+        return output;
+    }
+
+    /**
+     * Decodes the array.  The <code>input</code> array must be a multiple of
+     * four.  Results are undefined if this is not true.
+     *
+     * @param input the array to decode
+     *
+     * @param index the starting position into the input array to start decoding
+     *
+     * @param posn
+     *
+     * @param length
+     */
+    private int[] MD5Decode(byte input[], int offset, int posn, int length) {
+        int output[] = new int[length / 4];
+        int i, j;
+        int limit = length + posn + offset;
+
+        for (i = 0, j = offset + posn; j < limit; i++, j += 4)
+            output[i] = ((input[j]) & 0xff) | (((input[j + 1]) & 0xff) << 8)
+                    | (((input[j + 2]) & 0xff) << 16) | (((input[j + 3]) & 0xff) << 24);
+
+        return output;
+    }
+}
diff --git a/obex/javax/obex/ObexSession.java b/obex/javax/obex/ObexSession.java
new file mode 100644
index 0000000..b3da89c
--- /dev/null
+++ b/obex/javax/obex/ObexSession.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2008-2009, Motorola, Inc.
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the Motorola, Inc. nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package javax.obex;
+
+import java.io.IOException;
+
+/**
+ * The <code>ObexSession</code> interface characterizes the term
+ * "OBEX Connection" as defined in the IrDA Object Exchange Protocol v1.2, which
+ * could be the server-side view of an OBEX connection, or the client-side view
+ * of the same connection, which is established by server's accepting of a
+ * client issued "CONNECT".
+ * <P>
+ * 
+ * This interface serves as the common super class for
+ * <CODE>ClientSession</CODE> and <CODE>ServerSession</CODE>.
+ * 
+ * @version 0.3 November 28, 2008
+ */
+public interface ObexSession {
+
+    /*
+    public InputStream openInputStream() throws IOException;
+
+    public DataInputStream openDataInputStream() throws IOException;
+
+    public OutputStream openOutputStream() throws IOException;
+
+    public DataOutputStream openDataOutputStream() throws IOException;*/
+
+    public void close() throws IOException;
+
+}
diff --git a/obex/javax/obex/ObexTransport.java b/obex/javax/obex/ObexTransport.java
new file mode 100644
index 0000000..b1734ff
--- /dev/null
+++ b/obex/javax/obex/ObexTransport.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2008-2009, Motorola, Inc.
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the Motorola, Inc. nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package javax.obex;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+/**
+ * The <code>ObexTransport</code> interface defines the underlying transport
+ * connection which carries the OBEX protocol( such as TCP, RFCOMM device file
+ * exposed by Bluetooth or USB in kernel, RFCOMM socket emulated in Android
+ * platform, Irda). This interface provides an abstract layer to be used by the
+ * <code>ObexConnection</code>. Each kind of medium shall have its own
+ * implementation to wrap and follow the same interface.
+ * <P>
+ * See section 1.2.2 of IrDA Object Exchange Protocol specification.
+ * <P>
+ * Different kind of medium may have different construction - for example, the
+ * RFCOMM device file medium may be constructed from a file descriptor or simply
+ * a string while the TCP medium usually from a socket.
+ * 
+ * @version 0.3 November 28, 2008
+ */
+public interface ObexTransport {
+
+    void create() throws IOException;
+
+    void listen() throws IOException;
+
+    void close() throws IOException;
+
+    void connect() throws IOException;
+
+    void disconnect() throws IOException;
+
+    InputStream openInputStream() throws IOException;
+
+    OutputStream openOutputStream() throws IOException;
+
+    DataInputStream openDataInputStream() throws IOException;
+
+    DataOutputStream openDataOutputStream() throws IOException;
+    //ObexSession accept() throws IOException;
+
+}
diff --git a/obex/javax/obex/Operation.java b/obex/javax/obex/Operation.java
new file mode 100644
index 0000000..120852a
--- /dev/null
+++ b/obex/javax/obex/Operation.java
@@ -0,0 +1,200 @@
+/*
+ * Copyright (c) 2008-2009, Motorola, Inc.
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the Motorola, Inc. nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package javax.obex;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+/**
+ * The <code>Operation</code> interface provides ways to manipulate a single
+ * OBEX PUT or GET operation.  The implementation of this interface sends
+ * OBEX packets as they are built.  If during the operation the peer in the
+ * operation ends the operation, an <code>IOException</code> is thrown on
+ * the next read from the input stream, write to the output stream, or call to
+ * <code>sendHeaders()</code>.
+ * <P>
+ * <STRONG>Definition of methods inherited from <code>ContentConnection</code></STRONG>
+ * <P>
+ * <code>getEncoding()</code> will always return <code>null</code>.
+ * <BR><code>getLength()</code> will return the length specified by the OBEX Length
+ * header or -1 if the OBEX Length header was not included.
+ * <BR><code>getType()</code> will return the value specified in the OBEX Type
+ * header or <code>null</code> if the OBEX Type header was not included.<BR>
+ * <P>
+ * <STRONG>How Headers are Handled</STRONG>
+ * <P>
+ * As headers are received, they may be retrieved through the
+ * <code>getReceivedHeaders()</code> method.  If new headers are set during the
+ * operation, the new headers will be sent during the next packet exchange.
+ * <P>
+ * <STRONG>PUT example</STRONG>
+ * <P>
+ * <PRE>
+ * void putObjectViaOBEX(ClientSession conn, HeaderSet head, byte[] obj)
+ *     throws IOException {
+ *
+ *     // Include the length header
+ *     head.setHeader(head.LENGTH, new Long(obj.length));
+ *
+ *     // Initiate the PUT request
+ *     Operation op = conn.put(head);
+ *
+ *     // Open the output stream to put the object to it
+ *     DataOutputStream out = op.openDataOutputStream();
+ *
+ *     // Send the object to the server
+ *     out.write(obj);
+ *
+ *     // End the transaction
+ *     out.close();
+ *     op.close();
+ * }
+ * </PRE>
+ * <P>
+ * <STRONG>GET example</STRONG>
+ * <P>
+ * <PRE>
+ * byte[] getObjectViaOBEX(ClientSession conn, HeaderSet head) throws IOException {
+ *
+ *     // Send the initial GET request to the server
+ *     Operation op = conn.get(head);
+ *
+ *     // Retrieve the length of the object being sent back
+ *     int length = op.getLength();
+ *
+ *      // Create space for the object
+ *      byte[] obj = new byte[length];
+ *
+ *     // Get the object from the input stream
+ *     DataInputStream in = trans.openDataInputStream();
+ *     in.read(obj);
+ *
+ *     // End the transaction
+ *     in.close();
+ *     op.close();
+ *
+ *     return obj;
+ * }
+ * </PRE>
+ * <H3>Client PUT Operation Flow</H3>
+ * For PUT operations, a call to <code>close()</code> the <code>OutputStream</code>
+ * returned from <code>openOutputStream()</code> or <code>openDataOutputStream()</code>
+ * will signal that the request is done.  (In OBEX terms, the End-Of-Body header should
+ * be sent and the final bit in the request will be set.)  At this point, the
+ * reply from the server may begin to be processed.  A call to
+ * <code>getResponseCode()</code> will do an implicit close on the
+ * <code>OutputStream</code> and therefore signal that the request is done.
+ * <H3>Client GET Operation Flow</H3>
+ * For GET operation, a call to <code>openInputStream()</code> or
+ * <code>openDataInputStream()</code> will signal that the request is done.  (In OBEX
+ * terms, the final bit in the request will be set.)  A call to
+ * <code>getResponseCode()</code> will cause an implicit close on the
+ * <code>InputStream</code>.  No further data may be read at this point.
+ *
+ * @version 0.3 November 28, 2008
+ */
+public interface Operation {
+
+    /**
+     * Sends an ABORT message to the server.  By calling this method, the
+     * corresponding input and output streams will be closed along with this
+     * object.  No headers are sent in the abort request.  This will end the
+     * operation since <code>close()</code> will be called by this method.
+     *
+     * @exception IOException if the transaction has already ended or if an
+     * OBEX server calls this method
+     */
+    public void abort() throws IOException;
+
+    /**
+     * Returns the headers that have been received during the operation.
+     * Modifying the object returned has no effect on the headers that are
+     * sent or retrieved.
+     *
+     * @return the headers received during this <code>Operation</code>
+     *
+     * @exception IOException if this <code>Operation</code> has been closed
+     */
+    public HeaderSet getReceivedHeaders() throws IOException;
+
+    /**
+     * Specifies the headers that should be sent in the next OBEX message that
+     * is sent.
+     *
+     * @param headers the headers to send in the next message
+     *
+     * @exception IOException  if this <code>Operation</code> has been closed
+     * or the transaction has ended and no further messages will be exchanged
+     *
+     * @exception IllegalArgumentException if <code>headers</code> was not created
+     * by a call to <code>ServerRequestHandler.createHeaderSet()</code> or
+     * <code>ClientSession.createHeaderSet()</code>
+     *
+     * @exception NullPointerException if <code>headers</code> if <code>null</code>
+     */
+    public void sendHeaders(HeaderSet headers) throws IOException;
+
+    /**
+     * Returns the response code received from the server.  Response codes
+     * are defined in the <code>ResponseCodes</code> class.
+     *
+     * @see ResponseCodes
+     *
+     * @return the response code retrieved from the server
+     *
+     * @exception IOException if an error occurred in the transport layer during
+     * the transaction; if this object was created by an OBEX server
+     */
+    public int getResponseCode() throws IOException;
+
+    public String getEncoding();
+
+    public long getLength();
+
+    public String getType();
+
+    public InputStream openInputStream() throws IOException;
+
+    public DataInputStream openDataInputStream() throws IOException;
+
+    public OutputStream openOutputStream() throws IOException;
+
+    public DataOutputStream openDataOutputStream() throws IOException;
+
+    public void close() throws IOException;
+
+    public int getMaxPacketSize();
+}
diff --git a/obex/javax/obex/PasswordAuthentication.java b/obex/javax/obex/PasswordAuthentication.java
new file mode 100644
index 0000000..82f9623
--- /dev/null
+++ b/obex/javax/obex/PasswordAuthentication.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2008-2009, Motorola, Inc.
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the Motorola, Inc. nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package javax.obex;
+
+/**
+ * This class holds user name and password combinations.
+ *
+ * @version 0.3 November 28, 2008
+ */
+public class PasswordAuthentication {
+
+    private byte[] userName;
+
+    private byte[] password;
+
+    /**
+     * Creates a new <code>PasswordAuthentication</code> with the user name
+     * and password provided.
+     *
+     * @param userName the user name to include; this may be <code>null</code>
+     *
+     * @param password the password to include in the response
+     *
+     * @exception NullPointerException if <code>password</code> is
+     * <code>null</code>
+     */
+    public PasswordAuthentication(byte[] userName, byte[] password) {
+        if (userName != null) {
+            this.userName = new byte[userName.length];
+            System.arraycopy(userName, 0, this.userName, 0, userName.length);
+        }
+
+        this.password = new byte[password.length];
+        System.arraycopy(password, 0, this.password, 0, password.length);
+    }
+
+    /**
+     * Retrieves the user name that was specified in the constructor.
+     * The user name may be <code>null</code>.
+     *
+     * @return the user name
+     */
+    public byte[] getUserName() {
+        return this.userName;
+    }
+
+    /**
+     * Retrieves the password.
+     *
+     * @return the password
+     */
+    public byte[] getPassword() {
+        return this.password;
+    }
+}
diff --git a/obex/javax/obex/PrivateInputStream.java b/obex/javax/obex/PrivateInputStream.java
new file mode 100644
index 0000000..1b83bb0
--- /dev/null
+++ b/obex/javax/obex/PrivateInputStream.java
@@ -0,0 +1,196 @@
+/*
+ * Copyright (c) 2008-2009, Motorola, Inc.
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the Motorola, Inc. nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package javax.obex;
+
+import java.io.*;
+
+/**
+ * This object provides an input stream to the Operation objects used in this
+ * package.
+ *
+ * OPTIMIZATION: Include the other read() methods defined in InputStream.
+ *
+ * @version 0.3 November 28, 2008
+ */
+public class PrivateInputStream extends InputStream {
+
+    private BaseStream parent;
+
+    private byte[] data;
+
+    private int index;
+
+    private boolean isOpen;
+
+    public PrivateInputStream() {
+
+    }
+
+    /**
+     * Creates an input stream for the <code>Operation</code> to read from
+     *
+     * @param p the connection this input stream is for
+     */
+    public PrivateInputStream(BaseStream p) {
+        parent = p;
+        data = new byte[0];
+        index = 0;
+        isOpen = true;
+    }
+
+    /**
+     * Returns the number of bytes that can be read (or skipped over) from this
+     * input stream without blocking by the next caller of a method for this
+     * input stream. The next caller might be the same thread or or another
+     * thread.
+     *
+     * @return the number of bytes that can be read from this input stream
+     * without blocking
+     *
+     * @exception IOException if an I/O error occurs
+     */
+    @Override
+    public synchronized int available() throws IOException {
+        ensureOpen();
+        return data.length - index;
+    }
+
+    /**
+     * Reads the next byte of data from the input stream. The value byte is
+     * returned as an int in the range 0 to 255. If no byte is available
+     * because the end of the stream has been reached, the value -1 is
+     * returned. This method blocks until input data is available, the end of
+     * the stream is detected, or an exception is thrown.
+     *
+     * @return the byte read from the input stream or -1 if it reaches the end
+     * of stream
+     *
+     * @exception IOException if an I/O error occurs
+     */
+    @Override
+    public synchronized int read() throws IOException {
+        ensureOpen();
+        while (data.length == index) {
+            if (!parent.continueOperation(true, true)) {
+                return -1;
+            }
+        }
+        return (data[index++] & 0xFF);
+    }
+
+    @Override
+    public int read(byte[] b) throws IOException {
+        return read(b, 0, b.length);
+    }
+
+    @Override
+    public synchronized int read(byte[] b, int offset, int length) throws IOException {
+
+        if (b == null) {
+            throw new NullPointerException("buffer is null");
+        }
+        if ((offset | length) < 0 || length > b.length - offset) {
+            throw new ArrayIndexOutOfBoundsException("index outof bound");
+        }
+        ensureOpen();
+
+        int currentDataLength = data.length - index;
+        int remainReadLength = length;
+        int offset1 = offset;
+        int result = 0;
+
+        while (currentDataLength <= remainReadLength) {
+            System.arraycopy(data, index, b, offset1, currentDataLength);
+            index += currentDataLength;
+            offset1 += currentDataLength;
+            result += currentDataLength;
+            remainReadLength -= currentDataLength;
+
+            if (!parent.continueOperation(true, true)) {
+                return result == 0 ? -1 : result;
+            }
+            currentDataLength = data.length - index;
+        }
+        if (remainReadLength > 0) {
+            System.arraycopy(data, index, b, offset1, remainReadLength);
+            index += remainReadLength;
+            result += remainReadLength;
+        }
+        return result;
+    }
+
+    /**
+     * Allows the <code>OperationImpl</code> thread to add body data to the
+     * input stream.
+     *
+     * @param body the data to add to the stream
+     *
+     * @param start the start of the body to array to copy
+     */
+    public synchronized void writeBytes(byte[] body, int start) {
+
+        int length = (body.length - start) + (data.length - index);
+        byte[] temp = new byte[length];
+
+        System.arraycopy(data, index, temp, 0, data.length - index);
+        System.arraycopy(body, start, temp, data.length - index, body.length - start);
+
+        data = temp;
+        index = 0;
+        notifyAll();
+    }
+
+    /**
+     * Verifies that this stream is open
+     *
+     * @exception IOException if the stream is not open
+     */
+    private void ensureOpen() throws IOException {
+        parent.ensureOpen();
+        if (!isOpen) {
+            throw new IOException("Input stream is closed");
+        }
+    }
+
+    /**
+     * Closes the input stream.  If the input stream is already closed, do
+     * nothing.
+     *
+     * @exception IOException this will never happen
+     */
+    @Override
+    public void close() throws IOException {
+        isOpen = false;
+        parent.streamClosed(true);
+    }
+}
diff --git a/obex/javax/obex/PrivateOutputStream.java b/obex/javax/obex/PrivateOutputStream.java
new file mode 100644
index 0000000..03d2363
--- /dev/null
+++ b/obex/javax/obex/PrivateOutputStream.java
@@ -0,0 +1,197 @@
+/*
+ * Copyright (c) 2008-2009, Motorola, Inc.
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the Motorola, Inc. nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package javax.obex;
+
+import java.io.*;
+
+/**
+ * This object provides an output stream to the Operation objects used in this
+ * package.
+ *
+ * @version 0.3 November 28, 2008
+ */
+class PrivateOutputStream extends OutputStream {
+
+    private BaseStream parent;
+
+    private ByteArrayOutputStream output;
+
+    private boolean isClosed;
+
+    private int maxPacketSize;
+
+    /**
+     * Creates an empty <code>PrivateOutputStream</code> to write to.
+     *
+     * @param p the connection that this stream runs over
+     */
+    public PrivateOutputStream(BaseStream p, int maxSize) {
+        parent = p;
+        output = new ByteArrayOutputStream();
+        maxPacketSize = maxSize;
+    }
+
+    /**
+     * Determines how many bytes have been written to the output stream.
+     *
+     * @return the number of bytes written to the output stream
+     */
+    protected int size() {
+        return output.size();
+    }
+
+    /**
+     * Writes the specified byte to this output stream. The general contract
+     * for write is that one byte is written to the output stream. The byte to
+     * be written is the eight low-order bits of the argument b. The 24
+     * high-order bits of b are ignored.
+     *
+     * @param b the byte to write
+     *
+     * @exception IOException if an I/O error occurs
+     */
+    @Override
+    public synchronized void write(int b) throws IOException {
+        ensureOpen();
+        parent.ensureNotDone();
+        output.write(b);
+        if (output.size() == maxPacketSize) {
+            parent.continueOperation(true, false);
+        }
+    }
+
+    @Override
+    public void write(byte[] buffer) throws IOException {
+        write(buffer, 0, buffer.length);
+    }
+
+    @Override
+    public synchronized void write(byte[] buffer, int offset, int count) throws IOException {
+        int offset1 = offset;
+        int remainLength = count;
+
+        if (buffer == null) {
+            throw new NullPointerException("buffer is null");
+        }
+        if ((offset | count) < 0 || count > buffer.length - offset) {
+            throw new IndexOutOfBoundsException("index outof bound");
+        }
+
+        ensureOpen();
+        parent.ensureNotDone();
+        if (count < maxPacketSize) {
+            output.write(buffer, offset, count);
+        } else {
+            while (remainLength >= maxPacketSize) {
+                output.write(buffer, offset1, maxPacketSize);
+                offset1 += maxPacketSize;
+                remainLength = count - offset1;
+                parent.continueOperation(true, false);
+            }
+            if (remainLength > 0) {
+                output.write(buffer, offset1, remainLength);
+            }
+        }
+    }
+
+    /**
+     * Reads the bytes that have been written to this stream.
+     *
+     * @return the byte array that is written
+     */
+    protected synchronized byte[] readBytes() {
+        if (output.size() > 0) {
+            byte[] result = output.toByteArray();
+            output.reset();
+            return result;
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Reads the bytes that have been written to this stream.
+     *
+     * @param size the size of the array to return
+     *
+     * @return the byte array that is written
+     */
+    protected synchronized byte[] readBytes(int size) {
+        if (output.size() > 0) {
+            byte[] temp = output.toByteArray();
+            output.reset();
+            byte[] result = new byte[size];
+            System.arraycopy(temp, 0, result, 0, size);
+            if (temp.length != size) {
+                output.write(temp, size, temp.length - size);
+            }
+            return result;
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Verifies that this stream is open
+     *
+     * @exception IOException if the stream is not open
+     */
+    private void ensureOpen() throws IOException {
+        parent.ensureOpen();
+        if (isClosed) {
+            throw new IOException("Output stream is closed");
+        }
+    }
+
+    /**
+     * Closes the output stream.  If the input stream is already closed, do
+     * nothing.
+     *
+     * @exception IOException this will never happen
+     */
+    @Override
+    public void close() throws IOException {
+        isClosed = true;
+        parent.streamClosed(false);
+    }
+
+    /**
+     * Determines if the connection is closed
+     *
+     * @return <code>true</code> if the connection is closed;
+     * <code>false</code> if the connection is open
+     */
+    protected boolean isClosed() {
+        return isClosed;
+    }
+}
diff --git a/obex/javax/obex/ResponseCodes.java b/obex/javax/obex/ResponseCodes.java
new file mode 100644
index 0000000..7496738
--- /dev/null
+++ b/obex/javax/obex/ResponseCodes.java
@@ -0,0 +1,324 @@
+/*
+ * Copyright (c) 2008-2009, Motorola, Inc.
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the Motorola, Inc. nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package javax.obex;
+
+/**
+ * The <code>ResponseCodes</code> class contains the list of valid
+ * response codes a server may send to a client.
+ * <P>
+ * <STRONG>IMPORTANT NOTE</STRONG>
+ * <P>
+ * It is important to note that these values are different then those defined
+ * in <code>javax.microedition.io.HttpConnection</code>.  The values in this
+ * interface represent the values defined in the IrOBEX specification.  The
+ * values in <code>javax.microedition.io.HttpConnection</code> represent values
+ * defined in the HTTP specification.
+ * <P>
+ * <code>OBEX_DATABASE_FULL</code> and <code>OBEX_DATABASE_LOCKED</code> require
+ * further description since they are not defined in HTTP.  The server will send
+ * an <code>OBEX_DATABASE_FULL</code> message when the client requests that
+ * something be placed into a database but the database is full (cannot take
+ * more data).   <code>OBEX_DATABASE_LOCKED</code> will be returned when the
+ * client wishes to access a database, database table, or database record that
+ * has been locked.
+ *
+ * @version 0.3 November 28, 2008
+ */
+public class ResponseCodes {
+
+    /**
+     * Defines the OBEX SUCCESS response code.
+     * <P>
+     * The value of <code>OBEX_HTTP_OK</code> is 0xA0 (160).
+     */
+    public static final int OBEX_HTTP_OK = 0xA0;
+
+    /**
+     * Defines the OBEX CREATED response code.
+     * <P>
+     * The value of <code>OBEX_HTTP_CREATED</code> is 0xA1 (161).
+     */
+    public static final int OBEX_HTTP_CREATED = 0xA1;
+
+    /**
+     * Defines the OBEX ACCEPTED response code.
+     * <P>
+     * The value of <code>OBEX_HTTP_ACCEPTED</code> is 0xA2 (162).
+     */
+    public static final int OBEX_HTTP_ACCEPTED = 0xA2;
+
+    /**
+     * Defines the OBEX NON-AUTHORITATIVE INFORMATION response code.
+     * <P>
+     * The value of <code>OBEX_HTTP_NOT_AUTHORITATIVE</code> is 0xA3 (163).
+     */
+    public static final int OBEX_HTTP_NOT_AUTHORITATIVE = 0xA3;
+
+    /**
+     * Defines the OBEX NO CONTENT response code.
+     * <P>
+     * The value of <code>OBEX_HTTP_NO_CONTENT</code> is 0xA4 (164).
+     */
+    public static final int OBEX_HTTP_NO_CONTENT = 0xA4;
+
+    /**
+     * Defines the OBEX RESET CONTENT response code.
+     * <P>
+     * The value of <code>OBEX_HTTP_RESET</code> is 0xA5 (165).
+     */
+    public static final int OBEX_HTTP_RESET = 0xA5;
+
+    /**
+     * Defines the OBEX PARTIAL CONTENT response code.
+     * <P>
+     * The value of <code>OBEX_HTTP_PARTIAL</code> is 0xA6 (166).
+     */
+    public static final int OBEX_HTTP_PARTIAL = 0xA6;
+
+    /**
+     * Defines the OBEX MULTIPLE_CHOICES response code.
+     * <P>
+     * The value of <code>OBEX_HTTP_MULT_CHOICE</code> is 0xB0 (176).
+     */
+    public static final int OBEX_HTTP_MULT_CHOICE = 0xB0;
+
+    /**
+     * Defines the OBEX MOVED PERMANENTLY response code.
+     * <P>
+     * The value of <code>OBEX_HTTP_MOVED_PERM</code> is 0xB1 (177).
+     */
+    public static final int OBEX_HTTP_MOVED_PERM = 0xB1;
+
+    /**
+     * Defines the OBEX MOVED TEMPORARILY response code.
+     * <P>
+     * The value of <code>OBEX_HTTP_MOVED_TEMP</code> is 0xB2 (178).
+     */
+    public static final int OBEX_HTTP_MOVED_TEMP = 0xB2;
+
+    /**
+     * Defines the OBEX SEE OTHER response code.
+     * <P>
+     * The value of <code>OBEX_HTTP_SEE_OTHER</code> is 0xB3 (179).
+     */
+    public static final int OBEX_HTTP_SEE_OTHER = 0xB3;
+
+    /**
+     * Defines the OBEX NOT MODIFIED response code.
+     * <P>
+     * The value of <code>OBEX_HTTP_NOT_MODIFIED</code> is 0xB4 (180).
+     */
+    public static final int OBEX_HTTP_NOT_MODIFIED = 0xB4;
+
+    /**
+     * Defines the OBEX USE PROXY response code.
+     * <P>
+     * The value of <code>OBEX_HTTP_USE_PROXY</code> is 0xB5 (181).
+     */
+    public static final int OBEX_HTTP_USE_PROXY = 0xB5;
+
+    /**
+     * Defines the OBEX BAD REQUEST response code.
+     * <P>
+     * The value of <code>OBEX_HTTP_BAD_REQUEST</code> is 0xC0 (192).
+     */
+    public static final int OBEX_HTTP_BAD_REQUEST = 0xC0;
+
+    /**
+     * Defines the OBEX UNAUTHORIZED response code.
+     * <P>
+     * The value of <code>OBEX_HTTP_UNAUTHORIZED</code> is 0xC1 (193).
+     */
+    public static final int OBEX_HTTP_UNAUTHORIZED = 0xC1;
+
+    /**
+     * Defines the OBEX PAYMENT REQUIRED response code.
+     * <P>
+     * The value of <code>OBEX_HTTP_PAYMENT_REQUIRED</code> is 0xC2 (194).
+     */
+    public static final int OBEX_HTTP_PAYMENT_REQUIRED = 0xC2;
+
+    /**
+     * Defines the OBEX FORBIDDEN response code.
+     * <P>
+     * The value of <code>OBEX_HTTP_FORBIDDEN</code> is 0xC3 (195).
+     */
+    public static final int OBEX_HTTP_FORBIDDEN = 0xC3;
+
+    /**
+     * Defines the OBEX NOT FOUND response code.
+     * <P>
+     * The value of <code>OBEX_HTTP_NOT_FOUND</code> is 0xC4 (196).
+     */
+    public static final int OBEX_HTTP_NOT_FOUND = 0xC4;
+
+    /**
+     * Defines the OBEX METHOD NOT ALLOWED response code.
+     * <P>
+     * The value of <code>OBEX_HTTP_BAD_METHOD</code> is 0xC5 (197).
+     */
+    public static final int OBEX_HTTP_BAD_METHOD = 0xC5;
+
+    /**
+     * Defines the OBEX NOT ACCEPTABLE response code.
+     * <P>
+     * The value of <code>OBEX_HTTP_NOT_ACCEPTABLE</code> is 0xC6 (198).
+     */
+    public static final int OBEX_HTTP_NOT_ACCEPTABLE = 0xC6;
+
+    /**
+     * Defines the OBEX PROXY AUTHENTICATION REQUIRED response code.
+     * <P>
+     * The value of <code>OBEX_HTTP_PROXY_AUTH</code> is 0xC7 (199).
+     */
+    public static final int OBEX_HTTP_PROXY_AUTH = 0xC7;
+
+    /**
+     * Defines the OBEX REQUEST TIME OUT response code.
+     * <P>
+     * The value of <code>OBEX_HTTP_TIMEOUT</code> is 0xC8 (200).
+     */
+    public static final int OBEX_HTTP_TIMEOUT = 0xC8;
+
+    /**
+     * Defines the OBEX METHOD CONFLICT response code.
+     * <P>
+     * The value of <code>OBEX_HTTP_CONFLICT</code> is 0xC9 (201).
+     */
+    public static final int OBEX_HTTP_CONFLICT = 0xC9;
+
+    /**
+     * Defines the OBEX METHOD GONE response code.
+     * <P>
+     * The value of <code>OBEX_HTTP_GONE</code> is 0xCA (202).
+     */
+    public static final int OBEX_HTTP_GONE = 0xCA;
+
+    /**
+     * Defines the OBEX METHOD LENGTH REQUIRED response code.
+     * <P>
+     * The value of <code>OBEX_HTTP_LENGTH_REQUIRED</code> is 0xCB (203).
+     */
+    public static final int OBEX_HTTP_LENGTH_REQUIRED = 0xCB;
+
+    /**
+     * Defines the OBEX PRECONDITION FAILED response code.
+     * <P>
+     * The value of <code>OBEX_HTTP_PRECON_FAILED</code> is 0xCC (204).
+     */
+    public static final int OBEX_HTTP_PRECON_FAILED = 0xCC;
+
+    /**
+     * Defines the OBEX REQUESTED ENTITY TOO LARGE response code.
+     * <P>
+     * The value of <code>OBEX_HTTP_ENTITY_TOO_LARGE</code> is 0xCD (205).
+     */
+    public static final int OBEX_HTTP_ENTITY_TOO_LARGE = 0xCD;
+
+    /**
+     * Defines the OBEX REQUESTED URL TOO LARGE response code.
+     * <P>
+     * The value of <code>OBEX_HTTP_REQ_TOO_LARGE</code> is 0xCE (206).
+     */
+    public static final int OBEX_HTTP_REQ_TOO_LARGE = 0xCE;
+
+    /**
+     * Defines the OBEX UNSUPPORTED MEDIA TYPE response code.
+     * <P>
+     * The value of <code>OBEX_HTTP_UNSUPPORTED_TYPE</code> is 0xCF (207).
+     */
+    public static final int OBEX_HTTP_UNSUPPORTED_TYPE = 0xCF;
+
+    /**
+     * Defines the OBEX INTERNAL SERVER ERROR response code.
+     * <P>
+     * The value of <code>OBEX_HTTP_INTERNAL_ERROR</code> is 0xD0 (208).
+     */
+    public static final int OBEX_HTTP_INTERNAL_ERROR = 0xD0;
+
+    /**
+     * Defines the OBEX NOT IMPLEMENTED response code.
+     * <P>
+     * The value of <code>OBEX_HTTP_NOT_IMPLEMENTED</code> is 0xD1 (209).
+     */
+    public static final int OBEX_HTTP_NOT_IMPLEMENTED = 0xD1;
+
+    /**
+     * Defines the OBEX BAD GATEWAY response code.
+     * <P>
+     * The value of <code>OBEX_HTTP_BAD_GATEWAY</code> is 0xD2 (210).
+     */
+    public static final int OBEX_HTTP_BAD_GATEWAY = 0xD2;
+
+    /**
+     * Defines the OBEX SERVICE UNAVAILABLE response code.
+     * <P>
+     * The value of <code>OBEX_HTTP_UNAVAILABLE</code> is 0xD3 (211).
+     */
+    public static final int OBEX_HTTP_UNAVAILABLE = 0xD3;
+
+    /**
+     * Defines the OBEX GATEWAY TIMEOUT response code.
+     * <P>
+     * The value of <code>OBEX_HTTP_GATEWAY_TIMEOUT</code> is 0xD4 (212).
+     */
+    public static final int OBEX_HTTP_GATEWAY_TIMEOUT = 0xD4;
+
+    /**
+     * Defines the OBEX HTTP VERSION NOT SUPPORTED response code.
+     * <P>
+     * The value of <code>OBEX_HTTP_VERSION</code> is 0xD5 (213).
+     */
+    public static final int OBEX_HTTP_VERSION = 0xD5;
+
+    /**
+     * Defines the OBEX DATABASE FULL response code.
+     * <P>
+     * The value of <code>OBEX_DATABASE_FULL</code> is 0xE0 (224).
+     */
+    public static final int OBEX_DATABASE_FULL = 0xE0;
+
+    /**
+     * Defines the OBEX DATABASE LOCKED response code.
+     * <P>
+     * The value of <code>OBEX_DATABASE_LOCKED</code> is 0xE1 (225).
+     */
+    public static final int OBEX_DATABASE_LOCKED = 0xE1;
+
+    /**
+     * Constructor does nothing.
+     */
+    private ResponseCodes() {
+        throw new RuntimeException("Not Implemented! Used to compile Code");
+    }
+}
diff --git a/obex/javax/obex/ServerOperation.java b/obex/javax/obex/ServerOperation.java
new file mode 100644
index 0000000..1b9c4e9
--- /dev/null
+++ b/obex/javax/obex/ServerOperation.java
@@ -0,0 +1,772 @@
+/*
+ * Copyright (c) 2008-2009, Motorola, Inc.
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the Motorola, Inc. nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package javax.obex;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.DataInputStream;
+import java.io.OutputStream;
+import java.io.DataOutputStream;
+import java.io.ByteArrayOutputStream;
+
+/**
+ * This class implements the Operation interface for server side connections.
+ * <P>
+ * <STRONG>Request Codes</STRONG>
+ * There are four different request codes that are in this class.  0x02 is a
+ * PUT request that signals that the request is not complete and requires an
+ * additional OBEX packet.  0x82 is a PUT request that says that request is
+ * complete.  In this case, the server can begin sending the response.  The
+ * 0x03 is a GET request that signals that the request is not finished.  When
+ * the server receives a 0x83, the client is signalling the server that it is
+ * done with its request.
+ *
+ * OPTIMIZATION: Extend the ClientOperation and reuse the methods defined
+ * OPTIMIZATION: in that class.
+ *
+ * @version 0.3 November 28, 2008
+ */
+public class ServerOperation implements Operation, BaseStream {
+
+    private InputStream socketInput;
+
+    private ServerSession parent;
+
+    private int maxPacketLength;
+
+    private int responseSize;
+
+    private boolean isClosed;
+
+    boolean finalBitSet;
+
+    private boolean endOfBody; // This variable defines when the end of body
+
+    // header has been received.  When this header
+    // is received, no further body data will be
+    // received from the client
+    private boolean isGet;
+
+    boolean isAborted;
+
+    HeaderSet requestHeaders;
+
+    HeaderSet replyHeaders;
+
+    PrivateInputStream privateInput;
+
+    private PrivateOutputStream privateOutput;
+
+    private String exceptionString;
+
+    private ServerRequestHandler listener;
+
+    private boolean outputStreamOpened;
+
+    private boolean requestFinished;
+
+    private static int BASE_PACKET_LENGTH = 3;
+
+    private static final String TAG = "ServerOperation";
+
+    private boolean isHasBody;
+
+    /**
+     * Creates new PutServerOperation
+     *
+     * @param p the parent that created this object
+     *
+     * @param in the input stream to read from
+     *
+     * @param out the output stream to write to
+     *
+     * @param request the initial request that was received from the client
+     *
+     * @param maxSize the max packet size that the client will accept
+     *
+     * @param listen the listener that is responding to the request
+     *
+     * @exception IOException if an IO error occurs
+     */
+    public ServerOperation(ServerSession p, InputStream in, int request, int maxSize,
+            ServerRequestHandler listen) throws IOException {
+
+        isAborted = false;
+        parent = p;
+        socketInput = in;
+        maxPacketLength = maxSize;
+        isClosed = false;
+        requestHeaders = new HeaderSet();
+        replyHeaders = new HeaderSet();
+        privateInput = new PrivateInputStream(this);
+        endOfBody = false;
+        responseSize = 3;
+        listener = listen;
+        requestFinished = false;
+        outputStreamOpened = false;
+        isHasBody = false;
+        int bytesReceived;
+
+        /*
+         * Determine if this is a PUT request
+         */
+        if ((request == 0x02) || (request == 0x82)) {
+            /*
+             * It is a PUT request.
+             */
+            isGet = false;
+        } else {
+            /*
+             * It is a GET request.
+             */
+            isGet = true;
+        }
+
+        /*
+         * Determine if the final bit is set
+         */
+        if ((request & 0x80) == 0) {
+            finalBitSet = false;
+        } else {
+            finalBitSet = true;
+            requestFinished = true;
+        }
+
+        int length = in.read();
+        length = (length << 8) + in.read();
+
+        /*
+         * Determine if the packet length is larger than this device can receive
+         */
+        if (length > OBEXConstants.MAX_PACKET_SIZE_INT) {
+            parent.sendResponse(ResponseCodes.OBEX_HTTP_REQ_TOO_LARGE, null);
+            throw new IOException("Packet received was too large");
+        }
+
+        /*
+         * Determine if any headers were sent in the initial request
+         */
+        if (length > 3) {
+            byte[] data = new byte[length - 3];
+            bytesReceived = in.read(data);
+
+            while (bytesReceived != data.length) {
+                bytesReceived += in.read(data, bytesReceived, data.length - bytesReceived);
+            }
+
+            byte[] body = OBEXHelper.updateHeaderSet(requestHeaders, data);
+
+            if (body != null) {
+                isHasBody = true;
+            }
+
+            if (requestHeaders.connectionID != null) {
+                listener.setConnectionID(OBEXHelper.convertToLong(requestHeaders.connectionID));
+            } else {
+                listener.setConnectionID(0);
+            }
+
+            if (requestHeaders.authResp != null) {
+                if (!parent.handleAuthResp(requestHeaders.authResp)) {
+                    exceptionString = "Authentication Failed";
+                    parent.sendResponse(ResponseCodes.OBEX_HTTP_UNAUTHORIZED, null);
+                    isClosed = true;
+                    requestHeaders.authResp = null;
+                    return;
+                }
+            }
+
+            if (requestHeaders.authChall != null) {
+                parent.handleAuthChall(requestHeaders);
+                // send the  authResp to the client
+                replyHeaders.authResp = new byte[requestHeaders.authResp.length];
+                System.arraycopy(requestHeaders.authResp, 0, replyHeaders.authResp, 0,
+                        replyHeaders.authResp.length);
+                requestHeaders.authResp = null;
+                requestHeaders.authChall = null;
+
+            }
+
+            if (body != null) {
+                /*
+                 * 0x49 is the end of body header.  This signifies that no more
+                 * body data will be sent from the client
+                 */
+                if (body[0] == 0x49) {
+                    endOfBody = true;
+                }
+                //privateInput.writeBytes(body, body.length);
+                //byte [] body_tmp = new byte[body.length-1];
+                //System.arraycopy(body,1,body_tmp,0,body.length-1);
+                //privateInput.writeBytes(body_tmp, body.length-1);
+                privateInput.writeBytes(body, 1);
+            } else {
+                while ((!isGet) && (!finalBitSet)) {
+                    sendReply(OBEXConstants.OBEX_HTTP_CONTINUE);
+                    if (privateInput.available() > 0) {
+                        break;
+                    }
+                }
+            }//  if (body != null) 
+
+        }// if (length > 3)
+
+        while ((!isGet) && (!finalBitSet) && (privateInput.available() == 0)) {
+            sendReply(OBEXConstants.OBEX_HTTP_CONTINUE);
+            if (privateInput.available() > 0) {
+                break;
+            }
+        }
+
+        // wait for get request finished !!!!
+        while (isGet && !finalBitSet) {
+            sendReply(OBEXConstants.OBEX_HTTP_CONTINUE);
+        }
+        if (finalBitSet && isGet) {
+            requestFinished = true;
+        }
+    }
+
+    public synchronized boolean isValidBody() {
+        return isHasBody;
+    }
+
+    /**
+     * Determines if the operation should continue or should wait.  If it
+     * should continue, this method will continue the operation.
+     *
+     * @param sendEmpty if <code>true</code> then this will continue the
+     * operation even if no headers will be sent; if <code>false</code> then
+     * this method will only continue the operation if there are headers to
+     * send
+     * @param isStream  if<code>true</code> the stream is input stream or
+     * is outputstream
+     * @return <code>true</code> if the operation was completed;
+     * <code>false</code> if no operation took place
+     */
+    public synchronized boolean continueOperation(boolean sendEmpty, boolean inStream)
+            throws IOException {
+        if (!isGet) {
+            if (!finalBitSet) {
+                if (sendEmpty) {
+                    sendReply(OBEXConstants.OBEX_HTTP_CONTINUE);
+                    return true;
+                } else {
+                    if ((responseSize > 3) || (privateOutput.size() > 0)) {
+                        sendReply(OBEXConstants.OBEX_HTTP_CONTINUE);
+                        return true;
+                    } else {
+                        return false;
+                    }
+                }
+            } else {
+                return false;
+            }
+        } else {
+            sendReply(OBEXConstants.OBEX_HTTP_CONTINUE);
+            return true;
+        }
+    }
+
+    /**
+     * Sends a reply to the client.  If the reply is a OBEX_HTTP_CONTINUE, it
+     * will wait for a response from the client before ending.
+     *
+     * @param type the response code to send back to the client
+     *
+     * @return <code>true</code> if the final bit was not set on the reply;
+     * <code>false</code> if no reply was received because the operation ended,
+     * an abort was received, or the final bit was set in the reply
+     *
+     * @exception IOException if an IO error occurs
+     */
+    protected synchronized boolean sendReply(int type) throws IOException {
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        int bytesReceived;
+
+        long id = listener.getConnectionID();
+        if (id == -1) {
+            replyHeaders.connectionID = null;
+        } else {
+            replyHeaders.connectionID = OBEXHelper.convertToByteArray(id);
+        }
+
+        byte[] headerArray = OBEXHelper.createHeader(replyHeaders, true);
+        int bodyLength = -1;
+        int orginalBodyLength = -1;
+
+        if (privateOutput != null) {
+            bodyLength = privateOutput.size();
+            orginalBodyLength = bodyLength;
+        }
+
+        if ((BASE_PACKET_LENGTH + headerArray.length) > maxPacketLength) {
+
+            int end = 0;
+            int start = 0;
+
+            while (end != headerArray.length) {
+                end = OBEXHelper.findHeaderEnd(headerArray, start, maxPacketLength
+                        - BASE_PACKET_LENGTH);
+                if (end == -1) {
+
+                    isClosed = true;
+
+                    if (privateInput != null) {
+                        privateInput.close();
+                    }
+
+                    if (privateOutput != null) {
+                        privateOutput.close();
+                    }
+                    parent.sendResponse(ResponseCodes.OBEX_HTTP_INTERNAL_ERROR, null);
+                    throw new IOException("OBEX Packet exceeds max packet size");
+                }
+                byte[] sendHeader = new byte[end - start];
+                System.arraycopy(headerArray, start, sendHeader, 0, sendHeader.length);
+
+                parent.sendResponse(type, sendHeader);
+                start = end;
+            }
+
+            if (bodyLength > 0) {
+                return true;
+            } else {
+                return false;
+            }
+
+        } else {
+            out.write(headerArray);
+        }
+
+        /*
+         * Determine if there is space to add a body reply.  First, we need to
+         * verify that the client is finished sending the request.  Next, there
+         * needs to be enough space to send the headers already defined along
+         * with the reply header (3 bytes) and the body header identifier
+         * (3 bytes).
+         */
+
+        /*        if ((finalBitSet) &&
+                    ((bodyLength + 6 + headerArray.length) > maxPacketLength)) {
+
+                    exceptionString = "Header larger then can be sent in a packet";
+                    isClosed = true;
+                    privateInput.close();
+                    if (privateOutput != null) {
+                        privateOutput.close();
+                    }
+                    parent.sendResponse(ResponseCodes.OBEX_HTTP_INTERNAL_ERROR,
+                        null);
+                    throw new IOException("OBEX Packet exceeds max packet size");
+                }
+        */
+         
+        if ((finalBitSet) || (headerArray.length < (maxPacketLength - 20))) {
+            if (bodyLength > 0) {
+                /*
+                 * Determine if I can send the whole body or just part of
+                 * the body.  Remember that there is the 3 bytes for the
+                 * response message and 3 bytes for the header ID and length
+                 */
+                if (bodyLength > (maxPacketLength - headerArray.length - 6)) {
+                    bodyLength = maxPacketLength - headerArray.length - 6;
+                }
+
+                byte[] body = privateOutput.readBytes(bodyLength);
+
+                /*
+                 * Since this is a put request if the final bit is set or
+                 * the output stream is closed we need to send the 0x49
+                 * (End of Body) otherwise, we need to send 0x48 (Body)
+                 */
+                if ((finalBitSet) || (privateOutput.isClosed())) {
+                    out.write(0x49);
+                } else {
+                    out.write(0x48);
+                }
+
+                bodyLength += 3;
+                out.write((byte)(bodyLength >> 8));
+                out.write((byte)bodyLength);
+                out.write(body);
+            }
+        }
+
+        if ((finalBitSet) && (type == ResponseCodes.OBEX_HTTP_OK) && (orginalBodyLength <= 0)) {
+            out.write(0x49);
+            orginalBodyLength = 3;
+            out.write((byte)(orginalBodyLength >> 8));
+            out.write((byte)orginalBodyLength);
+
+        }
+
+        responseSize = 3;
+        parent.sendResponse(type, out.toByteArray());
+
+        if (type == OBEXConstants.OBEX_HTTP_CONTINUE) {
+            int headerID = socketInput.read();
+            int length = socketInput.read();
+            length = (length << 8) + socketInput.read();
+            if ((headerID != 0x02) && (headerID != 0x82) && (headerID != 0x03)
+                    && (headerID != 0x83)) {
+
+                if (length > 3) {
+                    byte[] temp = new byte[length];
+                    bytesReceived = socketInput.read(temp);
+
+                    while (bytesReceived != length) {
+                        bytesReceived += socketInput.read(temp, bytesReceived, length
+                                - bytesReceived);
+                    }
+                }
+
+                /*
+                 * Determine if an ABORT was sent as the reply
+                 */
+                if (headerID == 0xFF) {
+                    parent.sendResponse(ResponseCodes.OBEX_HTTP_OK, null);
+                    isClosed = true;
+                    isAborted = true;
+                    exceptionString = "Abort Received";
+                    throw new IOException("Abort Received");
+                } else {
+                    parent.sendResponse(ResponseCodes.OBEX_HTTP_BAD_REQUEST, null);
+                    isClosed = true;
+                    exceptionString = "Bad Request Received";
+                    throw new IOException("Bad Request Received");
+                }
+            } else {
+
+                if ((headerID == 0x82) || (headerID == 0x83)) {
+                    finalBitSet = true;
+                }
+
+                /*
+                 * Determine if the packet length is larger then this device can receive
+                 */
+                if (length > OBEXConstants.MAX_PACKET_SIZE_INT) {
+                    parent.sendResponse(ResponseCodes.OBEX_HTTP_REQ_TOO_LARGE, null);
+                    throw new IOException("Packet received was too large");
+                }
+
+                /*
+                 * Determine if any headers were sent in the initial request
+                 */
+                if (length > 3) {
+                    byte[] data = new byte[length - 3];
+                    bytesReceived = socketInput.read(data);
+
+                    while (bytesReceived != data.length) {
+                        bytesReceived += socketInput.read(data, bytesReceived, data.length
+                                - bytesReceived);
+                    }
+                    byte[] body = OBEXHelper.updateHeaderSet(requestHeaders, data);
+                    if (body != null) {
+                        isHasBody = true;
+                    }
+                    if (requestHeaders.connectionID != null) {
+                        listener.setConnectionID(OBEXHelper
+                                .convertToLong(requestHeaders.connectionID));
+                    } else {
+                        listener.setConnectionID(1);
+                    }
+
+                    if (requestHeaders.authResp != null) {
+                        if (!parent.handleAuthResp(requestHeaders.authResp)) {
+                            exceptionString = "Authentication Failed";
+                            parent.sendResponse(ResponseCodes.OBEX_HTTP_UNAUTHORIZED, null);
+                            isClosed = true;
+                            requestHeaders.authResp = null;
+                            return false;
+                        }
+                        requestHeaders.authResp = null;
+                    }
+
+                    if (requestHeaders.authChall != null) {
+                        parent.handleAuthChall(requestHeaders);
+                        // send the auhtResp to the client
+                        replyHeaders.authResp = new byte[requestHeaders.authResp.length];
+                        System.arraycopy(requestHeaders.authResp, 0, replyHeaders.authResp, 0,
+                                replyHeaders.authResp.length);
+                        requestHeaders.authResp = null;
+                        requestHeaders.authChall = null;
+                    }
+
+                    if (body != null) {
+                        if (body[0] == 0x49) {
+                            endOfBody = true;
+                        }
+
+                        /*byte [] body_tmp = new byte[body.length-1];
+                        System.arraycopy(body,1,body_tmp,0,body.length-1);
+                        privateInput.writeBytes(body_tmp, body.length-1);*/
+                        privateInput.writeBytes(body, 1);
+
+                    }
+                }
+            }
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * Sends an ABORT message to the server.  By calling this method, the
+     * corresponding input and output streams will be closed along with this
+     * object.
+     *
+     * @exception IOException if the transaction has already ended or if an
+     * OBEX server called this method
+     */
+    public void abort() throws IOException {
+        throw new IOException("Called from a server");
+    }
+
+    /**
+     * Returns the headers that have been received during the operation.
+     * Modifying the object returned has no effect on the headers that are
+     * sent or retrieved.
+     *
+     * @return the headers received during this <code>Operation</code>
+     *
+     * @exception IOException if this <code>Operation</code> has been closed
+     */
+    public HeaderSet getReceivedHeaders() throws IOException {
+        ensureOpen();
+        return requestHeaders;
+    }
+
+    /**
+     * Specifies the headers that should be sent in the next OBEX message that
+     * is sent.
+     *
+     * @param headers the headers to send in the next message
+     *
+     * @exception IOException  if this <code>Operation</code> has been closed
+     * or the transaction has ended and no further messages will be exchanged
+     *
+     * @exception IllegalArgumentException if <code>headers</code> was not created
+     * by a call to <code>ServerRequestHandler.createHeaderSet()</code>
+     */
+    public void sendHeaders(HeaderSet headers) throws IOException {
+        ensureOpen();
+
+        if (headers == null) {
+            throw new NullPointerException("Headers may not be null");
+        }
+
+        int[] headerList = headers.getHeaderList();
+        if (headerList != null) {
+            for (int i = 0; i < headerList.length; i++) {
+                replyHeaders.setHeader(headerList[i], headers.getHeader(headerList[i]));
+            }
+
+        }
+    }
+
+    /**
+     * Retrieves the response code retrieved from the server.  Response codes
+     * are defined in the <code>ResponseCodes</code> interface.
+     *
+     * @return the response code retrieved from the server
+     *
+     * @exception IOException if an error occurred in the transport layer during
+     * the transaction; if this method is called on a <code>HeaderSet</code>
+     * object created by calling <code>createHeaderSet</code> in a
+     * <code>ClientSession</code> object; if this is called from a server
+     */
+    public int getResponseCode() throws IOException {
+        throw new IOException("Called from a server");
+    }
+
+    /**
+     * Always returns <code>null</code>
+     *
+     * @return <code>null</code>
+     */
+    public String getEncoding() {
+        return null;
+    }
+
+    /**
+     * Returns the type of content that the resource connected to is providing.
+     * E.g. if the connection is via HTTP, then the value of the content-type
+     * header field is returned.
+     *
+     * @return the content type of the resource that the URL references, or
+     * <code>null</code> if not known
+     */
+    public String getType() {
+        try {
+            return (String)requestHeaders.getHeader(HeaderSet.TYPE);
+        } catch (IOException e) {
+            return null;
+        }
+    }
+
+    /**
+     * Returns the length of the content which is being provided. E.g. if the
+     * connection is via HTTP, then the value of the content-length header
+     * field is returned.
+     *
+     * @return the content length of the resource that this connection's URL
+     * references, or -1 if the content length is not known
+     */
+    public long getLength() {
+        try {
+            Long temp = (Long)requestHeaders.getHeader(HeaderSet.LENGTH);
+
+            if (temp == null) {
+                return -1;
+            } else {
+                return temp.longValue();
+            }
+        } catch (IOException e) {
+            return -1;
+        }
+    }
+
+    public int getMaxPacketSize() {
+        return maxPacketLength - 6;
+    }
+
+    /**
+     * Open and return an input stream for a connection.
+     *
+     * @return an input stream
+     *
+     * @exception IOException if an I/O error occurs
+     */
+    public InputStream openInputStream() throws IOException {
+        ensureOpen();
+        return privateInput;
+    }
+
+    /**
+     * Open and return a data input stream for a connection.
+     *
+     * @return an input stream
+     *
+     * @exception IOException if an I/O error occurs
+     */
+    public DataInputStream openDataInputStream() throws IOException {
+        return new DataInputStream(openInputStream());
+    }
+
+    /**
+     * Open and return an output stream for a connection.
+     *
+     * @return an output stream
+     *
+     * @exception IOException if an I/O error occurs
+     */
+    public OutputStream openOutputStream() throws IOException {
+        ensureOpen();
+
+        if (outputStreamOpened)
+            throw new IOException("no more input streams available, stream already opened");
+
+        if (!requestFinished)
+            throw new IOException("no  output streams available ,request not finished");
+
+        if (privateOutput == null) {
+            privateOutput = new PrivateOutputStream(this, maxPacketLength - 6);
+        }
+        outputStreamOpened = true;
+        return privateOutput;
+    }
+
+    /**
+     * Open and return a data output stream for a connection.
+     *
+     * @return an output stream
+     *
+     * @exception IOException if an I/O error occurs
+     */
+    public DataOutputStream openDataOutputStream() throws IOException {
+        return new DataOutputStream(openOutputStream());
+    }
+
+    /**
+     * Closes the connection and ends the transaction
+     *
+     * @exception IOException if the operation has already ended or is closed
+     */
+    public void close() throws IOException {
+        ensureOpen();
+        isClosed = true;
+    }
+
+    /**
+     * Verifies that the connection is open and no exceptions should be thrown.
+     *
+     * @exception IOException if an exception needs to be thrown
+     */
+    public void ensureOpen() throws IOException {
+        if (exceptionString != null) {
+            throw new IOException(exceptionString);
+        }
+        if (isClosed) {
+            throw new IOException("Operation has already ended");
+        }
+    }
+
+    /**
+     * Verifies that additional information may be sent.  In other words, the
+     * operation is not done.
+     * <P>
+     * Included to implement the BaseStream interface only.  It does not do
+     * anything on the server side since the operation of the Operation object
+     * is not done until after the handler returns from its method.
+     *
+     * @exception IOException if the operation is completed
+     */
+    public void ensureNotDone() throws IOException {
+    }
+
+    /**
+     * Called when the output or input stream is closed.  It does not do
+     * anything on the server side since the operation of the Operation object
+     * is not done until after the handler returns from its method.
+     *
+     * @param inStream <code>true</code> if the input stream is closed;
+     * <code>false</code> if the output stream is closed
+     *
+     * @exception IOException if an IO error occurs
+     */
+    public void streamClosed(boolean inStream) throws IOException {
+
+    }
+}
diff --git a/obex/javax/obex/ServerRequestHandler.java b/obex/javax/obex/ServerRequestHandler.java
new file mode 100644
index 0000000..4e7f5b4
--- /dev/null
+++ b/obex/javax/obex/ServerRequestHandler.java
@@ -0,0 +1,288 @@
+/*
+ * Copyright (c) 2008-2009, Motorola, Inc.
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the Motorola, Inc. nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package javax.obex;
+
+/**
+ * The <code>ServerRequestHandler</code> class defines an event
+ * listener that will respond to OBEX requests made to the server.
+ * <P>
+ * The <code>onConnect()</code>, <code>onSetPath()</code>, <code>onDelete()</code>,
+ * <code>onGet()</code>,
+ * and <code>onPut()</code> methods may return any response code defined
+ * in the <code>ResponseCodes</code> class except for
+ * <code>OBEX_HTTP_CONTINUE</code>.  If <code>OBEX_HTTP_CONTINUE</code> or
+ * a value not defined in the <code>ResponseCodes</code> class is returned,
+ * the server implementation will send an <code>OBEX_HTTP_INTERNAL_ERROR</code>
+ * response to the client.
+ * <P>
+ * <STRONG>Connection ID and Target Headers</STRONG>
+ * <P>
+ * According to the IrOBEX specification, a packet may not contain a Connection
+ * ID and Target header.  Since the Connection ID header is managed by the
+ * implementation, it will not send a Connection ID header, if a Connection ID
+ * was specified, in a packet that has a Target header.  In other words, if an
+ * application adds a Target header to a <code>HeaderSet</code> object used
+ * in an OBEX operation and a Connection ID was specified, no Connection ID
+ * will be sent in the packet containing the Target header.
+ * <P>
+ * <STRONG>CREATE-EMPTY Requests</STRONG>
+ * <P>
+ * A CREATE-EMPTY request allows clients to create empty objects on the server.
+ * When a CREATE-EMPTY request is received, the <code>onPut()</code> method
+ * will be called by the implementation.  To differentiate between a normal
+ * PUT request and a CREATE-EMPTY request, an application must open the
+ * <code>InputStream</code> from the <code>Operation</code> object passed
+ * to the <code>onPut()</code> method.  For a PUT request, the application
+ * will be able to read Body data from this <code>InputStream</code>.  For
+ * a CREATE-EMPTY request, there will be no Body data to read.  Therefore,
+ * a call to <code>InputStream.read()</code> will return -1.
+ *
+ * @version 0.3 November 28, 2008
+ */
+public class ServerRequestHandler {
+
+    private long connectionID;
+
+    /**
+      * Creates a <code>ServerRequestHandler</code>.
+      */
+    protected ServerRequestHandler() {
+        /*
+         * A connection ID of -1 implies there is no conenction ID
+         */
+        connectionID = -1;
+    }
+
+    /**
+     * Creates a <code>HeaderSet</code> object that may be used in put and get
+     * operations.
+     *
+     * @return the <code>HeaderSet</code> object to use in put and get operations
+     */
+    public final HeaderSet createHeaderSet() {
+        return new HeaderSet();
+    }
+
+    /**
+     * Sets the connection ID header to include in the reply packets.
+     *
+     * @param id the connection ID to use; -1 if no connection ID should be
+     * sent
+     *
+     * @exception IllegalArgumentException if <code>id</code> is not in the
+     * range -1 to 2<sup>32</sup>-1
+     */
+    public void setConnectionID(long id) {
+        if ((id < -1) || (id > 0xFFFFFFFFL)) {
+            throw new IllegalArgumentException("Illegal Connection ID");
+        }
+        connectionID = id;
+    }
+
+    /**
+     * Retrieves the connection ID that is being used in the present connection.
+     * This method will return -1 if no connection ID is being used.
+     *
+     * @return the connection id being used or -1 if no connection ID is being
+     * used
+     */
+    public long getConnectionID() {
+        return connectionID;
+    }
+
+    /**
+     * Called when a CONNECT request is received.
+     * <P>
+     * If this method is not implemented by the class that extends this
+     * class, <code>onConnect()</code> will always return an
+     * <code>OBEX_HTTP_OK</code> response code.
+     * <P>
+     * The headers received in the request can be retrieved from the
+     * <code>request</code> argument.  The headers that should be sent
+     * in the reply must be specified in the <code>reply</code> argument.
+     *
+     * @param request contains the headers sent by the client;
+     * <code>request</code> will never be <code>null</code>
+     *
+     * @param reply the headers that should be sent in the reply;
+     * <code>reply</code> will never be <code>null</code>
+     *
+     * @return a response code defined in <code>ResponseCodes</code> that will be
+     * returned to the client; if an invalid response code is provided, the
+     * <code>OBEX_HTTP_INTERNAL_ERROR</code> response code will be used
+     */
+    public int onConnect(HeaderSet request, HeaderSet reply) {
+        return ResponseCodes.OBEX_HTTP_OK;
+    }
+
+    /**
+     * Called when a DISCONNECT request is received.
+     * <P>
+     * The headers received in the request can be retrieved from the
+     * <code>request</code> argument.  The headers that should be sent
+     * in the reply must be specified in the <code>reply</code> argument.
+     *
+     * @param request contains the headers sent by the client;
+     * <code>request</code> will never be <code>null</code>
+     *
+     * @param reply the headers that should be sent in the reply;
+     * <code>reply</code> will never be <code>null</code>
+     */
+    public void onDisconnect(HeaderSet request, HeaderSet reply) {
+    }
+
+    /**
+     * Called when a SETPATH request is received.
+     * <P>
+     * If this method is not implemented by the class that extends this
+     * class, <code>onSetPath()</code> will always return an
+     * <code>OBEX_HTTP_NOT_IMPLEMENTED</code> response code.
+     * <P>
+     * The headers received in the request can be retrieved from the
+     * <code>request</code> argument.  The headers that should be sent
+     * in the reply must be specified in the <code>reply</code> argument.
+     *
+     * @param request contains the headers sent by the client;
+     * <code>request</code> will never be <code>null</code>
+     *
+     * @param reply the headers that should be sent in the reply;
+     * <code>reply</code> will never be <code>null</code>
+     *
+     * @param backup <code>true</code> if the client requests that the server
+     * back up one directory before changing to the path described by
+     * <code>name</code>; <code>false</code> to apply the request to the present
+     * path
+     *
+     * @param create <code>true</code> if the path should be created if it does
+     * not already exist; <code>false</code> if the path should not be created
+     * if it does not exist and an error code should be returned
+     *
+     * @return a response code defined in <code>ResponseCodes</code> that will be
+     * returned to the client; if an invalid response code is provided, the
+     * <code>OBEX_HTTP_INTERNAL_ERROR</code> response code will be used
+     */
+    public int onSetPath(HeaderSet request, HeaderSet reply, boolean backup, boolean create) {
+
+        return ResponseCodes.OBEX_HTTP_NOT_IMPLEMENTED;
+    }
+
+    /**
+     * Called when a DELETE request is received.
+     * <P>
+     * If this method is not implemented by the class that extends this
+     * class, <code>onDelete()</code> will always return an
+     * <code>OBEX_HTTP_NOT_IMPLEMENTED</code> response code.
+     * <P>
+     * The headers received in the request can be retrieved from the
+     * <code>request</code> argument.  The headers that should be sent
+     * in the reply must be specified in the <code>reply</code> argument.
+     *
+     * @param request contains the headers sent by the client;
+     * <code>request</code> will never be <code>null</code>
+     *
+     * @param reply the headers that should be sent in the reply;
+     * <code>reply</code> will never be <code>null</code>
+     *
+     * @return a response code defined in <code>ResponseCodes</code> that will be
+     * returned to the client; if an invalid response code is provided, the
+     * <code>OBEX_HTTP_INTERNAL_ERROR</code> response code will be used
+     */
+    public int onDelete(HeaderSet request, HeaderSet reply) {
+        return ResponseCodes.OBEX_HTTP_NOT_IMPLEMENTED;
+    }
+
+    /**
+     * Called when a PUT request is received.
+     * <P>
+     * If this method is not implemented by the class that extends this
+     * class, <code>onPut()</code> will always return an
+     * <code>OBEX_HTTP_NOT_IMPLEMENTED</code> response code.
+     * <P>
+     * If an ABORT request is received during the processing of a PUT request,
+     * <code>op</code> will be closed by the implementation.
+     *
+     * @param op contains the headers sent by the client and allows new
+     * headers to be sent in the reply; <code>op</code> will never be
+     * <code>null</code>
+     *
+     * @return a response code defined in <code>ResponseCodes</code> that will be
+     * returned to the client; if an invalid response code is provided, the
+     * <code>OBEX_HTTP_INTERNAL_ERROR</code> response code will be used
+     */
+    public int onPut(Operation op) {
+        return ResponseCodes.OBEX_HTTP_NOT_IMPLEMENTED;
+    }
+
+    /**
+     * Called when a GET request is received.
+     * <P>
+     * If this method is not implemented by the class that extends this
+     * class, <code>onGet()</code> will always return an
+     * <code>OBEX_HTTP_NOT_IMPLEMENTED</code> response code.
+     * <P>
+     * If an ABORT request is received during the processing of a GET request,
+     * <code>op</code> will be closed by the implementation.
+     *
+     * @param op contains the headers sent by the client and allows new
+     * headers to be sent in the reply; <code>op</code> will never be
+     * <code>null</code>
+     *
+     * @return a response code defined in <code>ResponseCodes</code> that will be
+     * returned to the client; if an invalid response code is provided, the
+     * <code>OBEX_HTTP_INTERNAL_ERROR</code> response code will be used
+     */
+    public int onGet(Operation op) {
+        return ResponseCodes.OBEX_HTTP_NOT_IMPLEMENTED;
+    }
+
+    /**
+     * Called when this object attempts to authenticate a client and the
+     * authentication request fails because the response digest in the
+     * authentication response header was wrong.
+     * <P>
+     * If this method is not implemented by the class that extends this class,
+     * this method will do nothing.
+     *
+     * @param userName the user name returned in the authentication response;
+     * <code>null</code> if no user name was provided in the response
+     */
+    public void onAuthenticationFailure(byte[] userName) {
+    }
+
+    /**Called by ServerSession to update the status of current transaction */
+    public void updateStatus(String message) {
+    }
+
+    public void onClose() {
+    }
+}
diff --git a/obex/javax/obex/ServerSession.java b/obex/javax/obex/ServerSession.java
new file mode 100644
index 0000000..31c82cc
--- /dev/null
+++ b/obex/javax/obex/ServerSession.java
@@ -0,0 +1,923 @@
+/*
+ * Copyright (c) 2008-2009, Motorola, Inc.
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the Motorola, Inc. nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package javax.obex;
+
+import java.io.*;
+
+/**
+ * This class in an implementation of the ServerSession interface.
+ * 
+ * @version 0.3 November 28, 2008
+ */
+public class ServerSession implements Runnable, ObexSession {
+
+    private ObexTransport client;
+
+    // private Socket client ;
+    private InputStream input;
+
+    private OutputStream output;
+
+    private ServerRequestHandler listener;
+
+    private Thread processThread;
+
+    private int maxPacketLength;
+
+    private Authenticator authenticator;
+
+    byte[] challengeDigest;
+
+    public boolean isClosed;
+
+    private static final String TAG = "ServerSession";
+
+    /**
+     * Creates new ServerSession.
+     *
+     * @param conn
+     *            the connection to the client
+     *
+     * @param handler
+     *            the event listener that will process requests
+     *
+     * @param auth
+     *            the authenticator to use with this connection
+     *
+     * @exception IOException
+     *                if an error occurred while opening the input and output
+     *                streams
+     */
+    public ServerSession(ObexTransport conn, ServerRequestHandler handler, Authenticator auth)
+            throws IOException {
+        authenticator = auth;
+        client = conn;
+        input = client.openInputStream();
+        output = client.openOutputStream();
+        listener = handler;
+        maxPacketLength = 256;
+
+        isClosed = false;
+        processThread = new Thread(this);
+        processThread.start();
+    }
+
+    /* removed as they're provided to the API user. Not used internally. */
+    /*
+     public boolean isCreatedServer() {
+        if (client instanceof BTConnection)
+            return ((BTConnection)client).isServerCreated();
+        else
+            return false;
+    }
+
+    public boolean isClosed() {
+        if (client instanceof BTConnection)
+            return ((BTConnection)client).isClosed();
+        else
+            return false;
+    }
+
+    public int getConnectionHandle() {
+        if (client instanceof BTConnection)
+            return ((BTConnection)client).getConnectionHandle();
+        else
+            return -1;
+    }
+
+    public RemoteDevice getRemoteDevice() {
+        if (client instanceof BTConnection)
+            return ((BTConnection)client).getRemoteDevice();
+        else
+            return null;
+    }*/
+
+    /**
+     * Processes requests made to the server and forwards them to the
+     * appropriate event listener.
+     */
+    public void run() {
+        try {
+
+            boolean done = false;
+            while (!done && !isClosed) {
+                int requestType = input.read();
+                switch (requestType) {
+                    case 0x80:
+                        handleConnectRequest();
+                        break;
+
+                    case 0x81:
+                        handleDisconnectRequest();
+                        done = true;
+                        break;
+
+                    case 0x03:
+                    case 0x83:
+                        handleGetRequest(requestType);
+                        break;
+
+                    case 0x02:
+                    case 0x82:
+                        handlePutRequest(requestType);
+                        break;
+
+                    case 0x85:
+                        handleSetPathRequest();
+                        break;
+
+                    case -1:
+                        done = true;
+                        break;
+
+                    default:
+
+                        /*
+                         * Received a request type that is not recognized so I am
+                         * just going to read the packet and send a not implemented
+                         * to the client
+                         */
+                        int length = input.read();
+                        length = (length << 8) + input.read();
+                        for (int i = 3; i < length; i++) {
+                            input.read();
+                        }
+                        sendResponse(ResponseCodes.OBEX_HTTP_NOT_IMPLEMENTED, null);
+
+                        // done = true;
+                }
+            }
+
+        } catch (NullPointerException e) {
+        } catch (Exception e) {
+        }
+        close();
+    }
+
+    /**
+     * Handles a PUT request from a client. This method will provide a
+     * <code>ServerOperation</code> object to the request handler. The
+     * <code>ServerOperation</code> object will handle the rest of the request.
+     * It will also send replies and receive requests until the final reply
+     * should be sent. When the final reply should be sent, this method will get
+     * the response code to use and send the reply. The
+     * <code>ServerOperation</code> object will always reply with a
+     * OBEX_HTTP_CONTINUE reply. It will only reply if further information is
+     * needed.
+     *
+     * @param type
+     *            the type of request received; either 0x02 or 0x82
+     *
+     * @exception IOException
+     *                if an error occurred at the transport layer
+     */
+    private void handlePutRequest(int type) throws IOException {
+        ServerOperation client = new ServerOperation(this, input, type, maxPacketLength, listener);
+        try {
+            int response = -1;
+
+            if ((client.finalBitSet) && !client.isValidBody()) {
+                response = validateResponseCode(listener.onDelete(client.requestHeaders,
+                        client.replyHeaders));
+            } else {
+                response = validateResponseCode(listener.onPut(client));
+            }
+            if (response != ResponseCodes.OBEX_HTTP_OK) {
+                client.sendReply(response);
+            } else if (!client.isAborted) {
+                // wait for the final bit
+                while (!client.finalBitSet) {
+                    client.sendReply(OBEXConstants.OBEX_HTTP_CONTINUE);
+                }
+                client.sendReply(response);
+            }
+        } catch (Exception e) {
+            sendResponse(ResponseCodes.OBEX_HTTP_INTERNAL_ERROR, null);
+        }
+    }
+
+    /**
+     * Handles a GET request from a client. This method will provide a
+     * <code>ServerOperation</code> object to the request handler. The
+     * <code>ServerOperation</code> object will handle the rest of the request.
+     * It will also send replies and receive requests until the final reply
+     * should be sent. When the final reply should be sent, this method will get
+     * the response code to use and send the reply. The
+     * <code>ServerOperation</code> object will always reply with a
+     * OBEX_HTTP_CONTINUE reply. It will only reply if further information is
+     * needed.
+     *
+     * @param type
+     *            the type of request received; either 0x03 or 0x83
+     *
+     * @exception IOException
+     *                if an error occurred at the transport layer
+     */
+    private void handleGetRequest(int type) throws IOException {
+        ServerOperation client = new ServerOperation(this, input, type, maxPacketLength, listener);
+        try {
+            int response = validateResponseCode(listener.onGet(client));
+
+            if (!client.isAborted) {
+                client.sendReply(response);
+            }
+        } catch (Exception e) {
+            sendResponse(ResponseCodes.OBEX_HTTP_INTERNAL_ERROR, null);
+        }
+    }
+
+    /**
+     * Send standard response.
+     *
+     * @param code
+     *            the response code to send
+     *
+     * @param header
+     *            the headers to include in the response
+     *
+     * @exception IOException
+     *                if an IO error occurs
+     */
+    protected void sendResponse(int code, byte[] header) throws IOException {
+        int totalLength = 3;
+        byte[] data = null;
+
+        if (header != null) {
+            totalLength += header.length;
+            data = new byte[totalLength];
+            data[0] = (byte)code;
+            data[1] = (byte)(totalLength >> 8);
+            data[2] = (byte)totalLength;
+            System.arraycopy(header, 0, data, 3, header.length);
+        } else {
+            data = new byte[totalLength];
+            data[0] = (byte)code;
+            data[1] = (byte)0x00;
+            data[2] = (byte)totalLength;
+        }
+        output.write(data);
+        output.flush();
+    }
+
+    /**
+     * Handles a SETPATH request from a client. This method will read the rest
+     * of the request from the client. Assuming the request is valid, it will
+     * create a <code>HeaderSet</code> object to pass to the
+     * <code>ServerRequestHandler</code> object. After the handler processes the
+     * request, this method will create a reply message to send to the server
+     * with the response code provided.
+     *
+     * @exception IOException
+     *                if an error occurred at the transport layer
+     */
+    private void handleSetPathRequest() throws IOException {
+        int length;
+        int flags;
+        int constants;
+        int totalLength = 3;
+        byte[] head = null;
+        int code = -1;
+        int bytesReceived;
+        HeaderSet request = new HeaderSet();
+        HeaderSet reply = new HeaderSet();
+
+        length = input.read();
+        length = (length << 8) + input.read();
+        flags = input.read();
+        constants = input.read();
+
+        if (length > OBEXConstants.MAX_PACKET_SIZE_INT) {
+            code = ResponseCodes.OBEX_HTTP_REQ_TOO_LARGE;
+            totalLength = 3;
+        } else {
+            if (length > 5) {
+                byte[] headers = new byte[length - 5];
+                bytesReceived = input.read(headers);
+
+                while (bytesReceived != headers.length) {
+                    bytesReceived += input.read(headers, bytesReceived, headers.length
+                            - bytesReceived);
+                }
+
+                OBEXHelper.updateHeaderSet(request, headers);
+
+                if (request.connectionID != null) {
+                    listener.setConnectionID(OBEXHelper.convertToLong(request.connectionID));
+                } else {
+                    listener.setConnectionID(-1);
+                }
+                // the Auth chan is initiated by the server.
+                // client sent back the authResp .
+                if (request.authResp != null) {
+                    if (!handleAuthResp(request.authResp)) {
+                        code = ResponseCodes.OBEX_HTTP_UNAUTHORIZED;
+                        listener.onAuthenticationFailure(OBEXHelper.getTagValue((byte)0x01,
+                                request.authResp));
+                    }
+                    request.authResp = null;
+                }
+            }
+
+            if (code != ResponseCodes.OBEX_HTTP_UNAUTHORIZED) {
+                // the Auth chan is initiated by the client
+                // the server will send back the authResp to the client
+                if (request.authChall != null) {
+                    handleAuthChall(request);
+                    reply.authResp = new byte[request.authResp.length];
+                    System.arraycopy(request.authResp, 0, reply.authResp, 0, reply.authResp.length);
+                    request.authChall = null;
+                    request.authResp = null;
+                }
+                boolean backup = false;
+                boolean create = true;
+                if (!((flags & 1) == 0)) {
+                    backup = true;
+                }
+                if ((flags & 2) == 0) {
+                    create = false;
+                }
+
+                try {
+                    code = listener.onSetPath(request, reply, backup, create);
+                } catch (Exception e) {
+                    sendResponse(ResponseCodes.OBEX_HTTP_INTERNAL_ERROR, null);
+                    return;
+                }
+
+                code = validateResponseCode(code);
+
+                if (reply.nonce != null) {
+                    challengeDigest = new byte[16];
+                    System.arraycopy(reply.nonce, 0, challengeDigest, 0, 16);
+                } else {
+                    challengeDigest = null;
+                }
+
+                long id = listener.getConnectionID();
+                if (id == -1) {
+                    reply.connectionID = null;
+                } else {
+                    reply.connectionID = OBEXHelper.convertToByteArray(id);
+                }
+
+                head = OBEXHelper.createHeader(reply, false);
+                totalLength += head.length;
+
+                if (totalLength > maxPacketLength) {
+                    totalLength = 3;
+                    head = null;
+                    code = ResponseCodes.OBEX_HTTP_INTERNAL_ERROR;
+                }
+            }
+        }
+
+        // Compute Length of OBEX SETPATH packet
+        byte[] replyData = new byte[totalLength];
+        replyData[0] = (byte)code;
+        replyData[1] = (byte)(totalLength >> 8);
+        replyData[2] = (byte)totalLength;
+        if (head != null) {
+            System.arraycopy(head, 0, replyData, 3, head.length);
+        }
+        /*
+         * Write the OBEX SETPATH packet to the server. Byte 0: response code
+         * Byte 1&2: Connect Packet Length Byte 3 to n: headers
+         */
+        output.write(replyData);
+        output.flush();
+    }
+
+    /**
+     * Handles a disconnect request from a client. This method will read the
+     * rest of the request from the client. Assuming the request is valid, it
+     * will create a <code>HeaderSet</code> object to pass to the
+     * <code>ServerRequestHandler</code> object. After the handler processes the
+     * request, this method will create a reply message to send to the server.
+     *
+     * @exception IOException
+     *                if an error occurred at the transport layer
+     */
+    private void handleDisconnectRequest() throws IOException {
+        int length;
+        int code = ResponseCodes.OBEX_HTTP_OK;
+        int totalLength = 3;
+        byte[] head = null;
+        int bytesReceived;
+        HeaderSet request = new HeaderSet();
+        HeaderSet reply = new HeaderSet();
+
+        length = input.read();
+        length = (length << 8) + input.read();
+
+        if (length > OBEXConstants.MAX_PACKET_SIZE_INT) {
+            code = ResponseCodes.OBEX_HTTP_REQ_TOO_LARGE;
+            totalLength = 3;
+        } else {
+            if (length > 3) {
+                byte[] headers = new byte[length - 3];
+                bytesReceived = input.read(headers);
+
+                while (bytesReceived != headers.length) {
+                    bytesReceived += input.read(headers, bytesReceived, headers.length
+                            - bytesReceived);
+                }
+
+                OBEXHelper.updateHeaderSet(request, headers);
+            }
+
+            if (request.connectionID != null) {
+                listener.setConnectionID(OBEXHelper.convertToLong(request.connectionID));
+            } else {
+                listener.setConnectionID(1);
+            }
+
+            if (request.authResp != null) {
+                if (!handleAuthResp(request.authResp)) {
+                    code = ResponseCodes.OBEX_HTTP_UNAUTHORIZED;
+                    listener.onAuthenticationFailure(OBEXHelper.getTagValue((byte)0x01,
+                            request.authResp));
+                }
+                request.authResp = null;
+            }
+
+            if (code != ResponseCodes.OBEX_HTTP_UNAUTHORIZED) {
+
+                if (request.authChall != null) {
+                    handleAuthChall(request);
+                    request.authChall = null;
+                }
+
+                try {
+                    listener.onDisconnect(request, reply);
+                } catch (Exception e) {
+                    sendResponse(ResponseCodes.OBEX_HTTP_INTERNAL_ERROR, null);
+                    return;
+                }
+
+                /*
+                 * Since a client will never response to an authentication
+                 * challenge on a DISCONNECT, there is no reason to keep track
+                 * of the challenge.
+                 *
+                 * if (reply.nonce != null) { challengeDigest = new byte[16];
+                 * System.arraycopy(reply.nonce, 0, challengeDigest, 0, 16); }
+                 * else { challengeDigest = null; }
+                 */
+
+                long id = listener.getConnectionID();
+                if (id == -1) {
+                    reply.connectionID = null;
+                } else {
+                    reply.connectionID = OBEXHelper.convertToByteArray(id);
+                }
+
+                head = OBEXHelper.createHeader(reply, false);
+                totalLength += head.length;
+
+                if (totalLength > maxPacketLength) {
+                    totalLength = 3;
+                    head = null;
+                    code = ResponseCodes.OBEX_HTTP_INTERNAL_ERROR;
+                }
+            }
+        }
+
+        // Compute Length of OBEX CONNECT packet
+        byte[] replyData;
+        if (head != null) {
+            replyData = new byte[3 + head.length];
+        } else {
+            replyData = new byte[3];
+        }
+        replyData[0] = (byte)code;
+        replyData[1] = (byte)(totalLength >> 8);
+        replyData[2] = (byte)totalLength;
+        if (head != null) {
+            System.arraycopy(head, 0, replyData, 3, head.length);
+        }
+        /*
+         * Write the OBEX DISCONNECT packet to the server. Byte 0: response code
+         * Byte 1&2: Connect Packet Length Byte 3 to n: headers
+         */
+        output.write(replyData);
+        output.flush();
+    }
+
+    /**
+     * Handles a connect request from a client. This method will read the rest
+     * of the request from the client. Assuming the request is valid, it will
+     * create a <code>HeaderSet</code> object to pass to the
+     * <code>ServerRequestHandler</code> object. After the handler processes the
+     * request, this method will create a reply message to send to the server
+     * with the response code provided.
+     *
+     * @exception IOException
+     *                if an error occurred at the transport layer
+     */
+    private void handleConnectRequest() throws IOException {
+        int packetLength;
+        int version;
+        int flags;
+        int totalLength = 7;
+        byte[] head = null;
+        int code = -1;
+        HeaderSet request = new HeaderSet();
+        HeaderSet reply = new HeaderSet();
+        int bytesReceived;
+
+        /*
+         * Read in the length of the OBEX packet, OBEX version, flags, and max
+         * packet length
+         */
+        packetLength = input.read();
+        packetLength = (packetLength << 8) + input.read();
+        version = input.read();
+        flags = input.read();
+        maxPacketLength = input.read();
+        maxPacketLength = (maxPacketLength << 8) + input.read();
+
+        // should we check it?
+        if (maxPacketLength > OBEXConstants.MAX_PACKET_SIZE_INT) {
+            maxPacketLength = OBEXConstants.MAX_PACKET_SIZE_INT;
+        }
+
+        if (packetLength > OBEXConstants.MAX_PACKET_SIZE_INT) {
+            code = ResponseCodes.OBEX_HTTP_REQ_TOO_LARGE;
+            totalLength = 7;
+        } else {
+            if (packetLength > 7) {
+                byte[] headers = new byte[packetLength - 7];
+                bytesReceived = input.read(headers);
+
+                while (bytesReceived != headers.length) {
+                    bytesReceived += input.read(headers, bytesReceived, headers.length
+                            - bytesReceived);
+                }
+
+                OBEXHelper.updateHeaderSet(request, headers);
+            }
+
+            if (request.connectionID != null) {
+                listener.setConnectionID(OBEXHelper.convertToLong(request.connectionID));
+            } else {
+                listener.setConnectionID(1);
+            }
+
+            if (request.authResp != null) {
+                if (!handleAuthResp(request.authResp)) {
+                    code = ResponseCodes.OBEX_HTTP_UNAUTHORIZED;
+                    listener.onAuthenticationFailure(OBEXHelper.getTagValue((byte)0x01,
+                            request.authResp));
+                }
+                request.authResp = null;
+            }
+
+            if (code != ResponseCodes.OBEX_HTTP_UNAUTHORIZED) {
+                if (request.authChall != null) {
+                    handleAuthChall(request);
+                    reply.authResp = new byte[request.authResp.length];
+                    System.arraycopy(request.authResp, 0, reply.authResp, 0, reply.authResp.length);
+                    request.authChall = null;
+                    request.authResp = null;
+                }
+
+                try {
+                    code = listener.onConnect(request, reply);
+                    code = validateResponseCode(code);
+
+                    if (reply.nonce != null) {
+                        challengeDigest = new byte[16];
+                        System.arraycopy(reply.nonce, 0, challengeDigest, 0, 16);
+                    } else {
+                        challengeDigest = null;
+                    }
+                    long id = listener.getConnectionID();
+                    if (id == -1) {
+                        reply.connectionID = null;
+                    } else {
+                        reply.connectionID = OBEXHelper.convertToByteArray(id);
+                    }
+
+                    head = OBEXHelper.createHeader(reply, false);
+                    totalLength += head.length;
+
+                    if (totalLength > maxPacketLength) {
+                        totalLength = 7;
+                        head = null;
+                        code = ResponseCodes.OBEX_HTTP_INTERNAL_ERROR;
+                    }
+                } catch (Exception e) {
+                    e.printStackTrace();
+                    totalLength = 7;
+                    head = null;
+                    code = ResponseCodes.OBEX_HTTP_INTERNAL_ERROR;
+                }
+
+            }
+        }
+
+        // Compute Length of OBEX CONNECT packet
+        byte[] length = OBEXHelper.convertToByteArray(totalLength);
+
+        /*
+         * Write the OBEX CONNECT packet to the server. Byte 0: response code
+         * Byte 1&2: Connect Packet Length Byte 3: OBEX Version Number
+         * (Presently, 0x10) Byte 4: Flags (For TCP 0x00) Byte 5&6: Max OBEX
+         * Packet Length (Defined in MAX_PACKET_SIZE) Byte 7 to n: headers
+         */
+        byte[] sendData = new byte[totalLength];
+        sendData[0] = (byte)code;
+        sendData[1] = length[2];
+        sendData[2] = length[3];
+        sendData[3] = (byte)0x10;
+        sendData[4] = (byte)0x00;
+        sendData[5] = (byte)(OBEXConstants.MAX_PACKET_SIZE_INT >> 8);
+        sendData[6] = (byte)(OBEXConstants.MAX_PACKET_SIZE_INT & 0xFF);
+
+        if (head != null) {
+            System.arraycopy(head, 0, sendData, 7, head.length);
+        }
+
+        output.write(sendData);
+        output.flush();
+    }
+
+    /**
+     * Closes the server session - in detail close I/O streams and the
+     * underlying transport layer. Internal flag is also set so that later
+     * attempt to read/write will throw an exception.
+     */
+    public synchronized void close() {
+        if (listener != null) {
+            listener.onClose();
+        }
+        try {
+            input.close();
+            output.close();
+            client.close();
+            isClosed = true;
+        } catch (Exception e) {
+        }
+        client = null;
+        input = null;
+        output = null;
+        listener = null;
+    }
+
+    /**
+     * Verifies that the response code is valid. If it is not valid, it will
+     * return the <code>OBEX_HTTP_INTERNAL_ERROR</code> response code.
+     *
+     * @param code
+     *            the response code to check
+     *
+     * @return the valid response code or <code>OBEX_HTTP_INTERNAL_ERROR</code>
+     *         if <code>code</code> is not valid
+     */
+    private int validateResponseCode(int code) {
+
+        if ((code >= ResponseCodes.OBEX_HTTP_OK) && (code <= ResponseCodes.OBEX_HTTP_PARTIAL)) {
+            return code;
+        }
+        if ((code >= ResponseCodes.OBEX_HTTP_MULT_CHOICE)
+                && (code <= ResponseCodes.OBEX_HTTP_USE_PROXY)) {
+            return code;
+        }
+        if ((code >= ResponseCodes.OBEX_HTTP_BAD_REQUEST)
+                && (code <= ResponseCodes.OBEX_HTTP_UNSUPPORTED_TYPE)) {
+            return code;
+        }
+        if ((code >= ResponseCodes.OBEX_HTTP_INTERNAL_ERROR)
+                && (code <= ResponseCodes.OBEX_HTTP_VERSION)) {
+            return code;
+        }
+        if ((code >= ResponseCodes.OBEX_DATABASE_FULL)
+                && (code <= ResponseCodes.OBEX_DATABASE_LOCKED)) {
+            return code;
+        }
+        return ResponseCodes.OBEX_HTTP_INTERNAL_ERROR;
+    }
+
+    /**
+     * Called when the server received an authentication challenge header. This
+     * will cause the authenticator to handle the authentication challenge.
+     *
+     * @param header
+     *            the header with the authentication challenge
+     *
+     * @return <code>true</code> if the last request should be resent;
+     *         <code>false</code> if the last request should not be resent
+     */
+    protected boolean handleAuthChall(HeaderSet header) {
+        if (authenticator == null) {
+            return false;
+        }
+
+        /*
+         * An authentication challenge is made up of one required and two
+         * optional tag length value triplets. The tag 0x00 is required to be in
+         * the authentication challenge and it represents the challenge digest
+         * that was received. The tag 0x01 is the options tag. This tag tracks
+         * if user ID is required and if full access will be granted. The tag
+         * 0x02 is the realm, which provides a description of which user name
+         * and password to use.
+         */
+        byte[] challenge = OBEXHelper.getTagValue((byte)0x00, header.authChall);
+        byte[] option = OBEXHelper.getTagValue((byte)0x01, header.authChall);
+        byte[] description = OBEXHelper.getTagValue((byte)0x02, header.authChall);
+
+        String realm = "";
+        if (description != null) {
+            byte[] realmString = new byte[description.length - 1];
+            System.arraycopy(description, 1, realmString, 0, realmString.length);
+
+            switch (description[0] & 0xFF) {
+
+                case 0x00:
+                    // ASCII encoding
+                    // Fall through
+                case 0x01:
+                    // ISO-8859-1 encoding
+                    try {
+                        realm = new String(realmString, "ISO8859_1");
+                    } catch (Exception e) {
+                        throw new RuntimeException("Unsupported Encoding Scheme");
+                    }
+                    break;
+
+                case 0xFF:
+                    // UNICODE Encoding
+                    realm = OBEXHelper.convertToUnicode(realmString, false);
+                    break;
+
+                case 0x02:
+                    // ISO-8859-2 encoding
+                    // Fall through
+                case 0x03:
+                    // ISO-8859-3 encoding
+                    // Fall through
+                case 0x04:
+                    // ISO-8859-4 encoding
+                    // Fall through
+                case 0x05:
+                    // ISO-8859-5 encoding
+                    // Fall through
+                case 0x06:
+                    // ISO-8859-6 encoding
+                    // Fall through
+                case 0x07:
+                    // ISO-8859-7 encoding
+                    // Fall through
+                case 0x08:
+                    // ISO-8859-8 encoding
+                    // Fall through
+                case 0x09:
+                    // ISO-8859-9 encoding
+                    // Fall through
+                default:
+                    throw new RuntimeException("Unsupported Encoding Scheme");
+            }
+        }
+
+        boolean isUserIDRequired = false;
+        boolean isFullAccess = true;
+        if (option != null) {
+            if ((option[0] & 0x01) != 0) {
+                isUserIDRequired = true;
+            }
+
+            if ((option[0] & 0x02) != 0) {
+                isFullAccess = false;
+            }
+        }
+
+        PasswordAuthentication result = null;
+        header.authChall = null;
+
+        try {
+            result = authenticator.onAuthenticationChallenge(realm, isUserIDRequired, isFullAccess);
+        } catch (Exception e) {
+            return false;
+        }
+
+        /*
+         * If no password is provided then we not resent the request
+         */
+        if (result == null) {
+            return false;
+        }
+
+        byte[] password = result.getPassword();
+        if (password == null) {
+            return false;
+        }
+
+        byte[] userName = result.getUserName();
+
+        /*
+         * Create the authentication response header. It includes 1 required and
+         * 2 option tag length value triples. The required triple has a tag of
+         * 0x00 and is the response digest. The first optional tag is 0x01 and
+         * represents the user ID. If no user ID is provided, then no user ID
+         * will be sent. The second optional tag is 0x02 and is the challenge
+         * that was received. This will always be sent
+         */
+        if (userName != null) {
+            header.authResp = new byte[38 + userName.length];
+            header.authResp[36] = (byte)0x01;
+            header.authResp[37] = (byte)userName.length;
+            System.arraycopy(userName, 0, header.authResp, 38, userName.length);
+        } else {
+            header.authResp = new byte[36];
+        }
+
+        // Create the secret String
+        byte[] digest = new byte[challenge.length + password.length + 1];
+        System.arraycopy(challenge, 0, digest, 0, challenge.length);
+        // Insert colon between challenge and password
+        digest[challenge.length] = (byte)0x3A;
+        System.arraycopy(password, 0, digest, challenge.length + 1, password.length);
+
+        // Add the Response Digest
+        header.authResp[0] = (byte)0x00;
+        header.authResp[1] = (byte)0x10;
+
+        System.arraycopy(OBEXHelper.computeMD5Hash(digest), 0, header.authResp, 2, 16);
+
+        // Add the challenge
+        header.authResp[18] = (byte)0x02;
+        header.authResp[19] = (byte)0x10;
+        System.arraycopy(challenge, 0, header.authResp, 20, 16);
+
+        return true;
+    }
+
+    /**
+     * Called when the server received an authentication response header. This
+     * will cause the authenticator to handle the authentication response.
+     *
+     * @param authResp
+     *            the authentication response
+     *
+     * @return <code>true</code> if the response passed; <code>false</code> if
+     *         the response failed
+     */
+    protected boolean handleAuthResp(byte[] authResp) {
+        if (authenticator == null) {
+            return false;
+        }
+        // get the correct password from the application
+        byte[] correctPassword = authenticator.onAuthenticationResponse(OBEXHelper.getTagValue(
+                (byte)0x01, authResp));
+        if (correctPassword == null) {
+            return false;
+        }
+
+        byte[] temp = new byte[correctPassword.length + 16];
+
+        System.arraycopy(challengeDigest, 0, temp, 0, 16);
+        System.arraycopy(correctPassword, 0, temp, 16, correctPassword.length);
+
+        byte[] correctResponse = OBEXHelper.computeMD5Hash(temp);
+        byte[] actualResponse = OBEXHelper.getTagValue((byte)0x00, authResp);
+
+        // compare the MD5 hash array .
+        for (int i = 0; i < 16; i++) {
+            if (correctResponse[i] != actualResponse[i]) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}
diff --git a/obex/javax/obex/SessionNotifier.java b/obex/javax/obex/SessionNotifier.java
new file mode 100644
index 0000000..0c9bfd5
--- /dev/null
+++ b/obex/javax/obex/SessionNotifier.java
@@ -0,0 +1,168 @@
+/*
+ * Copyright (c) 2008-2009, Motorola, Inc.
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the Motorola, Inc. nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package javax.obex;
+
+import java.io.IOException;
+
+/**
+ * The <code>SessionNotifier</code> interface defines a connection notifier for
+ * server-side OBEX connections.  When a <code>SessionNotifier</code> is
+ * created and calls  <code>acceptAndOpen()</code>, it will begin listening for
+ * clients to create a connection at the transport layer.  When the transport
+ * layer connection is received, the <code>acceptAndOpen()</code> method will
+ * return a  <code>javax.microedition.io.Connection</code> that is the
+ * connection to the client.  The <code>acceptAndOpen()</code> method also takes a
+ * <code>ServerRequestHandler</code> argument that will process the requests
+ * from the client that connects to the server.
+ *
+ * @version 0.3 November 28, 2008
+ */
+public interface SessionNotifier {
+
+    /**
+     * Waits for a transport layer connection to be established and specifies
+     * the handler to handle the requests from the client.  No authenticator
+     * is associated with this connection, therefore, it is implementation
+     * dependent as to how an authentication challenge and authentication
+     * response header will be received and processed.
+     * <P>
+     * <H4>Additional Note for OBEX over Bluetooth</H4>
+     * If this method is called on a <code>SessionNotifier</code> object that
+     * does not have a <code>ServiceRecord</code> in the SDDB, the
+     * <code>ServiceRecord</code> for this object will be added to the SDDB.
+     * This method requests the BCC to put the
+     * local device in connectable mode so that it will respond to
+     * connection attempts by clients.
+     * <P>
+     * The following checks are done to verify that the service record
+     * provided is valid. If any of these checks fail, then a
+     * <code>ServiceRegistrationException</code> is thrown.
+     * <UL>
+     * <LI>ServiceClassIDList and ProtocolDescriptorList, the mandatory
+     * service attributes for a <code>btgoep</code> service record, must be
+     * present in the <code>ServiceRecord</code> associated with this notifier.
+     * <LI>L2CAP, RFCOMM and OBEX must all be in the ProtocolDescriptorList
+     * <LI>The <code>ServiceRecord</code> associated with this notifier must
+     *  not have changed the RFCOMM server channel number
+     * </UL>
+     * <P>
+     * This method will not ensure that <code>ServiceRecord</code> associated
+     * with this notifier is a completely
+     * valid service record. It is the responsibility of the application to
+     * ensure that the service record follows all of the applicable
+     * syntactic and semantic rules for service record correctness.
+     *
+     * @param handler the request handler that will respond to OBEX requests
+     *
+     * @return the connection to the client
+     *
+     * @exception IOException if an error occurs in the transport layer
+     *
+     * @exception NullPointerException if <code>handler</code> is
+     * <code>null</code>
+     *
+     * @exception ServiceRegistrationException if the structure of the
+     * associated service record is invalid or if the service record
+     * could not be added successfully to the local SDDB.  The
+     * structure of service record is invalid if the service
+     * record is missing any mandatory service attributes, or has
+     * changed any of the values described above which are fixed and
+     * cannot be changed. Failures to add the record to the SDDB could
+     * be due to insufficient disk space, database locks, etc.
+     *
+     * @exception BluetoothStateException if the server device could
+     * not be placed in connectable mode because the device user has
+     * configured the device to be non-connectable
+     */
+    public ObexSession acceptAndOpen(ServerRequestHandler handler) throws IOException;
+
+    /**
+     * Waits for a transport layer connection to be established and specifies
+     * the handler to handle the requests from the client and the
+     * <code>Authenticator</code> to use to respond to authentication challenge
+     * and authentication response headers.
+     * <P>
+     * <H4>Additional Note for OBEX over Bluetooth</H4>
+     * If this method is called on a <code>SessionNotifier</code> object that
+     * does not have a <code>ServiceRecord</code> in the SDDB, the
+     * <code>ServiceRecord</code> for this object will be added to the SDDB.
+     * This method requests the BCC to put the
+     * local device in connectable mode so that it will respond to
+     * connection attempts by clients.
+     * <P>
+     * The following checks are done to verify that the service record
+     * provided is valid. If any of these checks fail, then a
+     * <code>ServiceRegistrationException</code> is thrown.
+     * <UL>
+     * <LI>ServiceClassIDList and ProtocolDescriptorList, the mandatory
+     * service attributes for a <code>btgoep</code> service record, must be
+     * present in the <code>ServiceRecord</code> associated with this notifier.
+     * <LI>L2CAP, RFCOMM and OBEX must all be in the ProtocolDescriptorList
+     * <LI>The <code>ServiceRecord</code> associated with this notifier must
+     *  not have changed the RFCOMM server channel number
+     * </UL>
+     * <P>
+     * This method will not ensure that <code>ServiceRecord</code> associated
+     * with this notifier is a completely
+     * valid service record. It is the responsibility of the application to
+     * ensure that the service record follows all of the applicable
+     * syntactic and semantic rules for service record correctness.
+     *
+     * @param handler the request handler that will respond to OBEX requests
+     *
+     * @param auth the <code>Authenticator</code> to use with this connection;
+     * if <code>null</code> then no <code>Authenticator</code> will be used
+     *
+     * @return the connection to the client
+     *
+     * @exception IOException if an error occurs in the transport layer
+     *
+     * @exception NullPointerException if <code>handler</code> is
+     * <code>null</code>
+     *
+     * @exception ServiceRegistrationException if the structure of the
+     * associated service record is invalid or if the service record
+     * could not be added successfully to the local SDDB.  The
+     * structure of service record is invalid if the service
+     * record is missing any mandatory service attributes, or has
+     * changed any of the values described above which are fixed and
+     * cannot be changed. Failures to add the record to the SDDB could
+     * be due to insufficient disk space, database locks, etc.
+     *
+     * @exception BluetoothStateException if the server device could
+     * not be placed in connectable mode because the device user has
+     * configured the device to be non-connectable
+     */
+    public ObexSession acceptAndOpen(ServerRequestHandler handler, Authenticator auth)
+            throws IOException;
+}