sdpsrv.c

Affix - Bluetooth Protocol Stack for Linux has been developed at Nokia Research Center in Helsinki

/* 
   Affix - Bluetooth Protocol Stack for Linux
   Copyright (C) 2001,2002 Nokia Corporation
   Author: Dmitry Kasatkin <[e-mail]>

   Original Author: Guruprasad Krishnamurthy <[e-mail]>

   This program is free software; you can redistribute it and/or modify it
   under the terms of the GNU General Public License as published by the
   Free Software Foundation; either version 2 of the License, or (at your
   option) any later version.

   This program 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
   General Public License for more details.

   You should have received a copy of the GNU General Public License along
   with this program; if not, write to the Free Software Foundation, Inc.,
   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
   */

/*
   $Id: sdpsrv.c,v 1.51 2004/01/16 15:12:50 litos Exp $

   Contains implementation of SDP service registration APIs
 
   Contains utlities for use by SDP service registration clients
   to add attributes to a service record.

   Fixes:
		Manel Guerrero			: service delete
		Dmitry Kasatkin			: int changed to complex type
		Dmitry Kasatkin			: cleanup
		Dmitry Kasatkin			: new simple API
*/

#include <affix/config.h>

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

#include <affix/sdp.h>
#include <affix/sdpsrv.h>
#include <affix/sdpclt.h>
#include "utils.h"
#include "attr.h"


int sdp_register_service(int srvHandle, sdpsvc_t *svcRec)
{
	char		*pdata;
	int		status = 0;
	char		*requestBuffer;
	char		*responseBuffer;
	int		requestSize;
	int		responseSize;
	sdp_hdr_t	*pduRequestHeader;
	sdp_hdr_t	*pduResponseHeader;
	uint32_t	svcRecHandle;
	
	if (svcRec->state != SDP_STATE_REGISTER_READY)
		return SDP_ERR_INVALID_ARG;
	requestBuffer = (char *)malloc(SDP_REQ_BUF_SIZE);
	if (!requestBuffer)
		return -1;
	responseBuffer = (char *)malloc(SDP_RSP_BUF_SIZE);
	if (!responseBuffer) {
		free(requestBuffer);
		return -1;
	}
	pduRequestHeader = (sdp_hdr_t *)requestBuffer;
	pduRequestHeader->pduId = SDP_PDU_REG_REQ;
	pduRequestHeader->transactionId = htons(sdp_gen_trans());

	pdata = (char *)(requestBuffer + sizeof(sdp_hdr_t));
	requestSize = sizeof(sdp_hdr_t);                       

	sdp_gen_svc_pdu(svcRec);
	memcpy(pdata, svcRec->pdu.data, svcRec->pdu.length);
	requestSize += svcRec->pdu.length;
	pduRequestHeader->paramLength = htons(requestSize - sizeof(sdp_hdr_t));

	status = sdp_send_req_w4_rsp(srvHandle, requestBuffer,
			responseBuffer, requestSize, &responseSize);

	if (status)
		goto exit;
	pduResponseHeader = (sdp_hdr_t *)responseBuffer;
	pdata = responseBuffer + sizeof(sdp_hdr_t);
	if ((pduResponseHeader->pduId == SDP_PDU_REG_RSP)) {
		svcRecHandle = ntohl(__get_u32(pdata));
		svcRec->serviceRecordHandle = svcRecHandle;
		sdp_append_attr(svcRec, SDP_ATTR_SERVICE_RECORD_HANDLE, sdp_put_u32(svcRecHandle));
		svcRec->state = SDP_STATE_REGISTERED;
	} else 	if (pduResponseHeader->pduId == SDP_PDU_ERROR_RSP)
		status = pduResponseHeader->data[0];
	else 
		status = SDP_ERR_SERVER;
exit:
	free(requestBuffer);
	free(responseBuffer);
	return status;
}

