header.c

SyncML手册及其编程

            */
            dataSize = iobxBufSize( header->value.byteSequenceValue );
            if ( header->identifier == OBEX_HEADER_BODY || header->identifier == OBEX_HEADER_BODY_END ) {
               /*
               ** Can we handle all the data? (plus the opcode + len (i.e. 3) )
               */
               if ( bytes >= dataSize + 3 ) {
                  /* yep, it all fits. */
                  sendLength = dataSize;
                  /*header->identifier = OBEX_HEADER_BODY_END; */
                  header->state = STATE_SENT;
               } else {
                  sendLength = bytes - 3;
                  /* Nope, fragmenting */
                  /*header->identifier = OBEX_HEADER_BODY;*/
                  header->state = STATE_SENDING;
               }
            } else {
               header->state = STATE_SENT;
               sendLength = dataSize;
            }

            /*
            ** Identifier
            */
            if ( (rc=handle->transport->send( &handle->connectionId,
                                              &header->identifier,
                                              1,
                                              &wrote,
                                              FALSE )) == OBX_RC_OK ) {
               /*
               ** Length (must include opcode and length fields)
               */
               shortData = htons( (short)(sendLength+3) );
               if ( (rc=handle->transport->send( &handle->connectionId,
                                                 &shortData,
                                                 sizeof(shortData),
                                                 &wrote,
                                                 FALSE )) == OBX_RC_OK ) {
                  /*
                  ** Data, if any.
                  */
                  if ( sendLength > 0 ) {
                     if ( (bytebuffer = (void *)malloc(sendLength)) ) {
                        OBXDBGBUF(("iobxHeaderSend() malloc, addr=0x%08x, len=%d.\n", bytebuffer, sendLength ));
                        iobxBufRead( header->value.byteSequenceValue, bytebuffer, sendLength );
                        OBXDBGMEM(("iobxHeaderSend()", bytebuffer, sendLength));
                        if ( (rc=handle->transport->send( &handle->connectionId,
                                                          bytebuffer,
                                                          sendLength,
                                                          &wrote,
                                                          FALSE )) == OBX_RC_OK ) {
                        } else {
                           OBXDBGERR(("[ERROR] iobxHeaderSend() unexpected return code sending data.\n"));
                        }
                        free( bytebuffer );
                     } else {
                        OBXDBGERR(("[ERROR] iobxHeaderSend() error getting byte buffer, len=%d.\n", sendLength));
                        rc = OBX_RC_ERR_MEMORY;
                     }
                  }
               } else {
                  OBXDBGERR(("[ERROR] iobxHeaderSend() unexpected return code sending length.\n"));
               }
            } else {
               OBXDBGERR(("[ERROR] iobxHeaderSend() unexpected return code sending identifier.\n"));
            }
            break;

         /*
         ** Null terminated unicode text sequence, length prefixed with 2 byte unsigned integer,
         ** transmit length in nbo
         */
         case OBEX_HEADER_ENCODING_UNICODE:
            OBXDBGINFO(("iobxHeaderSend() 'UNICODE' encoding detected.\n"));
            /*
            ** Identifier
            */
            if ( (rc=handle->transport->send( &handle->connectionId,
                                              &header->identifier,
                                              1,
                                              &wrote,
                                              FALSE )) == OBX_RC_OK ) {
               /*
               ** Length
               */
               dataSize = iobxBufSize( header->value.unicodeValue );
               shortData = htons( (short)(dataSize+3) );
               if ( (rc=handle->transport->send( &handle->connectionId,
                                                 &shortData,
                                                 sizeof(shortData),
                                                 &wrote,
                                                 FALSE )) == OBX_RC_OK ) {
                  /*
                  ** Data
                  */
                  if ( dataSize > 0 ) {
                     if ( (bytebuffer = (void *)malloc( dataSize )) ) {
                        OBXDBGBUF(("iobxHeaderSend() malloc, addr=0x%08x, len=%d.\n", bytebuffer, dataSize ));
                        iobxBufRead( header->value.unicodeValue, bytebuffer, dataSize );
                        OBXDBGMEM(("iobxHeaderSend()", bytebuffer, dataSize));
                        if ( (rc=handle->transport->send( &handle->connectionId,
                                                          bytebuffer,
                                                          dataSize,
                                                          &wrote,
                                                          FALSE )) == OBX_RC_OK ) {

                           header->state = STATE_SENT;
                        } else {
                           OBXDBGERR(("[ERROR] iobxHeaderSend() unexpected return code sending data.\n"));
                        }
                        free( bytebuffer );
                     } else {
                        OBXDBGERR(("[ERROR] iobxHeaderSend() error getting byte buffer, len=%d.\n", dataSize));
                        rc = OBX_RC_ERR_MEMORY;
                     }
                  }
               } else {
                  OBXDBGERR(("[ERROR] iobxHeaderSend() unexpected return code sending length.\n"));
               }
            } else {
               OBXDBGERR(("[ERROR] iobxHeaderSend() unexpected return code sending identifier.\n"));
            }
            break;

         default:
            OBXDBGERR(("[ERROR] iobxHeaderSend() unknown encoding type.\n"));
            rc = OBX_RC_ERR_BADID;
            break;
         }
      } else {
         OBXDBGINFO(("[WARNING] iobxHeaderSend() called to send, already sent, ignored.\n"));
      }
   } else {
      OBXDBGERR(("[ERROR] iobxHeaderSend() no transport defined within handle.\n"));
      rc = OBX_RC_ERR_NOTINITIALIZED;     /* No transport */
   }
   if ( rc != OBX_RC_OK ) {
      header->state = STATE_ERROR;
   }
   return rc;
}

