obex_object.c

来自「sparc硬件平台上的红外协议」· C语言 代码 · 共 828 行 · 第 1/2 页

/*********************************************************************
*                
* Filename:      obex_object.c
* Version:       0.8
* Description:   OBEX object related functions
* Status:        Experimental.
* Author:        Dag Brattli <[e-mail]>
* Created at:    Fri Apr 23 14:04:29 1999
* CVS ID:        $Id: obex_object.c,v 1.27 2006/05/04 11:24:21 holtmann Exp $
*
*     Copyright (c) 1999, 2000 Pontus Fuchs, All Rights Reserved.
*     Copyright (c) 1999, 2000 Dag Brattli, All Rights Reserved.
*     
*     This library is free software; you can redistribute it and/or
*     modify it under the terms of the GNU Lesser General Public
*     License as published by the Free Software Foundation; either
*     version 2 of the License, or (at your option) any later version.
*
*     This library is distributed in the hope that it will be useful,
*     but WITHOUT ANY WARRANTY; without even the implied warranty of
*     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
*     Lesser General Public License for more details.
*
*     You should have received a copy of the GNU Lesser General Public
*     License along with this library; if not, write to the Free Software
*     Foundation, Inc., 59 Temple Place, Suite 330, Boston, 
*     MA  02111-1307  USA    
*
********************************************************************/


#include <stdio.h>
#include <string.h>

#include "obex_main.h"
#include "obex_object.h"
#include "obex_header.h"
#include "obex_connect.h"
#include <stdlib.h>
/*
* Function obex_object_new ()
*
*    Create a new OBEX object
*
*/
obex_object_t *obex_object_new(void)
{
	obex_object_t *object;
	
	object =  malloc(sizeof(obex_object_t));
	if (object == NULL)
	{
		DEBUG(4,"can not alloc memory\n");
		return(NULL);
	}
	memset(object, 0, sizeof(obex_object_t));
	
	obex_object_setrsp(object, OBEX_RSP_NOT_IMPLEMENTED, OBEX_RSP_NOT_IMPLEMENTED);
	return object;
}

/*
* Function free_headerq(q)
*
*    Free all headers in a header queue.
*
*/
static inline void free_headerq(slist_t **q)
{
	struct obex_header_element *h;
	
	DEBUG(4, "\n");
	while(*q != NULL) {
		h = (*q)->data;
		*q = slist_remove(*q, h);
		buf_free(h->buf);
		free(h);
	}
	
}

/*
* Function obex_object_delete (object)
*
*    Delete OBEX object
*
*/
int obex_object_delete(obex_object_t *object)
{
	
	DEBUG(5, "\n");
	obex_return_val_if_fail(object != NULL, -1);
	
	/* Free the headerqueues */
	free_headerq(&object->tx_headerq);
	free_headerq(&object->rx_headerq);
	free_headerq(&object->rx_headerq_rm);
	
	/* Free tx and rx msgs */
	buf_free(object->tx_nonhdr_data);
	object->tx_nonhdr_data = NULL;
	
	buf_free(object->rx_nonhdr_data);
	object->rx_nonhdr_data = NULL;
	
	buf_free(object->rx_body);
	object->rx_body = NULL;
	
	free(object);
	object = NULL;
	return 0;
}

/*
* Function obex_object_setcmd ()
*
*    Set command of object
*
*/
int obex_object_setcmd(obex_object_t *object, uint8_t cmd, uint8_t lastcmd)
{
	DEBUG(4,"%02x\n", cmd);
	object->cmd = cmd;
	object->opcode = cmd;
	object->lastopcode = lastcmd;
	return 1;
}

/*
* Function obex_object_setrsp ()
*
*    Set the response for an object
*
*/
int obex_object_setrsp(obex_object_t *object, uint8_t rsp, uint8_t lastrsp)
{
	DEBUG(4,"\n");
	object->opcode = rsp;
	object->lastopcode = lastrsp;
	return 1;
}

