obex.c

SyncML手册及其编程

                  OBXDBGINFO(("ObxTransactionRecv() no-FINAL bit from peer.\n"));
                  response->cmd = (OBEX_RSP_CONTINUE | OBEX_CMD_FINAL);
                  /*
                  ** If this is a streaming request, we could be done.
                  */
                  done = requestOut->stream;
               }

               /*
               ** Flow response, success or continue.
               */
               if ( (rc=iobxObjectSendObject( response, handle )) != OBX_RC_OK ) {
                  OBXDBGERR(("[ERROR] ObxTransactionRecv() bad return code from iobxObjectSendObject() rc=%d\n", rc));
                  done = TRUE;
               }
            } else {
               OBXDBGERR(("[ERROR] ObxTransactionRecv() bad return code from iobxObjectReset() rc=%d\n", rc));
               done = TRUE;
            }
         } else {
            OBXDBGERR(("[ERROR] ObxTransactionRecv() bad return code from iobxObjectRecvObject() rc=%d\n", rc));
            done = TRUE;
         }
      } else {
         OBXDBGERR(("[ERROR] ObxTransactionRecv() bad return code from iobxObjectReset() rc=%d\n", rc));
         done = TRUE;
      }
   }

//Send client a response with a code that indicates what's wrong
   switch(rc) {
   case OBX_RC_ERR_SML_TARGET_HDR:
      OBXDBGERR(("[ERROR] ObxTransactionRecv() received Target header error\n"));
      response->cmd = (OBEX_RSP_BAD_REQUEST | OBEX_CMD_FINAL);
      if ( (rc=iobxObjectSendObject( response, handle )) != OBX_RC_OK ) {
         OBXDBGERR(("[ERROR] ObxTransactionRecv() bad return code from iobxObjectSendObject() rc=%d\n", rc));
      }
   }

   iobxObjectFree( request );
   iobxObjectFree( response );
   return rc;
}
#endif /* RAW_API_ONLY */

OBEX_EXPORT ObxRc ObxObjectRecv( ObxHandle *handle, ObxObject *object ) {
   OBXDBGFLOW(("ObxObjectRecv() entry, handle=0x%08x\tobject=0x%08x\n", handle, object));
   return iobxObjectRecvObject( object, handle );
}

OBEX_EXPORT ObxObject* ObxObjectNew( ObxHandle *handle, ObxCommand cmd ) {
   ObxObject *object = NULL;
   OBXDBGFLOW(("ObxObjectNew() entry, handle=0x%08x\tcmd=%x.\n", handle, cmd));
   if ( (object = iobxObjectNew()) ) {
      if ( iobxObjectReset( object ) == OBX_RC_OK ) {
         object->cmd = cmd;

         switch ( cmd ) {
         case OBEX_CMD_CONNECT:
            if ( (iobxObjectSetConnectMeta( object,
                                            OBX_CONNECT_META_VERSION,
                                            OBX_CONNECT_META_FLAGS,
                                            handle->maxPacketLen )) != OBX_RC_OK ) {
               OBXDBGERR(("[ERROR] ObxObjectNew() unexpected rc from iobxObjectSetConnectMeta()\n"));
               free( object );
               object = NULL;
            }
            break;
         case OBEX_CMD_SETPATH:
            if ( (iobxObjectSetSetPathMeta( object,
                                            OBX_SETPATH_META_FLAGS,
                                            OBX_SETPATH_META_CONSTANTS )) != OBX_RC_OK ) {
               OBXDBGERR(("[ERROR] ObxObjectNew() unexpected rc from iobxObjectSetSetPathMeta()\n"));
               free( object );
               object = NULL;
            }
            break;
         }
      } else {
         free( object );
         object = NULL;
      }
   } else {
      OBXDBGERR(("[ERROR] ObxObjectNew() failure calling iobxObjectNew().\n"));
      object = NULL;
   }
   return object;
}

OBEX_EXPORT ObxObject*     ObxObjectNewResponse( ObxHandle *handle, ObxObject *request, ObxCommand cmd ) {
   ObxObject *object = NULL;
   OBXDBGFLOW(("ObxObjectNewResponse() entry, handle=0x%08x\trequest=0x%08x\tcmd=%x.\n", handle, request, cmd));
   if ( (object=ObxObjectNew( handle, cmd )) ) {
      if ( request->cmd == OBEX_CMD_CONNECT ) {
         if ( (iobxObjectSetConnectMeta( object,
                                         OBX_CONNECT_META_VERSION,
                                         OBX_CONNECT_META_FLAGS,
                                         handle->maxPacketLen )) != OBX_RC_OK ) {
            OBXDBGERR(("[ERROR] ObxObjectNewResponse() unexpected rc from iobxObjectSetConnectMeta()\n"));
            free( object );
            object = NULL;
         }
      }
   }
   return object;
}

