1 /* 2 * Copyright (c) 2008-2009, Motorola, Inc. 3 * 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions are met: 8 * 9 * - Redistributions of source code must retain the above copyright notice, 10 * this list of conditions and the following disclaimer. 11 * 12 * - Redistributions in binary form must reproduce the above copyright notice, 13 * this list of conditions and the following disclaimer in the documentation 14 * and/or other materials provided with the distribution. 15 * 16 * - Neither the name of the Motorola, Inc. nor the names of its contributors 17 * may be used to endorse or promote products derived from this software 18 * without specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 21 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE 24 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 30 * POSSIBILITY OF SUCH DAMAGE. 31 */ 32 33 package javax.obex; 34 35 import java.io.IOException; 36 import java.io.InputStream; 37 import java.io.DataInputStream; 38 import java.io.OutputStream; 39 import java.io.DataOutputStream; 40 import java.io.ByteArrayOutputStream; 41 42 /** 43 * This class implements the Operation interface for server side connections. 44 * <P> 45 * <STRONG>Request Codes</STRONG> There are four different request codes that 46 * are in this class. 0x02 is a PUT request that signals that the request is not 47 * complete and requires an additional OBEX packet. 0x82 is a PUT request that 48 * says that request is complete. In this case, the server can begin sending the 49 * response. The 0x03 is a GET request that signals that the request is not 50 * finished. When the server receives a 0x83, the client is signaling the server 51 * that it is done with its request. TODO: Extend the ClientOperation and reuse 52 * the methods defined TODO: in that class. 53 * @hide 54 */ 55 public final class ServerOperation implements Operation, BaseStream { 56 57 public boolean isAborted; 58 59 public HeaderSet requestHeader; 60 61 public HeaderSet replyHeader; 62 63 public boolean finalBitSet; 64 65 private InputStream mInput; 66 67 private ServerSession mParent; 68 69 private int mMaxPacketLength; 70 71 private int mResponseSize; 72 73 private boolean mClosed; 74 75 private boolean mGetOperation; 76 77 private PrivateInputStream mPrivateInput; 78 79 private PrivateOutputStream mPrivateOutput; 80 81 private boolean mPrivateOutputOpen; 82 83 private String mExceptionString; 84 85 private ServerRequestHandler mListener; 86 87 private boolean mRequestFinished; 88 89 private boolean mHasBody; 90 91 /** 92 * Creates new ServerOperation 93 * @param p the parent that created this object 94 * @param in the input stream to read from 95 * @param out the output stream to write to 96 * @param request the initial request that was received from the client 97 * @param maxSize the max packet size that the client will accept 98 * @param listen the listener that is responding to the request 99 * @throws IOException if an IO error occurs 100 */ 101 public ServerOperation(ServerSession p, InputStream in, int request, int maxSize, 102 ServerRequestHandler listen) throws IOException { 103 104 isAborted = false; 105 mParent = p; 106 mInput = in; 107 mMaxPacketLength = maxSize; 108 mClosed = false; 109 requestHeader = new HeaderSet(); 110 replyHeader = new HeaderSet(); 111 mPrivateInput = new PrivateInputStream(this); 112 mResponseSize = 3; 113 mListener = listen; 114 mRequestFinished = false; 115 mPrivateOutputOpen = false; 116 mHasBody = false; 117 int bytesReceived; 118 119 /* 120 * Determine if this is a PUT request 121 */ 122 if ((request == 0x02) || (request == 0x82)) { 123 /* 124 * It is a PUT request. 125 */ 126 mGetOperation = false; 127 128 /* 129 * Determine if the final bit is set 130 */ 131 if ((request & 0x80) == 0) { 132 finalBitSet = false; 133 } else { 134 finalBitSet = true; 135 mRequestFinished = true; 136 } 137 } else if ((request == 0x03) || (request == 0x83)) { 138 /* 139 * It is a GET request. 140 */ 141 mGetOperation = true; 142 143 // For Get request, final bit set is decided by server side logic 144 finalBitSet = false; 145 146 if (request == 0x83) { 147 mRequestFinished = true; 148 } 149 } else { 150 throw new IOException("ServerOperation can not handle such request"); 151 } 152 153 int length = in.read(); 154 length = (length << 8) + in.read(); 155 156 /* 157 * Determine if the packet length is larger than this device can receive 158 */ 159 if (length > ObexHelper.MAX_PACKET_SIZE_INT) { 160 mParent.sendResponse(ResponseCodes.OBEX_HTTP_REQ_TOO_LARGE, null); 161 throw new IOException("Packet received was too large"); 162 } 163 164 /* 165 * Determine if any headers were sent in the initial request 166 */ 167 if (length > 3) { 168 byte[] data = new byte[length - 3]; 169 bytesReceived = in.read(data); 170 171 while (bytesReceived != data.length) { 172 bytesReceived += in.read(data, bytesReceived, data.length - bytesReceived); 173 } 174 175 byte[] body = ObexHelper.updateHeaderSet(requestHeader, data); 176 177 if (body != null) { 178 mHasBody = true; 179 } 180 181 if (mListener.getConnectionId() != -1 && requestHeader.mConnectionID != null) { 182 mListener.setConnectionId(ObexHelper.convertToLong(requestHeader.mConnectionID)); 183 } else { 184 mListener.setConnectionId(1); 185 } 186 187 if (requestHeader.mAuthResp != null) { 188 if (!mParent.handleAuthResp(requestHeader.mAuthResp)) { 189 mExceptionString = "Authentication Failed"; 190 mParent.sendResponse(ResponseCodes.OBEX_HTTP_UNAUTHORIZED, null); 191 mClosed = true; 192 requestHeader.mAuthResp = null; 193 return; 194 } 195 } 196 197 if (requestHeader.mAuthChall != null) { 198 mParent.handleAuthChall(requestHeader); 199 // send the authResp to the client 200 replyHeader.mAuthResp = new byte[requestHeader.mAuthResp.length]; 201 System.arraycopy(requestHeader.mAuthResp, 0, replyHeader.mAuthResp, 0, 202 replyHeader.mAuthResp.length); 203 requestHeader.mAuthResp = null; 204 requestHeader.mAuthChall = null; 205 206 } 207 208 if (body != null) { 209 mPrivateInput.writeBytes(body, 1); 210 } else { 211 while ((!mGetOperation) && (!finalBitSet)) { 212 sendReply(ResponseCodes.OBEX_HTTP_CONTINUE); 213 if (mPrivateInput.available() > 0) { 214 break; 215 } 216 } 217 } 218 } 219 220 while ((!mGetOperation) && (!finalBitSet) && (mPrivateInput.available() == 0)) { 221 sendReply(ResponseCodes.OBEX_HTTP_CONTINUE); 222 if (mPrivateInput.available() > 0) { 223 break; 224 } 225 } 226 227 // wait for get request finished !!!! 228 while (mGetOperation && !mRequestFinished) { 229 sendReply(ResponseCodes.OBEX_HTTP_CONTINUE); 230 } 231 } 232 233 public boolean isValidBody() { 234 return mHasBody; 235 } 236 237 /** 238 * Determines if the operation should continue or should wait. If it should 239 * continue, this method will continue the operation. 240 * @param sendEmpty if <code>true</code> then this will continue the 241 * operation even if no headers will be sent; if <code>false</code> 242 * then this method will only continue the operation if there are 243 * headers to send 244 * @param inStream if<code>true</code> the stream is input stream, otherwise 245 * output stream 246 * @return <code>true</code> if the operation was completed; 247 * <code>false</code> if no operation took place 248 */ 249 public synchronized boolean continueOperation(boolean sendEmpty, boolean inStream) 250 throws IOException { 251 if (!mGetOperation) { 252 if (!finalBitSet) { 253 if (sendEmpty) { 254 sendReply(ResponseCodes.OBEX_HTTP_CONTINUE); 255 return true; 256 } else { 257 if ((mResponseSize > 3) || (mPrivateOutput.size() > 0)) { 258 sendReply(ResponseCodes.OBEX_HTTP_CONTINUE); 259 return true; 260 } else { 261 return false; 262 } 263 } 264 } else { 265 return false; 266 } 267 } else { 268 sendReply(ResponseCodes.OBEX_HTTP_CONTINUE); 269 return true; 270 } 271 } 272 273 /** 274 * Sends a reply to the client. If the reply is a OBEX_HTTP_CONTINUE, it 275 * will wait for a response from the client before ending. 276 * @param type the response code to send back to the client 277 * @return <code>true</code> if the final bit was not set on the reply; 278 * <code>false</code> if no reply was received because the operation 279 * ended, an abort was received, or the final bit was set in the 280 * reply 281 * @throws IOException if an IO error occurs 282 */ 283 public synchronized boolean sendReply(int type) throws IOException { 284 ByteArrayOutputStream out = new ByteArrayOutputStream(); 285 int bytesReceived; 286 287 long id = mListener.getConnectionId(); 288 if (id == -1) { 289 replyHeader.mConnectionID = null; 290 } else { 291 replyHeader.mConnectionID = ObexHelper.convertToByteArray(id); 292 } 293 294 byte[] headerArray = ObexHelper.createHeader(replyHeader, true); 295 int bodyLength = -1; 296 int orginalBodyLength = -1; 297 298 if (mPrivateOutput != null) { 299 bodyLength = mPrivateOutput.size(); 300 orginalBodyLength = bodyLength; 301 } 302 303 if ((ObexHelper.BASE_PACKET_LENGTH + headerArray.length) > mMaxPacketLength) { 304 305 int end = 0; 306 int start = 0; 307 308 while (end != headerArray.length) { 309 end = ObexHelper.findHeaderEnd(headerArray, start, mMaxPacketLength 310 - ObexHelper.BASE_PACKET_LENGTH); 311 if (end == -1) { 312 313 mClosed = true; 314 315 if (mPrivateInput != null) { 316 mPrivateInput.close(); 317 } 318 319 if (mPrivateOutput != null) { 320 mPrivateOutput.close(); 321 } 322 mParent.sendResponse(ResponseCodes.OBEX_HTTP_INTERNAL_ERROR, null); 323 throw new IOException("OBEX Packet exceeds max packet size"); 324 } 325 byte[] sendHeader = new byte[end - start]; 326 System.arraycopy(headerArray, start, sendHeader, 0, sendHeader.length); 327 328 mParent.sendResponse(type, sendHeader); 329 start = end; 330 } 331 332 if (bodyLength > 0) { 333 return true; 334 } else { 335 return false; 336 } 337 338 } else { 339 out.write(headerArray); 340 } 341 342 // For Get operation: if response code is OBEX_HTTP_OK, then this is the 343 // last packet; so set finalBitSet to true. 344 if (mGetOperation && type == ResponseCodes.OBEX_HTTP_OK) { 345 finalBitSet = true; 346 } 347 348 if ((finalBitSet) || (headerArray.length < (mMaxPacketLength - 20))) { 349 if (bodyLength > 0) { 350 /* 351 * Determine if I can send the whole body or just part of 352 * the body. Remember that there is the 3 bytes for the 353 * response message and 3 bytes for the header ID and length 354 */ 355 if (bodyLength > (mMaxPacketLength - headerArray.length - 6)) { 356 bodyLength = mMaxPacketLength - headerArray.length - 6; 357 } 358 359 byte[] body = mPrivateOutput.readBytes(bodyLength); 360 361 /* 362 * Since this is a put request if the final bit is set or 363 * the output stream is closed we need to send the 0x49 364 * (End of Body) otherwise, we need to send 0x48 (Body) 365 */ 366 if ((finalBitSet) || (mPrivateOutput.isClosed())) { 367 out.write(0x49); 368 } else { 369 out.write(0x48); 370 } 371 372 bodyLength += 3; 373 out.write((byte)(bodyLength >> 8)); 374 out.write((byte)bodyLength); 375 out.write(body); 376 } 377 } 378 379 if ((finalBitSet) && (type == ResponseCodes.OBEX_HTTP_OK) && (orginalBodyLength <= 0)) { 380 out.write(0x49); 381 orginalBodyLength = 3; 382 out.write((byte)(orginalBodyLength >> 8)); 383 out.write((byte)orginalBodyLength); 384 385 } 386 387 mResponseSize = 3; 388 mParent.sendResponse(type, out.toByteArray()); 389 390 if (type == ResponseCodes.OBEX_HTTP_CONTINUE) { 391 int headerID = mInput.read(); 392 int length = mInput.read(); 393 length = (length << 8) + mInput.read(); 394 if ((headerID != ObexHelper.OBEX_OPCODE_PUT) 395 && (headerID != ObexHelper.OBEX_OPCODE_PUT_FINAL) 396 && (headerID != ObexHelper.OBEX_OPCODE_GET) 397 && (headerID != ObexHelper.OBEX_OPCODE_GET_FINAL)) { 398 399 if (length > 3) { 400 byte[] temp = new byte[length]; 401 bytesReceived = mInput.read(temp); 402 403 while (bytesReceived != length) { 404 bytesReceived += mInput.read(temp, bytesReceived, length - bytesReceived); 405 } 406 } 407 408 /* 409 * Determine if an ABORT was sent as the reply 410 */ 411 if (headerID == ObexHelper.OBEX_OPCODE_ABORT) { 412 mParent.sendResponse(ResponseCodes.OBEX_HTTP_OK, null); 413 mClosed = true; 414 isAborted = true; 415 mExceptionString = "Abort Received"; 416 throw new IOException("Abort Received"); 417 } else { 418 mParent.sendResponse(ResponseCodes.OBEX_HTTP_BAD_REQUEST, null); 419 mClosed = true; 420 mExceptionString = "Bad Request Received"; 421 throw new IOException("Bad Request Received"); 422 } 423 } else { 424 425 if ((headerID == ObexHelper.OBEX_OPCODE_PUT_FINAL)) { 426 finalBitSet = true; 427 } else if (headerID == ObexHelper.OBEX_OPCODE_GET_FINAL) { 428 mRequestFinished = true; 429 } 430 431 /* 432 * Determine if the packet length is larger then this device can receive 433 */ 434 if (length > ObexHelper.MAX_PACKET_SIZE_INT) { 435 mParent.sendResponse(ResponseCodes.OBEX_HTTP_REQ_TOO_LARGE, null); 436 throw new IOException("Packet received was too large"); 437 } 438 439 /* 440 * Determine if any headers were sent in the initial request 441 */ 442 if (length > 3) { 443 byte[] data = new byte[length - 3]; 444 bytesReceived = mInput.read(data); 445 446 while (bytesReceived != data.length) { 447 bytesReceived += mInput.read(data, bytesReceived, data.length 448 - bytesReceived); 449 } 450 byte[] body = ObexHelper.updateHeaderSet(requestHeader, data); 451 if (body != null) { 452 mHasBody = true; 453 } 454 if (mListener.getConnectionId() != -1 && requestHeader.mConnectionID != null) { 455 mListener.setConnectionId(ObexHelper 456 .convertToLong(requestHeader.mConnectionID)); 457 } else { 458 mListener.setConnectionId(1); 459 } 460 461 if (requestHeader.mAuthResp != null) { 462 if (!mParent.handleAuthResp(requestHeader.mAuthResp)) { 463 mExceptionString = "Authentication Failed"; 464 mParent.sendResponse(ResponseCodes.OBEX_HTTP_UNAUTHORIZED, null); 465 mClosed = true; 466 requestHeader.mAuthResp = null; 467 return false; 468 } 469 requestHeader.mAuthResp = null; 470 } 471 472 if (requestHeader.mAuthChall != null) { 473 mParent.handleAuthChall(requestHeader); 474 // send the auhtResp to the client 475 replyHeader.mAuthResp = new byte[requestHeader.mAuthResp.length]; 476 System.arraycopy(requestHeader.mAuthResp, 0, replyHeader.mAuthResp, 0, 477 replyHeader.mAuthResp.length); 478 requestHeader.mAuthResp = null; 479 requestHeader.mAuthChall = null; 480 } 481 482 if (body != null) { 483 mPrivateInput.writeBytes(body, 1); 484 } 485 } 486 } 487 return true; 488 } else { 489 return false; 490 } 491 } 492 493 /** 494 * Sends an ABORT message to the server. By calling this method, the 495 * corresponding input and output streams will be closed along with this 496 * object. 497 * @throws IOException if the transaction has already ended or if an OBEX 498 * server called this method 499 */ 500 public void abort() throws IOException { 501 throw new IOException("Called from a server"); 502 } 503 504 /** 505 * Returns the headers that have been received during the operation. 506 * Modifying the object returned has no effect on the headers that are sent 507 * or retrieved. 508 * @return the headers received during this <code>Operation</code> 509 * @throws IOException if this <code>Operation</code> has been closed 510 */ 511 public HeaderSet getReceivedHeader() throws IOException { 512 ensureOpen(); 513 return requestHeader; 514 } 515 516 /** 517 * Specifies the headers that should be sent in the next OBEX message that 518 * is sent. 519 * @param headers the headers to send in the next message 520 * @throws IOException if this <code>Operation</code> has been closed or the 521 * transaction has ended and no further messages will be exchanged 522 * @throws IllegalArgumentException if <code>headers</code> was not created 523 * by a call to <code>ServerRequestHandler.createHeaderSet()</code> 524 */ 525 public void sendHeaders(HeaderSet headers) throws IOException { 526 ensureOpen(); 527 528 if (headers == null) { 529 throw new IOException("Headers may not be null"); 530 } 531 532 int[] headerList = headers.getHeaderList(); 533 if (headerList != null) { 534 for (int i = 0; i < headerList.length; i++) { 535 replyHeader.setHeader(headerList[i], headers.getHeader(headerList[i])); 536 } 537 538 } 539 } 540 541 /** 542 * Retrieves the response code retrieved from the server. Response codes are 543 * defined in the <code>ResponseCodes</code> interface. 544 * @return the response code retrieved from the server 545 * @throws IOException if an error occurred in the transport layer during 546 * the transaction; if this method is called on a 547 * <code>HeaderSet</code> object created by calling 548 * <code>createHeaderSet</code> in a <code>ClientSession</code> 549 * object; if this is called from a server 550 */ 551 public int getResponseCode() throws IOException { 552 throw new IOException("Called from a server"); 553 } 554 555 /** 556 * Always returns <code>null</code> 557 * @return <code>null</code> 558 */ 559 public String getEncoding() { 560 return null; 561 } 562 563 /** 564 * Returns the type of content that the resource connected to is providing. 565 * E.g. if the connection is via HTTP, then the value of the content-type 566 * header field is returned. 567 * @return the content type of the resource that the URL references, or 568 * <code>null</code> if not known 569 */ 570 public String getType() { 571 try { 572 return (String)requestHeader.getHeader(HeaderSet.TYPE); 573 } catch (IOException e) { 574 return null; 575 } 576 } 577 578 /** 579 * Returns the length of the content which is being provided. E.g. if the 580 * connection is via HTTP, then the value of the content-length header field 581 * is returned. 582 * @return the content length of the resource that this connection's URL 583 * references, or -1 if the content length is not known 584 */ 585 public long getLength() { 586 try { 587 Long temp = (Long)requestHeader.getHeader(HeaderSet.LENGTH); 588 589 if (temp == null) { 590 return -1; 591 } else { 592 return temp.longValue(); 593 } 594 } catch (IOException e) { 595 return -1; 596 } 597 } 598 599 public int getMaxPacketSize() { 600 return mMaxPacketLength - 6 - getHeaderLength(); 601 } 602 603 public int getHeaderLength() { 604 long id = mListener.getConnectionId(); 605 if (id == -1) { 606 replyHeader.mConnectionID = null; 607 } else { 608 replyHeader.mConnectionID = ObexHelper.convertToByteArray(id); 609 } 610 611 byte[] headerArray = ObexHelper.createHeader(replyHeader, false); 612 613 return headerArray.length; 614 } 615 616 /** 617 * Open and return an input stream for a connection. 618 * @return an input stream 619 * @throws IOException if an I/O error occurs 620 */ 621 public InputStream openInputStream() throws IOException { 622 ensureOpen(); 623 return mPrivateInput; 624 } 625 626 /** 627 * Open and return a data input stream for a connection. 628 * @return an input stream 629 * @throws IOException if an I/O error occurs 630 */ 631 public DataInputStream openDataInputStream() throws IOException { 632 return new DataInputStream(openInputStream()); 633 } 634 635 /** 636 * Open and return an output stream for a connection. 637 * @return an output stream 638 * @throws IOException if an I/O error occurs 639 */ 640 public OutputStream openOutputStream() throws IOException { 641 ensureOpen(); 642 643 if (mPrivateOutputOpen) { 644 throw new IOException("no more input streams available, stream already opened"); 645 } 646 647 if (!mRequestFinished) { 648 throw new IOException("no output streams available ,request not finished"); 649 } 650 651 if (mPrivateOutput == null) { 652 mPrivateOutput = new PrivateOutputStream(this, getMaxPacketSize()); 653 } 654 mPrivateOutputOpen = true; 655 return mPrivateOutput; 656 } 657 658 /** 659 * Open and return a data output stream for a connection. 660 * @return an output stream 661 * @throws IOException if an I/O error occurs 662 */ 663 public DataOutputStream openDataOutputStream() throws IOException { 664 return new DataOutputStream(openOutputStream()); 665 } 666 667 /** 668 * Closes the connection and ends the transaction 669 * @throws IOException if the operation has already ended or is closed 670 */ 671 public void close() throws IOException { 672 ensureOpen(); 673 mClosed = true; 674 } 675 676 /** 677 * Verifies that the connection is open and no exceptions should be thrown. 678 * @throws IOException if an exception needs to be thrown 679 */ 680 public void ensureOpen() throws IOException { 681 if (mExceptionString != null) { 682 throw new IOException(mExceptionString); 683 } 684 if (mClosed) { 685 throw new IOException("Operation has already ended"); 686 } 687 } 688 689 /** 690 * Verifies that additional information may be sent. In other words, the 691 * operation is not done. 692 * <P> 693 * Included to implement the BaseStream interface only. It does not do 694 * anything on the server side since the operation of the Operation object 695 * is not done until after the handler returns from its method. 696 * @throws IOException if the operation is completed 697 */ 698 public void ensureNotDone() throws IOException { 699 } 700 701 /** 702 * Called when the output or input stream is closed. It does not do anything 703 * on the server side since the operation of the Operation object is not 704 * done until after the handler returns from its method. 705 * @param inStream <code>true</code> if the input stream is closed; 706 * <code>false</code> if the output stream is closed 707 * @throws IOException if an IO error occurs 708 */ 709 public void streamClosed(boolean inStream) throws IOException { 710 711 } 712 } 713