int sdp_delete_service(int srvHandle, sdpsvc_t *svcRec)
{
	char	*pdata;
	int	status = 0;
	char	*requestBuffer;
	char	*responseBuffer;
	int	requestSize = 0;
	int	responseSize = 0;

	sdp_hdr_t	*pduRequestHeader;
	sdp_hdr_t	*pduResponseHeader;

	uint32_t	svcRecHandle = 0;

	svcRecHandle = svcRec->serviceRecordHandle;
	if ((svcRecHandle == SDP_ATTR_SERVICE_RECORD_HANDLE) ||
			((svcRec->state != SDP_STATE_REGISTERED) &&
			 (svcRec->state != SDP_STATE_CREATED) && /* FIXME POPO TAROM */
			 (svcRec->state != SDP_STATE_UPDATE_READY)))
		return SDP_ERR_INVALID_ARG;

	requestBuffer = (char *)malloc(SDP_REQ_BUF_SIZE);
	if (!requestBuffer)
		return -1;
	responseBuffer = (char *)malloc(SDP_RSP_BUF_SIZE);
	if (!responseBuffer) {
		free(requestBuffer);
		return -1;
	}

	pduRequestHeader = (sdp_hdr_t *)requestBuffer;
	pduRequestHeader->pduId = SDP_PDU_REMOVE_REQ;
	pduRequestHeader->transactionId = htons(sdp_gen_trans());

	pdata = (char *)(requestBuffer + sizeof(sdp_hdr_t));
	requestSize = sizeof(sdp_hdr_t);                       
	__put_u32(pdata, htonl(svcRecHandle));
	requestSize += sizeof(uint32_t);

	pduRequestHeader->paramLength = htons(requestSize - sizeof(sdp_hdr_t));
	status = sdp_send_req_w4_rsp(srvHandle, requestBuffer,
			responseBuffer, requestSize, &responseSize);
	if (status)
		goto exit;
	pduResponseHeader = (sdp_hdr_t *)responseBuffer;
	if ((pduResponseHeader->pduId == SDP_PDU_REMOVE_RSP))
		svcRec->state = SDP_STATE_NOT_EXIST;
	else if (pduResponseHeader->pduId == SDP_PDU_ERROR_RSP)
		status = pduResponseHeader->data[0];
	else
		status = SDP_ERR_SERVER;
exit:
	free(requestBuffer);
	free(responseBuffer);
	return status;
}

int sdp_delete_service_handle(int srvHandle, uint32_t svcRecHandle)
{
	char	*pdata;
	int	status = 0;
	char	*requestBuffer;
	char	*responseBuffer;
	int	requestSize = 0;
	int	responseSize = 0;
	sdp_hdr_t	*pduRequestHeader;
	sdp_hdr_t	*pduResponseHeader;

	requestBuffer = (char *)malloc(SDP_REQ_BUF_SIZE);
	if (!requestBuffer)
		return -1;
	responseBuffer = (char *)malloc(SDP_RSP_BUF_SIZE);
	if (!responseBuffer) {
		free(requestBuffer);
		return -1;
	}

	pduRequestHeader = (sdp_hdr_t *)requestBuffer;
	pduRequestHeader->pduId = SDP_PDU_REMOVE_REQ;
	pduRequestHeader->transactionId = htons(sdp_gen_trans());

	pdata = (char *)(requestBuffer + sizeof(sdp_hdr_t));
	requestSize = sizeof(sdp_hdr_t);                       
	__put_u32(pdata, htonl(svcRecHandle));
	requestSize += sizeof(uint32_t);

	pduRequestHeader->paramLength = htons(requestSize - sizeof(sdp_hdr_t));
	status = sdp_send_req_w4_rsp(srvHandle, requestBuffer,
			responseBuffer, requestSize, &responseSize);
	if (status)
		goto exit;
	pduResponseHeader = (sdp_hdr_t *)responseBuffer;
	if ((pduResponseHeader->pduId == SDP_PDU_REMOVE_RSP))
		/* nothing */;
	else if (pduResponseHeader->pduId == SDP_PDU_ERROR_RSP)
		status = pduResponseHeader->data[0];
	else
		status = SDP_ERR_SERVER;
exit:
	free(requestBuffer);
	free(responseBuffer);
	return status;
}