/*
** How large is this header right now?
** This is the size of the header if 'put on the wire' right now.  Including identifier,
** any lengths, data, etc.  If it's already 'sent' or in error, it returns zero.
*/
int         iobxHeaderSize( ObxHeader *header ) {
   int  size = 0;
   OBXDBGFLOW(("iobxHeaderSize() entry, header=0x%08x\n", header));
   if ( header->state != STATE_SENT && header->state != STATE_ERROR ) {
      size = 1;   /* for the identifier */
      switch ( header->identifier & OBEX_HEADER_ENCODING_MASK ) {
      case OBEX_HEADER_ENCODING_INT:
         size += 4;
         break;
      case OBEX_HEADER_ENCODING_BYTE:
         size += 1;
         break;
      case OBEX_HEADER_ENCODING_BYTE_SEQ:
         /* length field + data len */
         size += 2 + iobxBufSize( header->value.byteSequenceValue );
         break;
      case OBEX_HEADER_ENCODING_UNICODE:
         /* length field + data len */
         size += 2 + iobxBufSize( header->value.unicodeValue );
         break;
      }
   }
   return size;
}

/*
** The following routines are called by ObxHeaderNewHeader() once the header type has
** been determined.  The continue the population of the header (passed in) using the data
** contained in the buffer (passed in 'buf').
*/
ObxRc       iobxHeaderAddIntBuffer( ObxHeader *header, ObxBuffer *buf ) {
   int   theInt;

   OBXDBGFLOW(("iobxHeaderAddIntBuffer() entry, header=0x%08x\tbuf=0x%08x\n", header, buf));
   iobxBufRead( buf, &theInt, 4 );
   header->value.fourBytevalue = (int)ntohl(theInt);
   return OBX_RC_OK;
}

ObxRc       iobxHeaderAddByteBuffer( ObxHeader *header, ObxBuffer *buf ) {
   OBXDBGFLOW(("iobxHeaderAddByteBuffer() entry, header=0x%08x\tbuf=0x%08x\n", header, buf));
   iobxBufRead( buf, &header->value.byteValue, 1 );
   return OBX_RC_OK;
}

