public int getHeaderLength() {
long id = mListener.getConnectionId();
if (id == -1) {
replyHeader.mConnectionID = null;
} else {
replyHeader.mConnectionID = ObexHelper.convertToByteArray(id);
}
byte[] headerArray = ObexHelper.createHeader(replyHeader, false);
return headerArray.length;
}
/**
* 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
* @throws IOException if an IO error occurs
*/
public synchronized boolean sendReply(int type) throws IOException {
ByteArrayOutputStream out = new ByteArrayOutputStream();
int bytesReceived;
long id = mListener.getConnectionId();
if (id == -1) {
replyHeader.mConnectionID = null;
} else {
replyHeader.mConnectionID = ObexHelper.convertToByteArray(id);
}
byte[] headerArray = ObexHelper.createHeader(replyHeader, true);
int bodyLength = -1;
int orginalBodyLength = -1;
if (mPrivateOutput != null) {
bodyLength = mPrivateOutput.size();
orginalBodyLength = bodyLength;
}
if ((ObexHelper.BASE_PACKET_LENGTH + headerArray.length) > mMaxPacketLength) {
int end = 0;
int start = 0;
while (end != headerArray.length) {
end =
ObexHelper.findHeaderEnd(
headerArray, start, mMaxPacketLength - ObexHelper.BASE_PACKET_LENGTH);
if (end == -1) {
mClosed = true;
if (mPrivateInput != null) {
mPrivateInput.close();
}
if (mPrivateOutput != null) {
mPrivateOutput.close();
}
mParent.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);
mParent.sendResponse(type, sendHeader);
start = end;
}
if (bodyLength > 0) {
return true;
} else {
return false;
}
} else {
out.write(headerArray);
}
// For Get operation: if response code is OBEX_HTTP_OK, then this is the
// last packet; so set finalBitSet to true.
if (mGetOperation && type == ResponseCodes.OBEX_HTTP_OK) {
finalBitSet = true;
}
if ((finalBitSet) || (headerArray.length < (mMaxPacketLength - 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 > (mMaxPacketLength - headerArray.length - 6)) {
bodyLength = mMaxPacketLength - headerArray.length - 6;
}
byte[] body = mPrivateOutput.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) || (mPrivateOutput.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);
}
mResponseSize = 3;
mParent.sendResponse(type, out.toByteArray());
if (type == ResponseCodes.OBEX_HTTP_CONTINUE) {
int headerID = mInput.read();
int length = mInput.read();
length = (length << 8) + mInput.read();
if ((headerID != ObexHelper.OBEX_OPCODE_PUT)
&& (headerID != ObexHelper.OBEX_OPCODE_PUT_FINAL)
&& (headerID != ObexHelper.OBEX_OPCODE_GET)
&& (headerID != ObexHelper.OBEX_OPCODE_GET_FINAL)) {
if (length > 3) {
byte[] temp = new byte[length - 3];
// First three bytes already read, compensating for this
bytesReceived = mInput.read(temp);
while (bytesReceived != temp.length) {
bytesReceived += mInput.read(temp, bytesReceived, temp.length - bytesReceived);
}
}
/*
* Determine if an ABORT was sent as the reply
*/
if (headerID == ObexHelper.OBEX_OPCODE_ABORT) {
mParent.sendResponse(ResponseCodes.OBEX_HTTP_OK, null);
mClosed = true;
isAborted = true;
mExceptionString = "Abort Received";
throw new IOException("Abort Received");
} else {
mParent.sendResponse(ResponseCodes.OBEX_HTTP_BAD_REQUEST, null);
mClosed = true;
mExceptionString = "Bad Request Received";
throw new IOException("Bad Request Received");
}
} else {
if ((headerID == ObexHelper.OBEX_OPCODE_PUT_FINAL)) {
finalBitSet = true;
} else if (headerID == ObexHelper.OBEX_OPCODE_GET_FINAL) {
mRequestFinished = true;
}
/*
* Determine if the packet length is larger then this device can receive
*/
if (length > ObexHelper.MAX_PACKET_SIZE_INT) {
mParent.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 = mInput.read(data);
while (bytesReceived != data.length) {
bytesReceived += mInput.read(data, bytesReceived, data.length - bytesReceived);
}
byte[] body = ObexHelper.updateHeaderSet(requestHeader, data);
if (body != null) {
mHasBody = true;
}
if (mListener.getConnectionId() != -1 && requestHeader.mConnectionID != null) {
mListener.setConnectionId(ObexHelper.convertToLong(requestHeader.mConnectionID));
} else {
mListener.setConnectionId(1);
}
if (requestHeader.mAuthResp != null) {
if (!mParent.handleAuthResp(requestHeader.mAuthResp)) {
mExceptionString = "Authentication Failed";
mParent.sendResponse(ResponseCodes.OBEX_HTTP_UNAUTHORIZED, null);
mClosed = true;
requestHeader.mAuthResp = null;
return false;
}
requestHeader.mAuthResp = null;
}
if (requestHeader.mAuthChall != null) {
mParent.handleAuthChall(requestHeader);
// send the auhtResp to the client
replyHeader.mAuthResp = new byte[requestHeader.mAuthResp.length];
System.arraycopy(
requestHeader.mAuthResp, 0, replyHeader.mAuthResp, 0, replyHeader.mAuthResp.length);
requestHeader.mAuthResp = null;
requestHeader.mAuthChall = null;
}
if (body != null) {
mPrivateInput.writeBytes(body, 1);
}
}
}
return true;
} else {
return false;
}
}
/**
* 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.
*
* @throws 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;
HeaderSet request = new HeaderSet();
HeaderSet reply = new HeaderSet();
length = mInput.read();
length = (length << 8) + mInput.read();
if (length > ObexHelper.MAX_PACKET_SIZE_INT) {
code = ResponseCodes.OBEX_HTTP_REQ_TOO_LARGE;
totalLength = 3;
} else {
if (length > 3) {
mData.reset();
mData.write(mInput, length - 3);
ObexHelper.updateHeaderSet(request, mData, null, mHeaderBuffer);
}
if (mListener.getConnectionId() != -1 && request.mConnectionID != null) {
mListener.setConnectionId(ObexHelper.convertToLong(request.mConnectionID));
} else {
mListener.setConnectionId(1);
}
if (request.mAuthResp != null) {
if (!handleAuthResp(request.mAuthResp)) {
code = ResponseCodes.OBEX_HTTP_UNAUTHORIZED;
mListener.onAuthenticationFailure(ObexHelper.getTagValue((byte) 0x01, request.mAuthResp));
}
request.mAuthResp = null;
}
if (code != ResponseCodes.OBEX_HTTP_UNAUTHORIZED) {
if (request.mAuthChall != null) {
handleAuthChall(request);
request.mAuthChall = null;
}
try {
mListener.onDisconnect(request, reply);
} catch (Exception e) {
sendResponse(ResponseCodes.OBEX_HTTP_INTERNAL_ERROR, null);
return;
}
long id = mListener.getConnectionId();
if (id == -1) {
reply.mConnectionID = null;
} else {
reply.mConnectionID = ObexHelper.convertToByteArray(id);
}
head = ObexHelper.createHeader(reply, false);
totalLength += head.length;
if (totalLength > mMaxPacketLength) {
totalLength = 3;
head = null;
code = ResponseCodes.OBEX_HTTP_INTERNAL_ERROR;
}
}
}
// Compute Length of OBEX CONNECT packet
mData.reset();
mData.write((byte) code);
mData.write((byte) (totalLength >> 8));
mData.write((byte) totalLength);
if (head != null) {
mData.write(head);
}
/*
* Write the OBEX DISCONNECT packet to the server. Byte 0: response code
* Byte 1&2: Connect Packet Length Byte 3 to n: headers
*/
mData.read(mOutput);
mOutput.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.
*
* @throws IOException if an error occurred at the transport layer
*/
private void handleConnectRequest() throws IOException {
int packetLength;
@SuppressWarnings("unused")
int version;
@SuppressWarnings("unused")
int flags;
int totalLength = 7;
byte[] head = null;
int code = -1;
HeaderSet request = new HeaderSet();
HeaderSet reply = new HeaderSet();
/*
* Read in the length of the OBEX packet, OBEX version, flags, and max
* packet length
*/
packetLength = mInput.read();
packetLength = (packetLength << 8) + mInput.read();
version = mInput.read();
flags = mInput.read();
mMaxPacketLength = mInput.read();
mMaxPacketLength = (mMaxPacketLength << 8) + mInput.read();
// should we check it?
if (mMaxPacketLength > ObexHelper.MAX_PACKET_SIZE_INT) {
mMaxPacketLength = ObexHelper.MAX_PACKET_SIZE_INT;
}
if (packetLength > ObexHelper.MAX_PACKET_SIZE_INT) {
code = ResponseCodes.OBEX_HTTP_REQ_TOO_LARGE;
totalLength = 7;
} else {
if (packetLength > 7) {
mData.reset();
mData.write(mInput, packetLength - 7);
ObexHelper.updateHeaderSet(request, mData, null, mHeaderBuffer);
}
if (mListener.getConnectionId() != -1 && request.mConnectionID != null) {
mListener.setConnectionId(ObexHelper.convertToLong(request.mConnectionID));
} else {
mListener.setConnectionId(1);
}
if (request.mAuthResp != null) {
if (!handleAuthResp(request.mAuthResp)) {
code = ResponseCodes.OBEX_HTTP_UNAUTHORIZED;
mListener.onAuthenticationFailure(ObexHelper.getTagValue((byte) 0x01, request.mAuthResp));
}
request.mAuthResp = null;
}
if (code != ResponseCodes.OBEX_HTTP_UNAUTHORIZED) {
if (request.mAuthChall != null) {
handleAuthChall(request);
reply.mAuthResp = new byte[request.mAuthResp.length];
System.arraycopy(request.mAuthResp, 0, reply.mAuthResp, 0, reply.mAuthResp.length);
request.mAuthChall = null;
request.mAuthResp = null;
}
try {
code = mListener.onConnect(request, reply);
code = validateResponseCode(code);
if (reply.nonce != null) {
mChallengeDigest = new byte[16];
System.arraycopy(reply.nonce, 0, mChallengeDigest, 0, 16);
} else {
mChallengeDigest = null;
}
long id = mListener.getConnectionId();
if (id == -1) {
reply.mConnectionID = null;
} else {
reply.mConnectionID = ObexHelper.convertToByteArray(id);
}
head = ObexHelper.createHeader(reply, false);
totalLength += head.length;
if (totalLength > mMaxPacketLength) {
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) (ObexHelper.MAX_PACKET_SIZE_INT >> 8);
sendData[6] = (byte) (ObexHelper.MAX_PACKET_SIZE_INT & 0xFF);
if (head != null) {
System.arraycopy(head, 0, sendData, 7, head.length);
}
mOutput.write(sendData);
mOutput.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.
*
* @throws IOException if an error occurred at the transport layer
*/
private void handleSetPathRequest() throws IOException {
int length;
int flags;
@SuppressWarnings("unused")
int constants;
int totalLength = 3;
byte[] head = null;
int code = -1;
HeaderSet request = new HeaderSet();
HeaderSet reply = new HeaderSet();
length = mInput.read();
length = (length << 8) + mInput.read();
flags = mInput.read();
constants = mInput.read();
if (length > ObexHelper.MAX_PACKET_SIZE_INT) {
code = ResponseCodes.OBEX_HTTP_REQ_TOO_LARGE;
totalLength = 3;
} else {
if (length > 5) {
mData.reset();
mData.write(mInput, length - 5);
ObexHelper.updateHeaderSet(request, mData, null, mHeaderBuffer);
if (mListener.getConnectionId() != -1 && request.mConnectionID != null) {
mListener.setConnectionId(ObexHelper.convertToLong(request.mConnectionID));
} else {
mListener.setConnectionId(1);
}
// the Auth chan is initiated by the server, client sent back the authResp .
if (request.mAuthResp != null) {
if (!handleAuthResp(request.mAuthResp)) {
code = ResponseCodes.OBEX_HTTP_UNAUTHORIZED;
mListener.onAuthenticationFailure(
ObexHelper.getTagValue((byte) 0x01, request.mAuthResp));
}
request.mAuthResp = null;
}
}
if (code != ResponseCodes.OBEX_HTTP_UNAUTHORIZED) {
// the Auth challenge is initiated by the client
// the server will send back the authResp to the client
if (request.mAuthChall != null) {
handleAuthChall(request);
reply.mAuthResp = new byte[request.mAuthResp.length];
System.arraycopy(request.mAuthResp, 0, reply.mAuthResp, 0, reply.mAuthResp.length);
request.mAuthChall = null;
request.mAuthResp = null;
}
boolean backup = false;
boolean create = true;
if (!((flags & 1) == 0)) {
backup = true;
}
if (!((flags & 2) == 0)) {
create = false;
}
try {
code = mListener.onSetPath(request, reply, backup, create);
} catch (Exception e) {
sendResponse(ResponseCodes.OBEX_HTTP_INTERNAL_ERROR, null);
return;
}
code = validateResponseCode(code);
if (reply.nonce != null) {
mChallengeDigest = new byte[16];
System.arraycopy(reply.nonce, 0, mChallengeDigest, 0, 16);
} else {
mChallengeDigest = null;
}
long id = mListener.getConnectionId();
if (id == -1) {
reply.mConnectionID = null;
} else {
reply.mConnectionID = ObexHelper.convertToByteArray(id);
}
head = ObexHelper.createHeader(reply, false);
totalLength += head.length;
if (totalLength > mMaxPacketLength) {
totalLength = 3;
head = null;
code = ResponseCodes.OBEX_HTTP_INTERNAL_ERROR;
}
}
}
// Compute Length of OBEX SETPATH packet
mData.reset();
mData.write((byte) code);
mData.write((byte) (totalLength >> 8));
mData.write((byte) totalLength);
if (head != null) {
mData.write(head);
}
/*
* Write the OBEX SETPATH packet to the server. Byte 0: response code
* Byte 1&2: Connect Packet Length Byte 3 to n: headers
*/
mData.read(mOutput);
mOutput.flush();
}