/*
* Function int obex_object_addheader(obex_object_t *object, uint8_t hi, 
*                      obex_headerdata_t hv, uint32_t hv_size, unsigned int flags)
*
*    Add a header to the TX-queue.
*
*/
int obex_object_addheader(obex_t *self, obex_object_t *object, uint8_t hi,
						  obex_headerdata_t hv, uint32_t hv_size, unsigned int flags)
{
	int ret = -1;
	struct obex_header_element *element;
	unsigned int maxlen;
	
	DEBUG(4, "\n");
	/* End of stream marker */
	if(flags & OBEX_FL_STREAM_DATAEND)	{
		if(self->object == NULL)
			return -1;
		self->object->s_stop = TRUE;
		self->object->s_buf = hv.bs;
		self->object->s_len = hv_size;
		return 1;
	}
	
	/* Stream data */
	if(flags & OBEX_FL_STREAM_DATA)	{
		if(self->object == NULL)
			return -1;
		self->object->s_buf = hv.bs;
		self->object->s_len = hv_size;
		return 1;
	}
	
	if(flags & OBEX_FL_FIT_ONE_PACKET)	{
		/* In this command all headers must fit in one packet! */
		DEBUG(3, "Fit one packet!\n");
		maxlen = self->mtu_tx - object->totallen - sizeof(struct obex_common_hdr);
	}
	else	{
		maxlen = self->mtu_tx - sizeof(struct obex_common_hdr);
	}
	
	element = malloc(sizeof(struct obex_header_element));
	if(element == NULL)
	{
		DEBUG(4,"can not alloc memory\n");
		return -1;
	}
	memset(element, 0, sizeof(struct obex_header_element));
	
	element->hi = hi;
	element->flags = flags;
	
	/* Is this a stream? */
	if(flags & OBEX_FL_STREAM_START) {
		DEBUG(3, "Adding stream\n");
		element->stream = TRUE;
		object->tx_headerq = slist_append(object->tx_headerq, element);
		return 1;
	}
	
	if (hi == OBEX_HDR_EMPTY) {
		DEBUG(2, "Empty header\n");
		object->tx_headerq = slist_append(object->tx_headerq, element);
		return 1;
	}
	
	switch (hi & OBEX_HI_MASK) {
	case OBEX_INT:
		DEBUG(2, "4BQ header %d\n", hv.bq4);
		
		element->buf = buf_new(sizeof(struct obex_uint_hdr));
		if(element->buf) {
			element->length = (unsigned int) sizeof(struct obex_uint_hdr);
			ret = insert_uint_header(element->buf, hi, hv.bq4);
		}
		break;
		
	case OBEX_BYTE:
		DEBUG(2, "1BQ header %d\n", hv.bq1);
		
		element->buf = buf_new(sizeof(struct obex_ubyte_hdr));
		if(element->buf) {
			element->length = sizeof(struct obex_ubyte_hdr);
			ret = insert_ubyte_header(element->buf, hi, hv.bq1);
		}
		break;
		
	case OBEX_BYTE_STREAM:
		DEBUG(2, "BS  header size %d\n", hv_size);
		
		element->buf = buf_new(hv_size + sizeof(struct obex_byte_stream_hdr) );
		if(element->buf) {
			element->length = hv_size + sizeof(struct obex_byte_stream_hdr);
			ret = insert_byte_stream_header(element->buf, hi, hv.bs, hv_size);
		}
		break;
		
	case OBEX_UNICODE:
		DEBUG(2, "Unicode header size %d\n", hv_size);
		
		element->buf = buf_new(hv_size + sizeof(struct obex_unicode_hdr) );
		if(element->buf) {
			element->length = hv_size + sizeof(struct obex_unicode_hdr);
			ret = insert_unicode_header(element->buf, hi, hv.bs, hv_size);
		}
		break;
		
	default:
		DEBUG(2, "Unsupported encoding %02x\n", hi & OBEX_HI_MASK);
		ret = -1;
		break;
	}
	
	/* Check if you can send this header without violating MTU or OBEX_FIT_ONE_PACKET */
	if( (element->hi != OBEX_HDR_BODY) || (flags & OBEX_FL_FIT_ONE_PACKET) )	{
		if(maxlen < element->length)	{
			DEBUG(0, "Header to big\n");
			ret = -1;
		}
	}
	
	if (ret > 0) {
		object->totallen += ret;
		object->tx_headerq = slist_append(object->tx_headerq, element);
		ret = 1;
	} else {
		buf_free(element->buf);
		free(element);
	}
	
	return ret;
}