ObxRc       iobxHeaderAddUnicodeBuffer( ObxHeader *header, ObxBuffer *buf ) {
   ObxRc          rc = OBX_RC_OK;
   short          nboLength;
   short          hboLength = 0;
   ObxBuffer      *buffer = NULL;
   void           *bytebuffer;

   OBXDBGFLOW(("iobxHeaderAddUnicodeBuffer() entry, header=0x%08x\tbuf=0x%08x\n", header, buf));

   /* Glean length */
   if ( iobxBufRead( buf, &nboLength, 2 ) != 2 ) {
      OBXDBGERR(("[ERROR] iobxHeaderAddUnicodeBuffer() not enough bytes in header?\n"));
      return OBX_RC_ERR_MEMORY;
   }
   hboLength = ntohs( nboLength ) - 3;   /* len included opcode and length field */

   if ( (buffer = iobxBufNew( hboLength )) ) {
      if ( (bytebuffer=(void *)malloc( hboLength )) ) {
         OBXDBGBUF(("iobxHeaderAddUnicodeBuffer() malloc, addr=0x%08x, len=%d.\n", bytebuffer, hboLength ));
         if ( iobxBufRead( buf, bytebuffer, hboLength ) == hboLength ) {
            iobxBufWrite( buffer, bytebuffer, hboLength );
            header->value.unicodeValue = buffer;
         } else {
            OBXDBGERR(("[ERROR] iobxHeaderAddUnicodeBuffer() not enough bytes in header?\n"));
            rc = OBX_RC_ERR_MEMORY;
         }
         free( bytebuffer );
      } else {
         OBXDBGERR(("[ERROR] iobxHeaderAddUnicodeBuffer() error obtaining bytebuffer.\n"));
         rc = OBX_RC_ERR_MEMORY;
      }
   } else {
      OBXDBGERR(("[ERROR] iobxHeaderAddUnicodeBuffer() error obtaining obex buffer.\n"));
      rc = OBX_RC_ERR_MEMORY;
   }
   return rc;
}

ObxRc       iobxHeaderAddByteSequenceBuffer( ObxHeader *header, ObxBuffer *buf ) {
   ObxRc          rc = OBX_RC_OK;
   short          nboLength;
   short          hboLength = 0;
   ObxBuffer      *buffer = NULL;
   void           *bytebuffer;

   OBXDBGFLOW(("iobxHeaderAddByteSequenceBuffer() entry, header=0x%08x\tbuf=0x%08x\n", header, buf));

   /* Glean length */
   if ( iobxBufRead( buf, &nboLength, 2 ) != 2 ) {
      OBXDBGERR(("[ERROR] iobxHeaderAddByteSequenceBuffer() not enough bytes in header?\n"));
      return OBX_RC_ERR_MEMORY;
   }
   hboLength = ntohs( nboLength ) - 3;   /* len included opcode and length field */

   if ( (buffer = iobxBufNew( hboLength )) ) {
      if ( (bytebuffer=(void *)malloc( hboLength )) ) {
         OBXDBGBUF(("iobxHeaderAddByteSequenceBuffer() malloc, addr=0x%08x, len=%d.\n", bytebuffer, hboLength ));
         if ( iobxBufRead( buf, bytebuffer, hboLength ) == hboLength ) {
            iobxBufWrite( buffer, bytebuffer, hboLength );
            header->value.unicodeValue = buffer;
         } else {
            OBXDBGERR(("[ERROR] iobxHeaderAddByteSequenceBuffer() not enough bytes in header?\n"));
            rc = OBX_RC_ERR_MEMORY;
         }
         free( bytebuffer );
      } else {
         OBXDBGERR(("[ERROR] iobxHeaderAddByteSequenceBuffer() error obtaining bytebuffer.\n"));
         rc = OBX_RC_ERR_MEMORY;
      }
   } else {
      OBXDBGERR(("[ERROR] iobxHeaderAddByteSequenceBuffer() error obtaining obex buffer.\n"));
      rc = OBX_RC_ERR_MEMORY;
   }
   return rc;
}