mirror/btstack
1
0
Fork 0
mirror of https://github.com/bluekitchen/btstack.git synced 2025-04-15 14:42:31 +00:00
Code Issues Packages Projects Releases Wiki Activity

goep_server: basis for pbap_server and others

Browse Source
This commit is contained in:
Matthias Ringwald 2022-04-05 18:23:47 +02:00
parent b8c00949e5
commit 3a22aa8134
3 changed files with 712 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/btstack.h
View File

@ -132,6 +132,7 @@
#include "classic/device_id_server.h"
#include "classic/gatt_sdp.h"
#include "classic/goep_client.h"
#include "classic/goep_server.h"
#include "classic/hfp.h"
#include "classic/hfp_ag.h"
#include "classic/hfp_hf.h"

609
src/classic/goep_server.c Normal file
View File

@ -0,0 +1,609 @@
/*
* Copyright (C) 2019 BlueKitchen GmbH
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the copyright holders nor the names of
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
* 4. Any redistribution, use, or modification is done solely for
* personal benefit and not for any commercial purpose or for
* monetary gain.
*
* THIS SOFTWARE IS PROVIDED BY BLUEKITCHEN GMBH AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL MATTHIAS
* RINGWALD OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
* THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* Please inquire about commercial licensing options at
* contact@bluekitchen-gmbh.com
*
*/
#define BTSTACK_FILE__ "goep_server.c"
#include "btstack_config.h"
#include <stdint.h>
#include <string.h>
#include "hci_cmd.h"
#include "btstack_debug.h"
#include "btstack_defines.h"
#include "hci.h"
#include "btstack_memory.h"
#include "hci_dump.h"
#include "btstack_event.h"
#include "classic/goep_server.h"
#ifdef ENABLE_GOEP_L2CAP
#include "l2cap.h"
#include "obex_message_builder.h"
static l2cap_ertm_config_t ertm_config = {
1, // ertm mandatory
2, // max transmit, some tests require > 1
2000,
12000,
(GOEP_SERVER_ERTM_BUFFER / 2), // l2cap ertm mtu
2,
2,
1, // 16-bit FCS
};
static uint8_t goep_server_l2cap_packet_buffer[1000];
#endif
static btstack_linked_list_t goep_server_connections = NULL;
static btstack_linked_list_t goep_server_services = NULL;
static uint16_t goep_server_cid_counter = 0;
static goep_server_service_t * goep_server_get_service_for_rfcomm_channel(uint8_t rfcomm_channel){
btstack_linked_item_t *it;
for (it = (btstack_linked_item_t *) goep_server_services; it ; it = it->next){
goep_server_service_t * service = ((goep_server_service_t *) it);
if (service->rfcomm_channel == rfcomm_channel){
return service;
};
}
return NULL;
}
static goep_server_service_t * goep_server_get_service_for_l2cap_psm(uint16_t l2cap_psm){
btstack_linked_item_t *it;
for (it = (btstack_linked_item_t *) goep_server_services; it ; it = it->next){
goep_server_service_t * service = ((goep_server_service_t *) it);
if (service->l2cap_psm == l2cap_psm){
return service;
};
}
return NULL;
}
static goep_server_connection_t * goep_server_get_connection_for_rfcomm_cid(uint16_t bearer_cid){
btstack_linked_item_t *it;
for (it = (btstack_linked_item_t *) goep_server_connections; it ; it = it->next){
goep_server_connection_t * connection = ((goep_server_connection_t *) it);
if (connection->type != GOEP_CONNECTION_RFCOMM) continue;
if (connection->bearer_cid == bearer_cid){
return connection;
};
}
return NULL;
}
static goep_server_connection_t * goep_server_get_connection_for_l2cap_cid(uint16_t bearer_cid){
btstack_linked_item_t *it;
for (it = (btstack_linked_item_t *) goep_server_connections; it ; it = it->next){
goep_server_connection_t * connection = ((goep_server_connection_t *) it);
if (connection->type != GOEP_CONNECTION_L2CAP) continue;
if (connection->bearer_cid == bearer_cid){
return connection;
};
}
return NULL;
}
static goep_server_connection_t * goep_server_get_connection_for_goep_cid(uint16_t goep_cid){
btstack_linked_item_t *it;
for (it = (btstack_linked_item_t *) goep_server_connections; it ; it = it->next){
goep_server_connection_t * connection = ((goep_server_connection_t *) it);
if (connection->goep_cid == goep_cid){
return connection;
};
}
return NULL;
}
static uint16_t goep_server_get_next_goep_cid(void){
goep_server_cid_counter++;
if (goep_server_cid_counter == 0){
goep_server_cid_counter = 1;
}
return goep_server_cid_counter;
}
static inline void goep_server_emit_connection_opened(btstack_packet_handler_t callback, uint16_t goep_cid, bd_addr_t bd_addr, hci_con_handle_t con_handle, uint8_t status){
uint8_t event[15];
uint16_t pos = 0;
event[pos++] = HCI_EVENT_GOEP_META;
event[pos++] = 15 - 2;
event[pos++] = GOEP_SUBEVENT_CONNECTION_OPENED;
little_endian_store_16(event, pos, goep_cid);
pos+=2;
event[pos++] = status;
memcpy(&event[pos], bd_addr, 6);
pos += 6;
little_endian_store_16(event, pos, con_handle);
pos += 2;
event[pos++] = 1;
btstack_assert(pos == sizeof(event));
callback(HCI_EVENT_PACKET, goep_cid, &event[0], pos);
}
static inline void goep_server_emit_connection_closed(btstack_packet_handler_t callback, uint16_t goep_cid){
uint8_t event[5];
uint16_t pos = 0;
event[pos++] = HCI_EVENT_GOEP_META;
event[pos++] = 5 - 3;
event[pos++] = GOEP_SUBEVENT_CONNECTION_CLOSED;
little_endian_store_16(event, pos, goep_cid);
pos += 2;
btstack_assert(pos == sizeof(event));
callback(HCI_EVENT_PACKET, goep_cid, &event[0], pos);
}
static inline void goep_server_emit_can_send_now_event(goep_server_connection_t * connection){
uint8_t event[5];
uint16_t pos = 0;
event[pos++] = HCI_EVENT_GOEP_META;
event[pos++] = 5 - 3;
event[pos++] = GOEP_SUBEVENT_CAN_SEND_NOW;
little_endian_store_16(event,pos,connection->goep_cid);
pos += 2;
btstack_assert(pos == sizeof(event));
connection->callback(HCI_EVENT_PACKET, connection->goep_cid, &event[0], pos);
}
static void goep_server_handle_connection_opened(goep_server_connection_t * context, bd_addr_t addr, hci_con_handle_t con_handle, uint8_t status, uint16_t bearer_cid, uint16_t bearer_mtu){
uint16_t goep_cid = context->goep_cid;
btstack_packet_handler_t packet_handler = context->callback;
if (status) {
log_info("goep_client: open failed, status %u", status);
btstack_linked_list_remove(&goep_server_connections, (btstack_linked_item_t *) context);
btstack_memory_goep_server_connection_free(context);
} else {
// context->bearer_mtu = mtu;
context->state = GOEP_SERVER_CONNECTED;
context->bearer_cid = bearer_cid;
#ifdef ENABLE_GOEP_L2CAP
if (context->type == GOEP_CONNECTION_L2CAP){
bearer_mtu = btstack_min(bearer_mtu, sizeof(goep_server_l2cap_packet_buffer));
}
#endif
context->bearer_mtu = bearer_mtu;
log_info("goep_server: connection opened. cid %u, max frame size %u", context->bearer_cid, bearer_mtu);
}
goep_server_emit_connection_opened(packet_handler, goep_cid, addr, con_handle, status);
}
static void goep_server_handle_connection_closed(goep_server_connection_t * goep_connection){
uint16_t goep_cid = goep_connection->goep_cid;
btstack_packet_handler_t packet_handler = goep_connection->callback;
btstack_linked_list_remove(&goep_server_connections, (btstack_linked_item_t *) goep_connection);
btstack_memory_goep_server_connection_free(goep_connection);
goep_server_emit_connection_closed(packet_handler, goep_cid);
}
#ifdef ENABLE_GOEP_L2CAP
static void goep_server_packet_handler_l2cap(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
UNUSED(channel);
UNUSED(size);
bd_addr_t event_addr;
uint16_t l2cap_psm;
uint16_t l2cap_cid;
goep_server_connection_t * goep_connection;
goep_server_service_t * goep_service;
switch (packet_type){
case HCI_EVENT_PACKET:
switch (hci_event_packet_get_type(packet)) {
case L2CAP_EVENT_INCOMING_CONNECTION:
l2cap_psm = l2cap_event_incoming_connection_get_psm(packet);
l2cap_cid = l2cap_event_incoming_connection_get_local_cid(packet);
goep_service = goep_server_get_service_for_l2cap_psm(l2cap_psm);
if (!goep_service){
l2cap_decline_connection(l2cap_cid);
break;
}
// alloc structure
goep_connection = btstack_memory_goep_server_connection_get();
if (!goep_connection){
l2cap_decline_connection(l2cap_cid);
break;
}
// setup connection
goep_connection->goep_cid = goep_server_get_next_goep_cid();
goep_connection->bearer_cid = l2cap_cid;
goep_connection->callback = goep_service->callback;
goep_connection->type = GOEP_CONNECTION_L2CAP;
goep_connection->state = GOEP_SERVER_W4_CONNECTED;
btstack_linked_list_add(&goep_server_connections, (btstack_linked_item_t *) goep_connection);
l2cap_ertm_accept_connection(l2cap_cid, &ertm_config, goep_connection->ertm_buffer, GOEP_SERVER_ERTM_BUFFER);
break;
case L2CAP_EVENT_CHANNEL_OPENED:
l2cap_cid = l2cap_event_channel_opened_get_local_cid(packet);
goep_connection = goep_server_get_connection_for_l2cap_cid(l2cap_cid);
btstack_assert(goep_connection != NULL);
btstack_assert(goep_connection->state == GOEP_SERVER_W4_CONNECTED);
l2cap_event_channel_opened_get_address(packet, event_addr);
goep_server_handle_connection_opened(goep_connection, event_addr,
l2cap_event_channel_opened_get_handle(packet),
l2cap_event_channel_opened_get_status(packet),
l2cap_cid,
l2cap_event_channel_opened_get_remote_mtu(packet) );
return;
case L2CAP_EVENT_CAN_SEND_NOW:
l2cap_cid = l2cap_event_can_send_now_get_local_cid(packet);
goep_connection = goep_server_get_connection_for_l2cap_cid(l2cap_cid);
btstack_assert(goep_connection != NULL);
goep_server_emit_can_send_now_event(goep_connection);
break;
case L2CAP_EVENT_CHANNEL_CLOSED:
l2cap_cid = l2cap_event_channel_closed_get_local_cid(packet);
goep_connection = goep_server_get_connection_for_l2cap_cid(l2cap_cid);
btstack_assert(goep_connection != NULL);
goep_server_handle_connection_closed(goep_connection);
break;
default:
break;
}
break;
case L2CAP_DATA_PACKET:
goep_connection = goep_server_get_connection_for_l2cap_cid(channel);
btstack_assert(goep_connection != NULL);
goep_connection->callback(GOEP_DATA_PACKET, goep_connection->goep_cid, packet, size);
break;
default:
break;
}
}
#endif
static void goep_server_packet_handler_rfcomm(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
UNUSED(channel);
UNUSED(size);
bd_addr_t event_addr;
uint8_t rfcomm_channel;
uint16_t rfcomm_cid;
goep_server_service_t * goep_service;
goep_server_connection_t * goep_connection;
switch (packet_type){
case HCI_EVENT_PACKET:
switch (hci_event_packet_get_type(packet)) {
case RFCOMM_EVENT_INCOMING_CONNECTION:
rfcomm_channel = rfcomm_event_incoming_connection_get_server_channel(packet);
rfcomm_cid = rfcomm_event_incoming_connection_get_rfcomm_cid(packet);
goep_service = goep_server_get_service_for_rfcomm_channel(rfcomm_channel);
if (!goep_service){
rfcomm_decline_connection(rfcomm_cid);
break;
}
// alloc structure
goep_connection = btstack_memory_goep_server_connection_get();
if (!goep_connection){
rfcomm_decline_connection(rfcomm_cid);
break;
}
// setup connection
goep_connection->goep_cid = goep_server_get_next_goep_cid();
goep_connection->bearer_cid = rfcomm_cid;
goep_connection->callback = goep_service->callback;
goep_connection->type = GOEP_CONNECTION_RFCOMM;
goep_connection->state = GOEP_SERVER_W4_CONNECTED;
btstack_linked_list_add(&goep_server_connections, (btstack_linked_item_t *) goep_connection);
rfcomm_accept_connection(rfcomm_cid);
break;
case RFCOMM_EVENT_CHANNEL_OPENED:
rfcomm_cid = rfcomm_event_channel_opened_get_rfcomm_cid(packet);
goep_connection = goep_server_get_connection_for_rfcomm_cid(rfcomm_cid);
btstack_assert(goep_connection != NULL);
btstack_assert(goep_connection->state == GOEP_SERVER_W4_CONNECTED);
rfcomm_event_channel_opened_get_bd_addr(packet, event_addr);
goep_server_handle_connection_opened(goep_connection, event_addr,
rfcomm_event_channel_opened_get_con_handle(packet),
rfcomm_event_channel_opened_get_status(packet),
rfcomm_cid,
rfcomm_event_channel_opened_get_max_frame_size(packet) );
break;
case RFCOMM_EVENT_CAN_SEND_NOW:
rfcomm_cid = rfcomm_event_can_send_now_get_rfcomm_cid(packet);
goep_connection = goep_server_get_connection_for_rfcomm_cid(rfcomm_cid);
btstack_assert(goep_connection != NULL);
goep_server_emit_can_send_now_event(goep_connection);
break;
case RFCOMM_EVENT_CHANNEL_CLOSED:
rfcomm_cid = rfcomm_event_channel_closed_get_rfcomm_cid(packet);
goep_connection = goep_server_get_connection_for_rfcomm_cid(rfcomm_cid);
btstack_assert(goep_connection != NULL);
goep_server_handle_connection_closed(goep_connection);
break;
default:
break;
}
break;
case RFCOMM_DATA_PACKET:
goep_connection = goep_server_get_connection_for_rfcomm_cid(channel);
btstack_assert(goep_connection != NULL);
goep_connection->callback(GOEP_DATA_PACKET, goep_connection->goep_cid, packet, size);
break;
default:
break;
}
}
void goep_server_init(void){
}
uint8_t goep_server_register_service(btstack_packet_handler_t callback, uint8_t rfcomm_channel, uint16_t rfcomm_max_frame_size,
uint16_t l2cap_psm, uint16_t l2cap_mtu, gap_security_level_t security_level){
log_info("rfcomm_channel 0x%02x rfcomm_max_frame_size %u l2cap_psm 0x%02x l2cap_mtu %u",
rfcomm_channel, rfcomm_max_frame_size, l2cap_psm, l2cap_mtu);
// check if service is already registered
goep_server_service_t * service;
service = goep_server_get_service_for_rfcomm_channel(rfcomm_channel);
if (service != NULL) {
return RFCOMM_CHANNEL_ALREADY_REGISTERED;
}
#ifdef ENABLE_GOEP_L2CAP
if (l2cap_psm != 0){
service = goep_server_get_service_for_l2cap_psm(l2cap_psm);
if (service != NULL) {
return L2CAP_SERVICE_ALREADY_REGISTERED;
}
}
#endif
// alloc structure
service = btstack_memory_goep_server_service_get();
if (service == NULL) {
return BTSTACK_MEMORY_ALLOC_FAILED;
}
// fill in
service->callback = callback;
service->rfcomm_channel = rfcomm_channel;
service->l2cap_psm = l2cap_psm;
uint8_t status = ERROR_CODE_SUCCESS;
bool rfcomm_registered = false;
#ifdef ENABLE_GOEP_L2CAP
bool l2cap_registered = false;
// register with L2CAP
if (l2cap_psm != 0){
status = l2cap_register_service(goep_server_packet_handler_l2cap, l2cap_psm, l2cap_mtu, security_level);
if (status == ERROR_CODE_SUCCESS){
l2cap_registered = true;
}
}
#endif
// register with RFCOMM
if (status == ERROR_CODE_SUCCESS){
status = rfcomm_register_service(goep_server_packet_handler_rfcomm, rfcomm_channel, rfcomm_max_frame_size);
if (status == ERROR_CODE_SUCCESS){
rfcomm_registered = true;
}
}
// add service on success
if (status == ERROR_CODE_SUCCESS){
btstack_linked_list_add(&goep_server_services, (btstack_linked_item_t *) service);
return ERROR_CODE_SUCCESS;
}
// unrestore otherwise
btstack_memory_goep_server_service_free(service);
#ifdef ENABLE_GOEP_L2CAP
if (l2cap_registered){
l2cap_unregister_service(l2cap_psm);
}
#endif
if (rfcomm_registered){
rfcomm_unregister_service(rfcomm_channel);
}
return status;
}
uint8_t goep_server_request_can_send_now(uint16_t goep_cid){
goep_server_connection_t * connection = goep_server_get_connection_for_goep_cid(goep_cid);
if (connection == NULL){
return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
}
switch (connection->type){
case GOEP_CONNECTION_RFCOMM:
rfcomm_request_can_send_now_event(connection->bearer_cid);
break;
#ifdef ENABLE_GOEP_L2CAP
case GOEP_CONNECTION_L2CAP:
l2cap_request_can_send_now_event(connection->bearer_cid);
break;
#endif
default:
btstack_unreachable();
break;
}
return ERROR_CODE_SUCCESS;
}
static uint8_t * goep_server_get_outgoing_buffer(goep_server_connection_t * connection){
switch (connection->type){
#ifdef ENABLE_GOEP_L2CAP
case GOEP_CONNECTION_L2CAP:
return goep_server_l2cap_packet_buffer;
#endif
case GOEP_CONNECTION_RFCOMM:
return rfcomm_get_outgoing_buffer();
default:
btstack_unreachable();
return NULL;
}
}
static uint16_t goep_server_get_outgoing_buffer_len(goep_server_connection_t * connection){
return connection->bearer_mtu;
}
static void goep_server_packet_init(goep_server_connection_t * connection){
switch (connection->type){
#ifdef ENABLE_GOEP_L2CAP
case GOEP_CONNECTION_L2CAP:
break;
#endif
case GOEP_CONNECTION_RFCOMM:
rfcomm_reserve_packet_buffer();
break;
default:
btstack_unreachable();
break;
}
}
uint8_t goep_server_set_connection_id(uint16_t goep_cid, uint32_t connection_id){
goep_server_connection_t * connection = goep_server_get_connection_for_goep_cid(goep_cid);
if (connection == NULL) {
return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
}
connection->obex_connection_id = connection_id;
return ERROR_CODE_SUCCESS;
}
uint8_t goep_server_response_create_connect(uint16_t goep_cid, uint8_t obex_version_number, uint8_t flags, uint16_t maximum_obex_packet_length){
goep_server_connection_t * connection = goep_server_get_connection_for_goep_cid(goep_cid);
if (connection == NULL) {
return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
}
goep_server_packet_init(connection);
// workaround: limit OBEX packet len to L2CAP/RFCOMM MTU
maximum_obex_packet_length = btstack_min(maximum_obex_packet_length, connection->bearer_mtu);
uint8_t * buffer = goep_server_get_outgoing_buffer(connection);
uint16_t buffer_len = goep_server_get_outgoing_buffer_len(connection);
return obex_message_builder_response_create_connect(buffer, buffer_len, obex_version_number, flags, maximum_obex_packet_length, connection->obex_connection_id);
}
uint8_t goep_server_response_create_general(uint16_t goep_cid, uint8_t opcode){
goep_server_connection_t * connection = goep_server_get_connection_for_goep_cid(goep_cid);
if (connection == NULL) {
return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
}
goep_server_packet_init(connection);
uint8_t * buffer = goep_server_get_outgoing_buffer(connection);
uint16_t buffer_len = goep_server_get_outgoing_buffer_len(connection);
return obex_message_builder_response_create_general(buffer, buffer_len, opcode);
}
uint8_t goep_server_header_add_end_of_body(uint16_t goep_cid, const uint8_t * end_of_body, uint16_t length){
goep_server_connection_t * connection = goep_server_get_connection_for_goep_cid(goep_cid);
if (connection == NULL) {
return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
}
uint8_t * buffer = goep_server_get_outgoing_buffer(connection);
uint16_t buffer_len = goep_server_get_outgoing_buffer_len(connection);
return obex_message_builder_body_add_static(buffer, buffer_len, end_of_body, length);
}
uint8_t goep_server_header_add_who(uint16_t goep_cid, const uint8_t * target){
goep_server_connection_t * connection = goep_server_get_connection_for_goep_cid(goep_cid);
if (connection == NULL) {
return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
}
uint8_t * buffer = goep_server_get_outgoing_buffer(connection);
uint16_t buffer_len = goep_server_get_outgoing_buffer_len(connection);
return obex_message_builder_header_add_who(buffer, buffer_len, target);
}
uint8_t goep_server_header_add_srm_enable(uint16_t goep_cid){
goep_server_connection_t * connection = goep_server_get_connection_for_goep_cid(goep_cid);
if (connection == NULL) {
return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
}
uint8_t * buffer = goep_server_get_outgoing_buffer(connection);
uint16_t buffer_len = goep_server_get_outgoing_buffer_len(connection);
return obex_message_builder_header_add_srm_enable(buffer, buffer_len);
}
uint8_t goep_server_execute(uint16_t goep_cid){
goep_server_connection_t * connection = goep_server_get_connection_for_goep_cid(goep_cid);
if (connection == NULL) {
return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
}
uint8_t * buffer = goep_server_get_outgoing_buffer(connection);
uint16_t pos = big_endian_read_16(buffer, 1);
switch (connection->type) {
#ifdef ENABLE_GOEP_L2CAP
case GOEP_CONNECTION_L2CAP:
return l2cap_send(connection->bearer_cid, buffer, pos);
break;
#endif
case GOEP_CONNECTION_RFCOMM:
return rfcomm_send_prepared(connection->bearer_cid, pos);
break;
default:
btstack_unreachable();
return ERROR_CODE_SUCCESS;
}
}
void goep_server_deinit(void){
goep_server_cid_counter = 0;
goep_server_services = NULL;
}

