/* Now, that's the interesting bit !	 * We split the sockets apart, one for each instance */	self->fd = server->fd;	self->serverfd = -1;	self->writefd = -1;	server->fd = -1;        self->state = MODE_SRV | STATE_IDLE;	return self;out_err:	if (self->tx_msg != NULL)		buf_free(self->tx_msg);	if (self->rx_msg != NULL)		buf_free(self->rx_msg);	free(self);	return NULL;}/** * OBEX_HandleInput - Let the OBEX parser do some work * @self: OBEX handle * @timeout: Maximum time to wait in seconds * * Let the OBEX parser read and process incoming data. If no data * is available this call will block. * * When a request has been sent or you are waiting for an incoming server- * request you should call this function until the request has finished. * * Like select() this function returns -1 on error, 0 on timeout or * positive on success. */int OBEX_HandleInput(obex_t *self, int timeout){	DEBUG(4, "\n");	obex_return_val_if_fail(self != NULL, -1);	return obex_transport_handle_input(self, timeout);}/** * OBEX_CustomDataFeed - Feed OBEX with data when using a custom transport * @self: OBEX handle * @inputbuf: Pointer to custom data * @actual: Length of buffer */int OBEX_CustomDataFeed(obex_t *self, uint8_t *inputbuf, int actual){	DEBUG(3, "\n");	obex_return_val_if_fail(self != NULL, -1);	obex_return_val_if_fail(inputbuf != NULL, -1);	return obex_data_indication(self, inputbuf, actual);}/** * OBEX_TransportConnect - Try to connect to peer * @self: OBEX handle * @saddr: Address to connect to * @addrlen: Length of address * * Returns -1 on error. */int OBEX_TransportConnect(obex_t *self, struct sockaddr *saddr, int addrlen){	DEBUG(4, "\n");	obex_return_val_if_fail(self != NULL, -1);	obex_return_val_if_fail((addrlen == 0) || (saddr != NULL), -1);	memcpy(&self->trans.peer, saddr, addrlen);	return obex_transport_connect_request(self);}/** * OBEX_TransportDisconnect - Disconnect transport * @self: OBEX handle */int OBEX_TransportDisconnect(obex_t *self){	DEBUG(4, "\n");	obex_return_val_if_fail(self != NULL, -1);	obex_transport_disconnect_request(self);	return 0;}/** * OBEX_GetFD - Get FD * @self: OBEX handle * * Returns the filedescriptor of the transport. Returns -1 on error. * Note that if you for example have a custom transport, no fd * is available. * * The returned filehandle can be used to do select() on, before * calling OBEX_HandleInput() * * There is one subtelty about this function. When the OBEX connection is * established, it returns the connection filedescriptor, while for * an unconnected server it will return the listening filedescriptor. * This mean that after receiving an incomming connection, you need to * call this function again. */int OBEX_GetFD(obex_t *self){	obex_return_val_if_fail(self != NULL, -1);	if(self->fd == -1)		return self->serverfd;	return self->fd;}/** * OBEX_Request - Start a request (as client) * @self: OBEX handle * @object: Object containing request * * Returns negative on error. */int OBEX_Request(obex_t *self, obex_object_t *object){	DEBUG(4, "\n");	obex_return_val_if_fail(self != NULL, -1);	if (self->object)	{		DEBUG(1, "We are busy.\n");		return -EBUSY;	}	obex_return_val_if_fail(object != NULL, -1);	self->object = object;        self->state = STATE_START | MODE_CLI;		return obex_client(self, NULL, 0);}/** * OBEX_CancelRequest - Cancel an ongoing operation * @self: OBEX handle * @nice: If true an OBEX Abort will be sent if beeing client *        or OBEX_RSP_UNAUTHORIZED as reponse if beeing server. * * */int OBEX_CancelRequest(obex_t *self, int nice){	obex_return_val_if_fail(self != NULL, -1);	return obex_cancelrequest(self, nice);}/** * OBEX_SuspendRequest - Suspend transfer of an object * @self: OBEX handle * @object: object to suspend (NULL to suspend currently transfered object) */int OBEX_SuspendRequest(obex_t *self, obex_object_t *object){	obex_return_val_if_fail(object != NULL || self->object != NULL, -1);	return obex_object_suspend(object ? object : self->object);}/** * OBEX_ResumeRequest - Resume transfer of an object * @self: OBEX handle */int OBEX_ResumeRequest(obex_t *self){	obex_return_val_if_fail(self->object != NULL, -1);	return obex_object_resume(self, self->object);}/** * OBEX_ObjectNew - Create a new OBEX Object * @self: OBEX handle * @cmd: command of object * * Returns a pointer to a new OBEX Object or %NULL on error. */obex_object_t *OBEX_ObjectNew(obex_t *self, uint8_t cmd){	obex_object_t *object;	obex_return_val_if_fail(self != NULL, NULL);	object = obex_object_new();	if(object == NULL)		return NULL;	obex_object_setcmd(object, cmd, (uint8_t) (cmd | OBEX_FINAL));	/* Need some special woodoo magic on connect-frame */	if(cmd == OBEX_CMD_CONNECT)	{		if(obex_insert_connectframe(self, object) < 0)	{			obex_object_delete(object);			object = NULL;		}	}	return object;}/** * OBEX_ObjectDelete - Delete an OBEX object * @self: OBEX handle * @object: object to delete. * * Note that as soon as you have passed an object to the lib using * OBEX_Request(), you shall not delete it yourself. */int OBEX_ObjectDelete(obex_t *self, obex_object_t *object){	obex_return_val_if_fail(object != NULL, -1);	return obex_object_delete(object);}/** * OBEX_ObjectAddHeader - Attach a header to an object * @self: OBEX handle * @object: OBEX object * @hi: Header identifier * @hv: Header value * @hv_size: Header size * @flags: See obex.h for possible values * * Add a new header to an object. * * If you want all headers to fit in one packet, use the flag * %OBEX_FL_FIT_ONE_PACKET on all headers you add to an object. * * To stream a body add a body header with hv.bs = %NULL and set the flag * %OBEX_FL_STREAM_START. You will now get %OBEX_EV_STREAMEMPTY events as * soon as the the parser wants you to feed it with more data. * * When you get an %OBEX_EV_STREAMEMPTY event give the parser some data by * adding a body-header and set the flag %OBEX_EV_STREAM_DATA. When you * have no more data to send set the flag %OBEX_EV_STREAM_DATAEND instead. * * After adding a header you are free to do whatever you want with the buffer * if you are NOT streaming. If you are streaming you may not touch the * buffer until you get another %OBEX_EV_STREAMEMTPY or until the request * finishes. * * The headers will be sent in the order you add them. */int OBEX_ObjectAddHeader(obex_t *self, obex_object_t *object, uint8_t hi,				obex_headerdata_t hv, uint32_t hv_size,				unsigned int flags){	obex_return_val_if_fail(self != NULL, -1);	obex_return_val_if_fail(object != NULL, -1);	return obex_object_addheader(self, object, hi, hv, hv_size, flags);}/** * OBEX_ObjectGetNextHeader - Get next available header from an object * @self: OBEX handle * @object: OBEX object * @hi: Pointer to header identifier * @hv: Pointer to hv * @hv_size: Pointer to hv_size * * Returns 0 when no more headers are available. * * All headers are read-only. * * You will get the headers in the received order. */int OBEX_ObjectGetNextHeader(obex_t *self, obex_object_t *object, uint8_t *hi,					obex_headerdata_t *hv,					uint32_t *hv_size){	obex_return_val_if_fail(self != NULL, -1);	obex_return_val_if_fail(object != NULL, -1);	return obex_object_getnextheader(self, object, hi, hv, hv_size);}/** * OBEX_ObjectReParseHeaders - Allow the user to parse again the rx headers * @self: OBEX handle * @object: OBEX object * * The user must have extracted all headers from the object before * calling this function (until %OBEX_ObjectGetNextHeader() returns 0). * Next call to %OBEX_ObjectGetNextHeader() will return the first received * header. * * Returns 1 on success * Returns 0 if failed due previous parsing not completed. */int OBEX_ObjectReParseHeaders(obex_t *self, obex_object_t *object){	obex_return_val_if_fail(self != NULL, -1);	obex_return_val_if_fail(object != NULL, -1);	return obex_object_reparseheaders(self, object);}/** * OBEX_ObjectReadStream - Read data from body stream * @self: OBEX handle * @object: OBEX object * @buf: A pointer to a pointer which this function will set to a buffer which * shall be read (and ONLY read) after this function returns. * * To recieve the body as a stream call this function with buf = %NULL as soon * as you get an OBEX_EV_REQHINT event. * * You will now recieve %OBEX_EV_STREAMAVAIL events when data is available * for you. Call this function to get the data. * * Note! When receiving a stream data is not buffered so if you don't call this * function when you get an %OBEX_EV_STREAMAVAIL event data will be lost. * * Returns the number of bytes in buffer, or 0 for end-of-stream. */int OBEX_ObjectReadStream(obex_t *self, obex_object_t *object, const uint8_t **buf){	obex_return_val_if_fail(self != NULL, -1);	obex_return_val_if_fail(object != NULL, -1);	return obex_object_readstream(self, object, buf);}/** * OBEX_ObjectSetRsp - Sets the response to a received request. * @self: OBEX handle * @object: OBEX object * @rsp: Respose code in non-last packets * @lastrsp: Response code in last packet * * Returns -1 on error. */int OBEX_ObjectSetRsp(obex_object_t *object, uint8_t rsp, uint8_t lastrsp){	obex_return_val_if_fail(object != NULL, -1);	return obex_object_setrsp(object, rsp, lastrsp);}/** * OBEX_ObjectGetNonHdrData - Get any data which was before headers * @object: OBEX object * @buffer: Pointer to a pointer which will point to a read-only buffer * * Returns the size of the buffer or -1 for error. */int OBEX_ObjectGetNonHdrData(obex_object_t *object, uint8_t **buffer){	obex_return_val_if_fail(object != NULL, -1);	if(!object->rx_nonhdr_data)		return 0;	*buffer = object->rx_nonhdr_data->data;	return object->rx_nonhdr_data->data_size;}/** * OBEX_ObjectSetNonHdrData - Set data to send before headers * @object: OBEX object * @buffer: Data to send * @len: Length to data * * Some commands (notably SetPath) send data before headers. Use this * function to set this data. */int OBEX_ObjectSetNonHdrData(obex_object_t *object, const uint8_t *buffer, unsigned int len){	//TODO: Check that we actually can send len bytes without violating MTU	obex_return_val_if_fail(object != NULL, -1);	obex_return_val_if_fail(buffer != NULL, -1);	if(object->tx_nonhdr_data)		return -1;	object->tx_nonhdr_data = buf_new(len);	if(object->tx_nonhdr_data == NULL)		return -1;	buf_insert_end(object->tx_nonhdr_data, (uint8_t *)buffer, len);	return 1;}/** * OBEX_ObjectSetHdrOffset - Set headeroffset * @object: OBEX object