/*
* Function send_stream(object, header, txmsg, tx_left)
*
*  Send a streaming header.
*
*/
static int send_stream(obex_t *self,
					   struct obex_header_element *h,
					   buf_t *txmsg, unsigned int tx_left)
{
	obex_object_t *object;
	struct obex_byte_stream_hdr *body_txh;
	int actual; 	/* Number of bytes sent in this fragment */
	
	DEBUG(4, "\n");
	
	object = self->object;
	
	/* Fill in length and header type later, but reserve space for it */
	body_txh  = (struct obex_byte_stream_hdr*) buf_reserve_end(txmsg,
		sizeof(struct obex_byte_stream_hdr) );
	tx_left -= sizeof(struct obex_byte_stream_hdr);
	actual = sizeof(struct obex_byte_stream_hdr);
	
	do {
		if(object->s_len == 0) {
			/* Ask app for more data if no more */
			object->s_offset = 0;
			object->s_buf = NULL;
			obex_deliver_event(self, OBEX_EV_STREAMEMPTY, 0, 0, FALSE);
			DEBUG(4, "s_len=%d, s_stop = %d\n",
				object->s_len, object->s_stop);
			/* End of stream ?*/
			if(object->s_stop)
				break;
			
			/* User suspended and didn't provide any new data */
			if (object->suspend && object->s_buf == NULL)
				break;
			
			/* Error ?*/
			if(object->s_buf == NULL) {
				DEBUG(1, "Unexpected end-of-stream\n");
				return -1;
			}
		}
		
		if(tx_left < object->s_len) {
			/*燭here is more data left in buffer than tx_left */
			DEBUG(4, "More data than tx_left. Buffer will not be empty\n");
			
			buf_insert_end(txmsg, (uint8_t*) object->s_buf + object->s_offset, tx_left);
			object->s_len -= tx_left;
			object->s_offset += tx_left;
			actual += tx_left;
			tx_left = 0;
		}
		else {
			/* There less data in buffer than tx_left */
			DEBUG(4, "Less data that tx_left. Buffer will be empty\n");
			buf_insert_end(txmsg, (uint8_t*) object->s_buf + object->s_offset, object->s_len);
			tx_left -= object->s_len;
			object->s_offset += object->s_len;
			actual += object->s_len;
			object->s_len = 0;
			if (object->suspend)
				tx_left = 0;
		}
	} while(tx_left > 0);
	
	DEBUG(4, "txmsg full or no more stream-data. actual = %d\n", actual);
	body_txh->hi = OBEX_HDR_BODY;
	
	if(object->s_stop && object->s_len == 0) {
		/* We are done. Remove header from tx-queue */
		object->tx_headerq = slist_remove(object->tx_headerq, h);
		body_txh->hi = OBEX_HDR_BODY_END;
		buf_free(h->buf);
		free(h);
	}
	//modify by xugangan
	body_txh->hl = htons((uint16_t)actual);

	return actual;
}





/*
* Function obex_object_send()
*
*    Send away all headers attached to an object. Returns:
*       1 on sucessfully done
*       0 on progress made
*     < 0 on error
*/
int obex_object_send(obex_t *self, obex_object_t *object,
					 int allowfinalcmd, int forcefinalbit)
{
	struct obex_header_element *h;
	buf_t *txmsg;
	int actual, finished = 0;
	uint16_t tx_left;
	int addmore = TRUE;
	int real_opcode;
	
	DEBUG(1, "\n");
	
	/* Calc how many bytes of headers we can fit in this package */
	tx_left = self->mtu_tx - sizeof(struct obex_common_hdr);
	switch(self->trans.type)
	{
		
	case OBEX_TRANS_IRDA:
		if(self->trans.mtu > 0 && self->mtu_tx > self->trans.mtu)
		{
			tx_left -= self->mtu_tx%self->trans.mtu;
		}
		break;
		
	default:
		break;
	}
	
	/* Reuse transmit buffer */
	txmsg = buf_reuse(self->tx_msg);
	
	/* Add nonheader-data first if any (SETPATH, CONNECT)*/
	if(object->tx_nonhdr_data) {
		DEBUG(4, "Adding %d bytes of non-headerdata\n", object->tx_nonhdr_data->data_size);
		buf_insert_end(txmsg, object->tx_nonhdr_data->data, object->tx_nonhdr_data->data_size);
		
		buf_free(object->tx_nonhdr_data);
		object->tx_nonhdr_data = NULL;