109
src/classic/goep_server.h
View File

@ -45,17 +45,23 @@ extern "C" {
#include "btstack_config.h"
#include <stdint.h>
#ifdef ENABLE_GOEP_L2CAP
#ifndef GOEP_SERVER_ERTM_BUFFER
#define GOEP_SERVER_ERTM_BUFFER 1000
#endif
#endif
/* API_START */
typedef enum {
GOEP_SERVER_IDLE,
GOEP_SERVER_W4_RFCOMM_CONNECTED,
GOEP_SERVER_RFCOMM_CONNECTED
GOEP_SERVER_W4_CONNECTED,
GOEP_SERVER_CONNECTED
} goep_server_state_t;
typedef enum {
GOEP_L2CAP_CONNECTION = 0,
GOEP_RFCOMM_CONNECTION
GOEP_CONNECTION_RFCOMM = 0,
GOEP_CONNECTION_L2CAP,
} goep_connection_type_t;
typedef struct {
@ -71,12 +77,101 @@ typedef struct {
typedef struct {
// linked list - assert: first field
btstack_linked_item_t item;
uint16_t bearer_cid;
uint16_t goep_cid;
goep_connection_type_t type;
goep_server_service_t * service;
goep_server_state_t state;
goep_connection_type_t type;
uint16_t bearer_cid;
uint16_t bearer_mtu;
btstack_packet_handler_t callback;
uint32_t obex_connection_id;
#ifdef ENABLE_GOEP_L2CAP
uint8_t ertm_buffer[GOEP_SERVER_ERTM_BUFFER];
#endif
} goep_server_connection_t;
/**
* Init GOEP Server
*/
void goep_server_init(void);
/**
* Register OBEX Service
* @param packet_handler
* @param rfcomm_channel
* @param rfcomm_max_frame_size
* @param l2cap_psm
* @param l2cap_mtu
* @param security_level
* @return status
*/
uint8_t goep_server_register_service(btstack_packet_handler_t packet_handler, uint8_t rfcomm_channel, uint16_t rfcomm_max_frame_size,
uint16_t l2cap_psm, uint16_t l2cap_mtu, gap_security_level_t security_level);
/**
* Request GOEP_SUBEVENT_CAN_SEND_NOW
* @param goep_cid
* @return status
*/
uint8_t goep_server_request_can_send_now(uint16_t goep_cid);
/**
* @brief Set Connection ID used for newly created requests
* @param goep_cid
* @return status
*/
uint8_t goep_server_set_connection_id(uint16_t goep_cid, uint32_t connection_id);
/**
* @brief Start Connect response
* @param goep_cid
* @param obex_version_number
* @param flags
* @param maximum_obex_packet_length
* @return status
*/
uint8_t goep_server_response_create_connect(uint16_t goep_cid, uint8_t obex_version_number, uint8_t flags, uint16_t maximum_obex_packet_length);
/**
* @brief Start General response with opcode
* @param goep_cid
* @param opcode
* @return status
*/
uint8_t goep_server_response_create_general(uint16_t goep_cid, uint8_t opcode);
/**
* @brief Add who header to current response
* @param goep_cid
* @param who - 16 bytes
* @return status
*/
uint8_t goep_server_header_add_who(uint16_t goep_cid, const uint8_t * who);
/**
* @brief Add end_of_body header to current response
* @param goep_cid
* @param end_of_body
* @param length
* @return status
*/
uint8_t goep_server_header_add_end_of_body(uint16_t goep_cid, const uint8_t * end_of_body, uint16_t length);
/**
* @brief Execute prepared request
* @param goep_cid
* @return status
*/
uint8_t goep_server_execute(uint16_t goep_cid);
/**
* De-Init
*/
void geop_server_deinit(void);
/* API_END */
#if defined __cplusplus