int sdp_update_service(int srvHandle, sdpsvc_t *svcRec)
{
	char *pdata;
	int status = 0;
	char *requestBuffer;
	char *responseBuffer;
	int requestSize;
	int responseSize;
	sdp_hdr_t *pduRequestHeader;
	sdp_hdr_t *pduResponseHeader;
	uint32_t svcRecHandle;

	svcRecHandle = svcRec->serviceRecordHandle;
	if ((svcRecHandle == SDP_ATTR_SERVICE_RECORD_HANDLE) ||
			((svcRec->state != SDP_STATE_UPDATE_READY)))
		return SDP_ERR_INVALID_ARG;

	requestBuffer = (char *)malloc(SDP_REQ_BUF_SIZE);
	if (!requestBuffer)
		return -1;
	responseBuffer = (char *)malloc(SDP_RSP_BUF_SIZE);
	if (!responseBuffer) {
		free(requestBuffer);
		return -1;
	}
	pduRequestHeader = (sdp_hdr_t *)requestBuffer;
	pduRequestHeader->pduId = SDP_PDU_UPDATE_REQ;
	pduRequestHeader->transactionId = htons(sdp_gen_trans());

	pdata = (char *)(requestBuffer + sizeof(sdp_hdr_t));
	requestSize = sizeof(sdp_hdr_t);                       

	__put_u32(pdata, htonl(svcRecHandle));
	requestSize += sizeof(uint32_t);
	pdata += sizeof(uint32_t);

	sdp_gen_svc_pdu(svcRec);
	memcpy(pdata, svcRec->pdu.data, svcRec->pdu.length);
	requestSize += svcRec->pdu.length;

	pduRequestHeader->paramLength = htons(requestSize - sizeof(sdp_hdr_t));
	status = sdp_send_req_w4_rsp(srvHandle, requestBuffer,
			responseBuffer, requestSize, &responseSize);
	DBPRT("Send req status : %d\n", status);
	if (status)
		goto exit;
	pduResponseHeader = (sdp_hdr_t *)responseBuffer;
	if ((pduResponseHeader->pduId == SDP_PDU_UPDATE_RSP)) {
		svcRec->state = SDP_STATE_REGISTERED;
	} else 	if (pduResponseHeader->pduId == SDP_PDU_ERROR_RSP)
		status = pduResponseHeader->data[0];
	else
		status = SDP_ERR_SERVER;
exit:
	free(requestBuffer);
	free(responseBuffer);
	return status;
}

/* ------------------------------------------------------------------------ */

/*
 ** NOTE that none of the sdp_set_XXX() functions below will
 ** actually update the SDP server, unless the
 ** sdp_{register,update}_service() function is invoked.
 **
 */

void sdp_set_state(sdpsvc_t *svcRec)
{
	DBPRT("Internal state of svcRec : %d", svcRec->state);
	if (svcRec->state == SDP_STATE_CREATED) {
		if ((sdp_get_attr(svcRec, SDP_ATTR_SERVICE_CLASSID_LIST) != NULL) &&
				(sdp_get_attr(svcRec, SDP_ATTR_PROTO_DESC_LIST) != NULL)) {
			svcRec->state = SDP_STATE_REGISTER_READY;
			DBPRT("Internal state of svcRec reg ready : %d", svcRec->state);
		} else if (sdp_get_attr(svcRec, SDP_ATTR_GROUPID) != NULL) {
			/*
			 ** This could be a browse group descriptor, which
			 ** need not contain mandatory attributes
			 */
			svcRec->state = SDP_STATE_REGISTER_READY;
			DBPRT("Internal state of svcRec reg ready : %d", svcRec->state);
		}
	} else if (svcRec->state == SDP_STATE_REGISTERED) {
		svcRec->state = SDP_STATE_UPDATE_READY;
	}
}

int sdp_set_info_attr(sdpsvc_t *svcRec, char *name, char *prov, char *desc) {
	if (!svcRec || (svcRec->state == SDP_STATE_NOT_EXIST))
		return -1;
	sdp_append_attr(svcRec, SDP_ATTR_SERVICE_NAME_PRIM, sdp_put_str(name));
	sdp_append_attr(svcRec, SDP_ATTR_PROVIDER_NAME_PRIM, sdp_put_str(prov));
	sdp_append_attr(svcRec, SDP_ATTR_SERVICE_DESC_PRIM, sdp_put_str(desc));
	sdp_set_state(svcRec);
	return 0;
}


sdpdata_t *sdp_set_class_attr(sdpsvc_t *svc)
{
	return sdp_append_attr(svc, SDP_ATTR_SERVICE_CLASSID_LIST, sdp_create_seq());
}

sdpdata_t *sdp_add_class(sdpdata_t *attr, uint16_t uuid)
{
	return sdp_append_uuid16(attr, uuid);
}


sdpdata_t *sdp_set_subgroup_attr(sdpsvc_t *svc)