haiku.git

/*
 * Copyright 2024, Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 */
#include "L2capEndpointManager.h"

#include <AutoDeleter.h>

#include <bluetooth/bdaddrUtils.h>


L2capEndpointManager gL2capEndpointManager;


L2capEndpointManager::L2capEndpointManager()
	:
	fNextChannelID(L2CAP_FIRST_CID)
{
	rw_lock_init(&fBoundEndpointsLock, "l2cap bound endpoints");
	rw_lock_init(&fChannelEndpointsLock, "l2cap channel endpoints");
}


L2capEndpointManager::~L2capEndpointManager()
{
	rw_lock_destroy(&fBoundEndpointsLock);
	rw_lock_destroy(&fChannelEndpointsLock);
}


status_t
L2capEndpointManager::Bind(L2capEndpoint* endpoint, const sockaddr_l2cap& address)
{
	// TODO: Support binding to specific addresses?
	if (!Bluetooth::bdaddrUtils::Compare(address.l2cap_bdaddr, BDADDR_ANY))
		return EINVAL;

	// PSM values must be odd.
	if ((address.l2cap_psm & 1) == 0)
		return EINVAL;

	WriteLocker _(fBoundEndpointsLock);

	if (fBoundEndpoints.Find(address.l2cap_psm) != NULL)
		return EADDRINUSE;

	memcpy(*endpoint->LocalAddress(), &address, sizeof(struct sockaddr_l2cap));
	fBoundEndpoints.Insert(endpoint);
	gSocketModule->acquire_socket(endpoint->socket);

	return B_OK;
}


status_t
L2capEndpointManager::Unbind(L2capEndpoint* endpoint)
{
	WriteLocker _(fBoundEndpointsLock);

	fBoundEndpoints.Remove(endpoint);
	(*endpoint->LocalAddress())->sa_len = 0;
	gSocketModule->release_socket(endpoint->socket);

	return B_OK;
}


L2capEndpoint*
L2capEndpointManager::ForPSM(uint16 psm)
{
	ReadLocker _(fBoundEndpointsLock);
	// TODO: Acquire reference?
	return fBoundEndpoints.Find(psm);
}


status_t
L2capEndpointManager::BindToChannel(L2capEndpoint* endpoint)
{
	WriteLocker _(fChannelEndpointsLock);

	for (uint16 i = 0; i < (L2CAP_LAST_CID - L2CAP_FIRST_CID); i++) {
		const uint16 cid = fNextChannelID;
		fNextChannelID++;
		if (fNextChannelID < L2CAP_FIRST_CID)
			fNextChannelID = L2CAP_FIRST_CID;

		if (fChannelEndpoints.Find(cid) != NULL)
			continue;

		endpoint->fChannelID = cid;
		fChannelEndpoints.Insert(endpoint);
		gSocketModule->acquire_socket(endpoint->socket);
		return B_OK;
	}

	return EADDRINUSE;
}


status_t
L2capEndpointManager::UnbindFromChannel(L2capEndpoint* endpoint)
{
	WriteLocker _(fChannelEndpointsLock);

	fChannelEndpoints.Remove(endpoint);
	endpoint->fChannelID = 0;
	gSocketModule->release_socket(endpoint->socket);

	return B_OK;
}


L2capEndpoint*
L2capEndpointManager::ForChannel(uint16 cid)
{
	ReadLocker _(fChannelEndpointsLock);
	// TODO: Acquire reference?
	return fChannelEndpoints.Find(cid);
}


void
L2capEndpointManager::Disconnected(HciConnection* connection)
{
	ReadLocker _(fChannelEndpointsLock);
	auto iter = fChannelEndpoints.GetIterator();
	while (iter.HasNext()) {
		L2capEndpoint* endpoint = iter.Next();
		if (endpoint->fConnection != connection)
			continue;

		endpoint->fConnection = NULL;
		endpoint->fState = L2capEndpoint::CLOSED;
	}
}