OBEX_EXPORT ObxRc ObxObjectFree( ObxHandle *handle, ObxObject *object ) {
   OBXDBGFLOW(("ObxObjectFree() entry, handle=0x%08x\tobject=0x%08x\n", handle, object));
   iobxObjectFree( object );
   return OBX_RC_OK;
}

OBEX_EXPORT ObxRc ObxObjectReset( ObxObject *object ) {
   OBXDBGFLOW(("ObxObjectReset() entry, object=0x%08x\n", object));
   return iobxObjectReset( object );
}

OBEX_EXPORT ObxRc ObxObjectAddHeader( ObxHandle *handle, ObxObject *object, ObxHeader *header ) {
   OBXDBGFLOW(("ObxObjectAddHeader() entry, handle=0x%08x\tobject=0x%08x\theader=0x%08x\n", handle, object, header));
   return iobxObjectAddHeader( object, header, handle );
}

OBEX_EXPORT ObxList *ObxObjectGetHeaderList( ObxObject *object ) {
   OBXDBGFLOW(("ObxObjectGetHeaderList() entry, object=0x%08x\n", object));
   return iobxObjectGetHeaderList( object );
}

OBEX_EXPORT ObxCommand ObxObjectGetCommand( ObxObject *object ) {
   OBXDBGFLOW(("ObxObjectGetCommand() entry, object=0x%08x\n", object));
   return (object ? object->cmd : -1);
}


OBEX_EXPORT ObxHeader *ObxHeaderNew( unsigned char opcode ) {
   OBXDBGFLOW(("ObxHeaderNew() entry.\n"));
   return iobxHeaderNew( opcode );
}

OBEX_EXPORT ObxRc ObxHeaderSetIntValue( ObxHeader *header, unsigned int value ) {
   OBXDBGFLOW(("ObxHeaderSetIntValue() entry, header=0x%08x\tvalue=0x%08x\n",header,value));
   return iobxHeaderSetIntValue( header, value );
}

OBEX_EXPORT ObxRc ObxHeaderSetByteValue( ObxHeader *header, unsigned char value ) {
   OBXDBGFLOW(("ObxHeaderSetByteValue() entry, header=0x%08x\tvalue=%x\n",header,value));
   return iobxHeaderSetByteValue( header, value );
}

OBEX_EXPORT ObxRc ObxHeaderSetUnicodeValue( ObxHeader *header, ObxBuffer *value ) {
   OBXDBGFLOW(("ObxHeaderSetUnicodeValue() entry, header=0x%08x\tvalue(buffer)=0x%08x\n",header,value));
   return iobxHeaderSetUnicodeValue( header, value );
}

OBEX_EXPORT ObxRc ObxHeaderSetByteSequenceValue( ObxHeader *header, ObxBuffer *value ) {
   OBXDBGFLOW(("ObxHeaderSetByteSequenceValue() entry, header=0x%08x\tvalue(buffer)=0x%08x\n",header,value));
   return iobxHeaderSetByteSequenceValue( header, value );
}

OBEX_EXPORT ObxHeader *ObxHeaderNewFromBuffer( ObxBuffer *buffer, ObxObject *object ) {
   OBXDBGFLOW(("ObxHeaderNewFromBuffer() entry, buffer=0x%08x\n",buffer));
   return iobxHeaderNewFromBuffer( buffer, object );
}

OBEX_EXPORT void ObxHeaderFree( ObxHeader *header ) {
   OBXDBGFLOW(("ObxHeaderFree() entry, header=0x%08x\n",header));
   iobxHeaderFree( header );
}

OBEX_EXPORT int ObxHeaderSize( ObxHeader *header ) {
   OBXDBGFLOW(("ObxHeaderSize() entry, header=0x%08x\n",header));
   return iobxHeaderSize( header );
}

OBEX_EXPORT ObxRc ObxHeaderAdd( ObxHandle *handle, ObxObject *object, ObxHeader *header ) {
   OBXDBGFLOW(("ObxHeaderAdd() entry, handle=0x%08x\tobject=0x%08x\theader=0x%08x\n", handle, object, header));
   return iobxObjectAddHeader( object, header, handle );
}

OBEX_EXPORT ObxList *ObxGetHeaderList( ObxHandle *handle, ObxObject *object ) {
   OBXDBGFLOW(("ObxGetHeaderList() entry, handle=0x%08x\tobject=0x%08x\n", handle, object));
   return iobxObjectGetHeaderList( object );
}

OBEX_EXPORT ObxBuffer   *ObxBufNew( int len ) {
   OBXDBGFLOW(("ObxBufNew() entry, len=%d\n", len));
   return iobxBufNew( len );
}

OBEX_EXPORT void        ObxBufFree( ObxBuffer *buf ) {
   OBXDBGFLOW(("ObxBufFree() entry, buf=0x%08x\n", buf));
   iobxBufFree( buf );
}

OBEX_EXPORT ObxBuffer   *ObxBufReset( ObxBuffer *buf ) {
   OBXDBGFLOW(("ObxBufReset() entry, buf=0x%08x\n", buf));
   return iobxBufReset( buf );
}

OBEX_EXPORT int         ObxBufWrite( ObxBuffer *buf, void *data, int len ) {
   OBXDBGFLOW(("ObxBufWrite() entry, buf=0x%08x\tdata=0x%08x\tlen=%d\n", buf, data, len));
   OBXDBGMEM(("ObxBufWrite()", data, len));
   return iobxBufWrite( buf, data, len );
}

OBEX_EXPORT int         ObxBufPeek( ObxBuffer *buf, void *data, int len ) {
   OBXDBGFLOW(("ObxBufPeek() entry, buf=0x%08x\tdata=0x%08x\tlen=%d\n", buf, data, len));
   return iobxBufPeek( buf, data, len );
}

OBEX_EXPORT int         ObxBufRead( ObxBuffer *buf, void *data, int len ) {
   OBXDBGFLOW(("ObxBufRead() entry, buf=0x%08x\tdata=0x%08x\tlen=%d\n", buf, data, len));
   return iobxBufRead( buf, data, len );
}

OBEX_EXPORT int         ObxBufSize( ObxBuffer *buf ) {
   OBXDBGFLOW(("ObxBufRead() entry, buf=0x%08x\n", buf));
   return iobxBufSize( buf );
}


OBEX_EXPORT ObxList *ObxListNew() {
   OBXDBGFLOW(("ObxListNew() entry.\n"));
   return iobxListNew();
}

OBEX_EXPORT void ObxListFree( ObxList *list ) {
   OBXDBGFLOW(("ObxListFree() entry, list=0x%08x\n", list));
   iobxListFree( list );
}

OBEX_EXPORT void ObxListReset( ObxList *list ) {
   OBXDBGFLOW(("ObxListReset() entry, list=0x%08x\n", list));
   iobxListReset( list );
}

OBEX_EXPORT void ObxListRelease( ObxList *list ) {
   OBXDBGFLOW(("ObxListRelease() entry, list=0x%08x\n", list));
   iobxListRelease( list );
}

OBEX_EXPORT void *ObxListAppend( ObxList *list, void *data ) {
   OBXDBGFLOW(("ObxListAppend() entry, list=0x%08x\n", list));
   return iobxListAppend( list, data );
}

OBEX_EXPORT ObxIterator *ObxListGetIterator( ObxList *list ) {
   OBXDBGFLOW(("ObxListGetIterator() entry, list=0x%08x\n", list));
   return iobxListGetIterator( list );
}

OBEX_EXPORT void *ObxListInsert( ObxList *list, const ObxIterator *iterator, void *data ) {
   OBXDBGFLOW(("ObxListInsert() entry, list=0x%08x\titerator=0x%08x\n", list,iterator));
   return iobxListInsert( list, iterator, data );
}

OBEX_EXPORT void *ObxListRemove( ObxList *list, ObxIterator *iterator ) {
   OBXDBGFLOW(("ObxListRemove() entry, list=0x%08x\titerator=0x%08x\n", list,iterator));
   return iobxListRemove( list, iterator );
}

OBEX_EXPORT void ObxListDelete( ObxList *list, ObxIterator *iterator ) {
   OBXDBGFLOW(("ObxListDelete() entry, list=0x%08x\titerator=0x%08x\n", list,iterator));
   iobxListDelete( list, iterator );
}

OBEX_EXPORT ObxIterator *ObxIteratorReset( ObxIterator *iterator ) {
   OBXDBGFLOW(("ObxIteratorReset() entry, iterator=0x%08x\n", iterator));
   return iobxIteratorReset( iterator );
}

OBEX_EXPORT void ObxIteratorFree( ObxIterator *iterator ) {
   OBXDBGFLOW(("ObxIteratorFree() entry, iterator=0x%08x\n", iterator));
   iobxIteratorFree( iterator );
}

OBEX_EXPORT void *ObxIteratorNext( ObxIterator *iterator ) {
   OBXDBGFLOW(("ObxIteratorNext() entry, iterator=0x%08x\n", iterator));