diff options
| -rw-r--r-- | hcid/dbus-sdp.c | 1125 |
1 files changed, 588 insertions, 537 deletions
diff --git a/hcid/dbus-sdp.c b/hcid/dbus-sdp.c index 2cfd687c..fe3ad04a 100644 --- a/hcid/dbus-sdp.c +++ b/hcid/dbus-sdp.c @@ -50,18 +50,17 @@ #include "hcid.h" #include "textfile.h" -#define SDP_UUID_SEQ_SIZE 256 -#define SDP_MAX_ATTR_LEN 65535 - +#define MAX_IDENTIFIER_LEN 24 struct service_provider { char *owner; /* null for remote services or unique name if local */ - bdaddr_t prov; /* remote Bluetooth address or local address */ + char *prov; /* remote Bluetooth address thar provides the service */ + int ttl; /* time to live */ struct slist *lrec; }; struct service_record { - uint32_t identifier; + int id; sdp_record_t *record; }; @@ -69,59 +68,114 @@ struct pending_connect { DBusConnection *conn; DBusMessage *rq; char *svc; - bdaddr_t dba; + char *dst; }; struct transaction_context { DBusConnection *conn; DBusMessage *rq; - char *svc; sdp_session_t *session; - sdp_cstate_t *cstate; - uint8_t *reqbuf; - bdaddr_t dba; - sdp_buf_t rspbuf; - uint32_t reqsize; - int attr_list_len; +}; +/* FIXME: move to a common file */ +typedef struct { + char *name; + uint16_t class; + char *info_name; +} sdp_service_t; + +/* FIXME: move to a common file */ +sdp_service_t sdp_service[] = { + { "vcp", VIDEO_CONF_SVCLASS_ID, NULL }, + { "map", 0, NULL }, + { "pbap", 0, NULL }, + { "sap", SAP_SVCLASS_ID, "SIM Access" }, + { "ftp", OBEX_FILETRANS_SVCLASS_ID, "OBEX File Transfer" }, + { "bpp", DIRECT_PRINTING_SVCLASS_ID, "Direct Printing" }, + { "bip", 0, NULL }, + { "synch", 0, NULL }, + { "dun", DIALUP_NET_SVCLASS_ID, "Dial-Up Networking" }, + { "opp", OBEX_OBJPUSH_SVCLASS_ID, "OBEX Object Push" }, + { "fax", FAX_SVCLASS_ID, "Fax" }, + { "spp", SERIAL_PORT_SVCLASS_ID, "Serial Port" }, + { NULL } }; -/* FIXME: store the arguments or just the pointer to the message */ +/* FIXME: move to a common file */ +uint16_t sdp_str2svclass(const char *str) +{ + sdp_service_t *s; -/* list of remote and local service records - * FIXME: free the cache when the local sock(sdpd) is closed - */ + for (s = sdp_service; s->name; s++) { + if (strcasecmp(s->name, str) == 0) + return s->class; + } -static struct slist *sdp_cache = NULL; -static struct slist *pending_connects = NULL; + return 0; +} -static const char *ecode2str(uint16_t ecode) +/* FIXME: move to a common file */ +const char* sdp_svclass2str(uint16_t class) { - switch (ecode) { - case 0x0000: - return "Reserved"; - case 0x0001: - return "Invalid/Unsupported SDP version"; - case 0x0002: - return "Invalid Service Record Handle"; - case 0x0003: - return "Invalid request syntax"; - case 0x0004: - return "Invalid PDU size"; - case 0x0005: - return "Invalid Continuation State"; - case 0x0006: - return "Insufficient Resources to satisfy Request"; - default: - return "Reserved"; + sdp_service_t *s; + + for (s = sdp_service; s->name; s++) { + if (s->class == class) + return s->name; } + + return NULL; } +/* FIXME: stub for bluez-libs changes */ +static inline sdp_session_t *sdp_session_new(int sk) +{ + errno = ENOSYS; + return NULL; +} + +/* FIXME: stub for bluez-libs changes */ +static inline int sdp_service_search_handle(sdp_session_t *session) +{ + return ENODATA; +} + +/* FIXME: stub for bluez-libs changes */ +typedef void sdp_transaction_cb_t(sdp_list_t *rsp, void *udata, int err); +static inline int sdp_service_search_attr_req_async(sdp_session_t *session, const sdp_list_t *search, + sdp_transaction_cb_t *f, void *udata) +{ + return 0; +} + +/* FIXME: stub for service registration. Shared with sdptool */ +static inline sdp_record_t *sdp_service_register(const char *name, bdaddr_t *interface, + uint8_t channel, int *err) +{ + if (err) + *err = ENOSYS; + + return NULL; +} + +/* FIXME: stub for service registration. Shared with sdptool */ +static inline int sdp_service_unregister(bdaddr_t *interface, sdp_record_t *rec, int *err) +{ + if (err) + *err = ENOSYS; + + return -1; +} + +/* list of remote and local service records */ +static struct slist *sdp_cache = NULL; +static struct slist *pending_connects = NULL; + static struct pending_connect *pending_connect_new(DBusConnection *conn, DBusMessage *msg, - const bdaddr_t *bda, const char *svc) + const char *dst, const char *svc) { struct pending_connect *c; - if (!bda) + if (!dst) return NULL; c = malloc(sizeof(*c)); @@ -131,18 +185,26 @@ static struct pending_connect *pending_connect_new(DBusConnection *conn, DBusMes if (svc) { c->svc = strdup(svc); if (!c->svc) - goto failed; + goto fail; + } + if (dst) { + c->dst = strdup(dst); + if (!c->dst) + goto fail; } - bacpy(&c->dba, bda); c->conn = dbus_connection_ref(conn); c->rq = dbus_message_ref(msg); return c; -failed: - if (c) - free(c); +fail: + if (c->svc) + free(c->svc); + if (c->dst) + free(c->dst); + free(c); + return NULL; } @@ -163,237 +225,120 @@ static void pending_connect_free(struct pending_connect *c) free(c); } -static struct pending_connect *find_pending_connect(const bdaddr_t *bda) +static struct pending_connect *find_pending_connect(const char *dst) { struct slist *l; for (l = pending_connects; l != NULL; l = l->next) { struct pending_connect *pending = l->data; - if (!bacmp(bda, &pending->dba)) + if (!strcmp(dst, pending->dst)) return pending; } return NULL; } -/* FIXME: duplicated function. Make this function public on bluez-libs */ -static int gen_dataseq_pdu(uint8_t *dst, const sdp_list_t *seq, uint8_t dtd) -{ - sdp_data_t *dataseq; - void **types, **values; - sdp_buf_t buf; - int i, seqlen = sdp_list_len(seq); - - // Fill up the value and the dtd arrays - memset(&buf, 0, sizeof(sdp_buf_t)); - buf.data = malloc(SDP_UUID_SEQ_SIZE); - buf.buf_size = SDP_UUID_SEQ_SIZE; - - types = malloc(seqlen * sizeof(void *)); - values = malloc(seqlen * sizeof(void *)); - for (i = 0; i < seqlen; i++) { - void *data = seq->data; - types[i] = &dtd; - if (SDP_IS_UUID(dtd)) - data = &((uuid_t *)data)->value; - values[i] = data; - seq = seq->next; - } - - dataseq = sdp_seq_alloc(types, values, seqlen); - seqlen = sdp_gen_pdu(&buf, dataseq); - memcpy(dst, buf.data, buf.data_size); - sdp_data_free(dataseq); - - free(types); - free(values); - free(buf.data); - return seqlen; -} - -/* FIXME: duplicated function */ -static int gen_searchseq_pdu(uint8_t *dst, const sdp_list_t *seq) -{ - uuid_t *uuid = (uuid_t *) seq->data; - return gen_dataseq_pdu(dst, seq, uuid->type); -} - -/* FIXME: duplicated function */ -static int gen_attridseq_pdu(uint8_t *dst, const sdp_list_t *seq, uint8_t dataType) -{ - return gen_dataseq_pdu(dst, seq, dataType); -} - -struct transaction_context *transaction_context_new(DBusConnection *conn, DBusMessage *msg, bdaddr_t *dba, - const char *svc, int sock, uint32_t flags) -{ - struct transaction_context *ctxt; - sdp_pdu_hdr_t *reqhdr; - sdp_list_t *pattern = NULL; - sdp_list_t *attrids = NULL; - uint8_t *pdata; - uuid_t uuid; - uint32_t range = 0x0000ffff; - int seqlen; - - ctxt = malloc(sizeof(*ctxt)); - if (!ctxt) - return NULL; - - memset(ctxt, 0, sizeof(*ctxt)); - - if (svc) { - ctxt->svc = strdup(svc); - if (!ctxt->svc) - goto failed; - } - - if (dba) - bacpy(&ctxt->dba, dba); - - ctxt->session = malloc(sizeof(sdp_session_t)); - if (!ctxt->session) - goto failed; - - memset(ctxt->session, 0, sizeof(sdp_session_t)); - - ctxt->conn = dbus_connection_ref(conn); - ctxt->rq = dbus_message_ref(msg); - ctxt->session->sock = sock; - ctxt->session->flags = flags; - - ctxt->reqbuf = malloc(SDP_REQ_BUFFER_SIZE); - if (!ctxt->reqbuf) - goto failed; - - memset(ctxt->reqbuf, 0, SDP_REQ_BUFFER_SIZE); - - reqhdr = (sdp_pdu_hdr_t *) ctxt->reqbuf; - - reqhdr->pdu_id = SDP_SVC_SEARCH_ATTR_REQ; - reqhdr->tid = 0; - - // Generate PDU - pdata = ctxt->reqbuf + sizeof(sdp_pdu_hdr_t); - ctxt->reqsize = sizeof(sdp_pdu_hdr_t); - - /* FIXME: it should be generic to handle other kind of search requests */ - sdp_uuid16_create(&uuid, PUBLIC_BROWSE_GROUP); - pattern = sdp_list_append(0, &uuid); - attrids = sdp_list_append(0, &range); - - seqlen = gen_searchseq_pdu(pdata, pattern); - - // set the length and increment the pointer - ctxt->reqsize += seqlen; - pdata +=seqlen; - - bt_put_unaligned(htons(SDP_MAX_ATTR_LEN), (uint16_t *) pdata); - ctxt->reqsize += sizeof(uint16_t); - pdata += sizeof(uint16_t); - - if (attrids) { - seqlen = gen_attridseq_pdu(pdata, attrids, SDP_UINT32); - if (seqlen == -1) - goto failed; - - } - if (pattern) - sdp_list_free(pattern, 0); - if (attrids) - sdp_list_free(attrids, 0); - - pdata += seqlen; - ctxt->reqsize += seqlen; - - reqhdr->plen = htons(ctxt->reqsize - sizeof(sdp_pdu_hdr_t)); - - return ctxt; - -failed: - if (ctxt->session) - free(ctxt->session); - if (ctxt->reqbuf) - free(ctxt->reqbuf); - free(ctxt); - - return NULL; -} - -void transaction_context_free(struct transaction_context *ctxt) +static int str2identifier(const char *identifier, char *address, int *id) { - if (!ctxt) - return; - - if (ctxt->conn) - dbus_connection_unref(ctxt->conn); - - if (ctxt->rq) - dbus_message_unref(ctxt->rq); - - if (ctxt->svc) - free(ctxt->svc); + if (!identifier || !address) + return -1; - if (ctxt->session) - free(ctxt->session); + if (strlen(identifier) < 19) + return -1; - if (ctxt->reqbuf) - free(ctxt->reqbuf); + memset(address, 0, 18); - if (ctxt->rspbuf.data) - free(ctxt->rspbuf.data); + snprintf(address, 18, "%s", identifier); - free(ctxt); + return (sscanf(identifier + 18, "%d", id) > 0? 0: -1); } -/* FIXME: generate the pseudo random id */ -static uint32_t gen_next_id(const bdaddr_t *prov, uint32_t handle) +static inline int gen_next_record_id() { - static uint32_t id; - return ++id; + static int id = 0; + return id++; } -static struct service_record *service_record_new(const bdaddr_t *prov, sdp_record_t *rec) +static struct service_record *service_record_new(sdp_record_t *rec) { struct service_record *r; - - if (!prov) - return NULL; r = malloc(sizeof(*r)); if (!r) return NULL; memset(r, 0, sizeof(*r)); - r->identifier = gen_next_id(prov, rec->handle); + r->id = gen_next_record_id(); r->record = rec; return r; } -static void service_record_free(struct service_record *r, void *data) +static void service_record_free(void *data, void *udata) { + struct service_record *r = data; + if (!r) return; - sdp_record_free(r->record); + if (r->record) + sdp_record_free(r->record); + free(r); } -static void service_provider_free(struct service_provider *p) +/* + * This function doesn't check service record pattern + */ +static int service_record_cmp(const void *data, const void *udata) { - if (p->owner) - free(p->owner); + const struct service_record *a = data; + const struct service_record *b = udata; + if (b->id >= 0) { + if (a->id != b->id) + return -1; + } - if (p->lrec) { - slist_foreach(p->lrec, (slist_func_t)service_record_free, NULL); - slist_free(p->lrec); + if (b->record) { + if (b->record->handle != 0xffffffff && + b->record->handle != a->record->handle) + return -1; } - free(p); + return 0; } -static struct service_provider *service_provider_new(const char *owner, const bdaddr_t *prov) +static void service_provider_free(void *data, void *udata) +{ + struct service_provider *p1 = data; + struct service_provider *p2 = udata; + + if (!p1) + return; + + /* Check if the provider match */ + if (p2) { + if (p2->owner && strcmp(p2->owner, p1->owner)) + return; + if (p2->prov && strcmp(p2->prov, p1->prov)) + return; + } + + if (p1->owner) + free(p1->owner); + + if (p1->prov) + free(p1->prov); + + if (p1->lrec) { + slist_foreach(p1->lrec, service_record_free, NULL); + slist_free(p1->lrec); + } + + free(p1); +} + +static struct service_provider *service_provider_new(const char *owner, const char *prov) { struct service_provider *p; @@ -411,19 +356,25 @@ static struct service_provider *service_provider_new(const char *owner, const bd goto fail; } - bacpy(&p->prov, prov); + if (prov) { + p->prov = strdup(prov); + if (!p->prov) + goto fail; + } return p; fail: - service_provider_free(p); + service_provider_free(p, NULL); return NULL; } -static int service_provider_cmp(const struct service_provider *a, const struct service_provider *b) +static int service_provider_cmp(const void *data, const void *udata) { + const struct service_provider *a = data; + const struct service_provider *b = udata; int ret; - + if (b->owner) { if (!a->owner) return -1; @@ -432,10 +383,10 @@ static int service_provider_cmp(const struct service_provider *a, const struct s return ret; } - if (bacmp(&b->prov, BDADDR_ANY)) { - if (!bacmp(&a->prov, BDADDR_ANY)) + if (b->prov) { + if (!a->prov) return -1; - ret = bacmp(&a->prov, &b->prov); + ret = strcmp(a->prov, b->prov); if (ret) return ret; } @@ -443,158 +394,98 @@ static int service_provider_cmp(const struct service_provider *a, const struct s return 0; } -static uint32_t sdp_cache_append(const char *owner, const bdaddr_t *prov, sdp_record_t *rec) +static int sdp_cache_append(const char *owner, const char *prov, sdp_record_t *rec) { - struct slist *l; + struct slist *lp, *lr; struct service_provider *p; - struct service_provider *ref; + struct service_provider psearch; struct service_record *r; - - if (!prov || !rec) - return 0; - ref = service_provider_new(owner, prov); - if (!ref) - return 0; + if (!prov || !rec) + return -1; - l = slist_find(sdp_cache, (const void*)ref, (cmp_func_t)service_provider_cmp); - if (!l) { + memset(&psearch, 0, sizeof(psearch)); + psearch.owner = (char *)owner; + psearch.prov = (char *)prov; + + lp = slist_find(sdp_cache, &psearch, service_provider_cmp); + if (!lp) { p = service_provider_new(owner, prov); sdp_cache = slist_append(sdp_cache, p); } else - p = l->data; - - r = service_record_new(prov, rec); - p->lrec = slist_append(p->lrec, r); + p = lp->data; - if (ref) - service_provider_free(ref); + /* check if there is service record already belongs to the cache */ + r = malloc(sizeof(*r)); + memset(r, 0, sizeof(*r)); + r->id = -1; + r->record = sdp_record_alloc(); + r->record->handle = rec->handle; + lr = slist_find(p->lrec, r, service_record_cmp); + service_record_free(r, NULL); + + if (lr) { + /* overwrite the record instead of compare */ + r = lr->data; + sdp_record_free(r->record); + r->record = rec; + } else { + /* create a new entry */ + r = service_record_new(rec); + p->lrec = slist_append(p->lrec, r); + } - return r->identifier; + return r->id; } static void owner_exited(const char *owner, struct hci_dbus_data *dbus_data) { - struct slist *cur, *next; - + struct slist *lp, *next, *lr; + struct service_provider *p; + bdaddr_t sba; + int err = 0; debug("SDP provider owner %s exited", owner); - for (cur = sdp_cache; cur != NULL; cur = next) { - struct service_provider *p = cur->data; - - next = cur->next; + for (lp = sdp_cache; lp; lp = next) { - if(!p->owner) - continue; - - if (strcmp(p->owner, owner)) + next = lp->next; + p = lp->data; + + if (!p->owner || strcmp(p->owner, owner)) continue; - sdp_cache = slist_remove(sdp_cache, p); - service_provider_free(p); - } -} - -/* FIXME: duplicated function */ -static int copy_cstate(uint8_t *pdata, const sdp_cstate_t *cstate) -{ - if (cstate) { - *pdata++ = cstate->length; - memcpy(pdata, cstate->data, cstate->length); - return cstate->length + 1; - } - *pdata = 0; - return 1; -} - -static int sdp_send_req(struct transaction_context *ctxt, int *err) -{ - sdp_pdu_hdr_t *reqhdr = (sdp_pdu_hdr_t *) ctxt->reqbuf; - uint32_t sent = 0; - uint32_t reqsize; - - reqhdr->tid = htons(sdp_gen_tid(ctxt->session)); - reqsize = ctxt->reqsize + copy_cstate(ctxt->reqbuf + ctxt->reqsize, ctxt->cstate); - reqhdr->plen = htons(reqsize - sizeof(sdp_pdu_hdr_t)); - - while (sent < reqsize) { - int n = send(ctxt->session->sock, ctxt->reqbuf + sent, reqsize - sent, 0); - if (n < 0) { - *err = errno; - return -1; + /* + * Unregister all service records related to this owner. + * One owner can use multiple local adapter(provider) + */ + str2ba(dbus_data->address, &sba); + for (lr = p->lrec; lr; lr = lr->next) { + struct service_record *r = lr->data; + if (sdp_service_unregister(&sba, r->record, &err) < 0) + error("unregister error: %s (%d)", strerror(err), err); + else + /* free inside the library */ + r->record = NULL; } - sent += n; - } - return 0; -} - -static DBusMessage *parse_response(struct transaction_context *ctxt) -{ - DBusMessage *reply = NULL; - DBusMessageIter iter; - DBusMessageIter array_iter; - int scanned, seqlen; - uint8_t dataType; - uint8_t *pdata; - const char *owner; - - owner = dbus_message_get_sender(ctxt->rq); - - reply = dbus_message_new_method_return(ctxt->rq); - - if ((ctxt->attr_list_len <= 0) || (ctxt->rspbuf.data_size == 0)) - return dbus_message_new_error(ctxt->rq, ERROR_INTERFACE ".DoesNotExist", - "Record does not exist"); - - dbus_message_iter_init_append(reply, &iter); - dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, - DBUS_TYPE_UINT32_AS_STRING, &array_iter); - - pdata = ctxt->rspbuf.data; - - scanned = sdp_extract_seqtype(pdata, &dataType, &seqlen); - - if (scanned && seqlen) { - pdata += scanned; - do { - uint32_t id; - int recsize = 0; - sdp_record_t *rec = sdp_extract_pdu(pdata, &recsize); - if (rec == NULL) - break; - - if (!recsize) { - sdp_record_free(rec); - break; - } - - scanned += recsize; - pdata += recsize; - - id = sdp_cache_append(owner, &ctxt->dba, rec); - dbus_message_iter_append_basic(&array_iter, - DBUS_TYPE_UINT32, &id); + /* remove from the cache */ + sdp_cache = slist_remove(sdp_cache, p); - } while (scanned < ctxt->attr_list_len); + service_provider_free(p, NULL); } - - dbus_message_iter_close_container(&iter, &array_iter); - - return reply; } -static gboolean svc_search_attr_req_cb(GIOChannel *chan, GIOCondition cond, struct transaction_context *ctxt) +static gboolean search_session_handle_cb(GIOChannel *chan, GIOCondition cond, void *udata) { - int sk, err, n; - uint32_t rsp_count; - gboolean ret_val = FALSE; + struct transaction_context *ctxt = udata; + int sk, err = 0; socklen_t len; - uint8_t cstate_len; - uint8_t *pdata; - uint8_t *rsp = NULL; - sdp_pdu_hdr_t *reqhdr = (sdp_pdu_hdr_t *) ctxt->reqbuf; - sdp_pdu_hdr_t *rsphdr; + const char *dst; + int retval = FALSE; + + dbus_message_get_args(ctxt->rq, NULL, + DBUS_TYPE_STRING, &dst, + DBUS_TYPE_INVALID); sk = g_io_channel_unix_get_fd(chan); @@ -602,84 +493,96 @@ static gboolean svc_search_attr_req_cb(GIOChannel *chan, GIOCondition cond, stru if (getsockopt(sk, SOL_SOCKET, SO_ERROR, &err, &len) < 0) { error("getsockopt(): %s, (%d)", strerror(errno), errno); - goto failed; + error_failed(ctxt->conn, ctxt->rq, errno); + goto fail; } if (err != 0) { - error("connect(): %s(%d)", strerror(err), err); - error_connection_attempt_failed(ctxt->conn, ctxt->rq, err); - goto failed; + error_failed(ctxt->conn, ctxt->rq, err); + error("sock error:s(%d)", strerror(err), err); + goto fail; } + if (!sdp_service_search_handle(ctxt->session)) + return TRUE; - rsp = malloc(SDP_RSP_BUFFER_SIZE); - memset(rsp, 0, SDP_RSP_BUFFER_SIZE); +fail: + g_io_channel_close(chan); + return retval; +} - n = recv(sk, rsp, SDP_RSP_BUFFER_SIZE, 0); - if (n <= 0) { - err = errno; - goto failed; - } +static void search_transaction_completed_cb(sdp_list_t *rsp, struct transaction_context *ctxt, int err) +{ + char identifier[MAX_IDENTIFIER_LEN]; + const char *ptr = identifier; + DBusMessage *reply; + DBusMessageIter iter, array_iter; + sdp_list_t *next; + const char *dst; + int id; - rsphdr = (sdp_pdu_hdr_t *)rsp; - if (n == 0 || reqhdr->tid != rsphdr->tid) { - err = EPROTO; - goto failed; + if (!ctxt) + return; + + if (err) { + error_failed(ctxt->conn, ctxt->rq, err); + return; } - pdata = rsp + sizeof(sdp_pdu_hdr_t); + dbus_message_get_args(ctxt->rq, NULL, + DBUS_TYPE_STRING, &dst, + DBUS_TYPE_INVALID); - if (rsphdr->pdu_id == SDP_ERROR_RSP) { - uint16_t ecode = ntohs(bt_get_unaligned((uint16_t *) pdata)); - error("Received SDP error response PDU: %s (%d)", ecode2str(ecode), ecode); - err = EPROTO; - goto failed; - } + reply = dbus_message_new_method_return(ctxt->rq); + dbus_message_iter_init_append(reply, &iter); + dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, + DBUS_TYPE_STRING_AS_STRING, &array_iter); - rsp_count = ntohs(bt_get_unaligned((uint16_t *) pdata)); - ctxt->attr_list_len += rsp_count; - pdata += sizeof(uint16_t); + /* add in the cache */ + for ( ;rsp; rsp = next) { + sdp_record_t *rec = (sdp_record_t *) rsp->data; - // if continuation state set need to re-issue request before parsing - cstate_len = *(uint8_t *) (pdata + rsp_count); + id = sdp_cache_append(NULL, dst, rec); + snprintf(identifier, MAX_IDENTIFIER_LEN, "%s/%d", dst, id); + dbus_message_iter_append_basic(&array_iter, + DBUS_TYPE_STRING, &ptr); - if (rsp_count > 0) { - uint8_t *targetPtr = NULL; + next = rsp->next; + free(rsp); + /* Don't free the record */ + } - ctxt->cstate = cstate_len > 0 ? (sdp_cstate_t *) (pdata + rsp_count) : 0; + dbus_message_iter_close_container(&iter, &array_iter); + send_reply_and_unref(ctxt->conn, reply); +} - // build concatenated response buffer - ctxt->rspbuf.data = realloc(ctxt->rspbuf.data, ctxt->rspbuf.data_size + rsp_count); - ctxt->rspbuf.buf_size = ctxt->rspbuf.data_size + rsp_count; - targetPtr = ctxt->rspbuf.data + ctxt->rspbuf.data_size; - memcpy(targetPtr, pdata, rsp_count); - ctxt->rspbuf.data_size += rsp_count; - } +static void transaction_context_free(void *udata) +{ + struct transaction_context *ctxt = udata; - if (ctxt->cstate) { - if (!sdp_send_req(ctxt, &err)) - ret_val = TRUE; - } else { - /* parse the response PDU */ - send_reply_and_unref(ctxt->conn, parse_response(ctxt)); - } -failed: - if (rsp) - free(rsp); + if (!ctxt) + return; - if (err) { - error_failed(ctxt->conn, ctxt->rq, err); - error("SDP transaction error: %s (%d)", strerror(err), err); - } + if (ctxt->conn) + dbus_connection_unref(ctxt->conn); + + if (ctxt->rq) + dbus_message_unref(ctxt->rq); - return ret_val; + if (ctxt->session) + sdp_close(ctxt->session); + + free(ctxt); } -static gboolean sdp_client_connect_cb(GIOChannel *chan, GIOCondition cond, struct pending_connect *c) +static gboolean sdp_client_connect_cb(GIOChannel *chan, GIOCondition cond, void *udata) { - int err, sk = 0; + struct pending_connect *c = udata; + struct transaction_context *ctxt = NULL; + sdp_list_t *search = NULL; + uint16_t class; + int err = 0, sk = 0; socklen_t len; - GIOChannel *tchan; - struct transaction_context *ctxt; + uuid_t uuid; sk = g_io_channel_unix_get_fd(chan); @@ -687,33 +590,62 @@ static gboolean sdp_client_connect_cb(GIOChannel *chan, GIOCondition cond, struc if (getsockopt(sk, SOL_SOCKET, SO_ERROR, &err, &len) < 0) { error("getsockopt(): %s, (%d)", strerror(errno), errno); - goto failed; + error_connection_attempt_failed(c->conn, c->rq, errno); + goto fail; } if (err != 0) { error("connect(): %s(%d)", strerror(err), err); error_connection_attempt_failed(c->conn, c->rq, err); - goto failed; + goto fail; } - ctxt = transaction_context_new(c->conn, c->rq, &c->dba, c->svc, sk, 0); - + ctxt = malloc(sizeof(*ctxt)); if (!ctxt) { error_failed(c->conn, c->rq, ENOMEM); - goto failed; + goto fail; } + memset(ctxt, 0, sizeof(*ctxt)); - tchan = g_io_channel_unix_new(sk); + /* FIXME: the sdp search list pattern should be created outside */ + if (!c->svc) { + sdp_uuid16_create(&uuid, PUBLIC_BROWSE_GROUP); + search = sdp_list_append(0, &uuid); + } else { + class = sdp_str2svclass(c->svc); + sdp_uuid16_create(&uuid, class); + search = sdp_list_append(0, &uuid); + } - g_io_add_watch_full(tchan, 0, G_IO_IN, (GIOFunc)svc_search_attr_req_cb, - ctxt, (GDestroyNotify)transaction_context_free); + ctxt->conn = dbus_connection_ref(c->conn); + ctxt->rq = dbus_message_ref(c->rq); + ctxt->session = sdp_session_new(sk); + if (!ctxt->session) { + error("error: %s (%d)", strerror(errno), errno); + error_failed(c->conn, c->rq, errno); + goto fail; + } - if (sdp_send_req(ctxt, &err) < 0) { - error("Can't send PDU: %s (%d)", strerror(err), err); - error_failed(c->conn, c->rq, err); - goto failed; + /* Create/send the search request and set the callback to indicate the request completion */ + if (sdp_service_search_attr_req_async(ctxt->session, search, + (sdp_transaction_cb_t *)search_transaction_completed_cb, ctxt) < 0) { + error("send request failed: %s (%d)", strerror(errno), errno); + error_failed(c->conn, c->rq, errno); + goto fail; } -failed: + + /* set the callback responsible for update the transaction data */ + g_io_add_watch_full(chan, 0, G_IO_IN, search_session_handle_cb, + ctxt, transaction_context_free); + goto done; + +fail: + if (ctxt) + transaction_context_free(ctxt); +done: + if (search) + sdp_list_free(search, 0); + pending_connects = slist_remove(pending_connects, c); pending_connect_free(c); @@ -725,11 +657,11 @@ static int search_request(DBusConnection *conn, DBusMessage *msg, uint16_t dev_i { struct pending_connect *c = NULL; GIOChannel *chan = NULL; - bdaddr_t sba; struct sockaddr_l2 sa; int sk, watch = 0; // create L2CAP connection + /* FIXME: use set_nonblocking */ sk = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_L2CAP); if (sk < 0) { if (err) @@ -743,21 +675,18 @@ static int search_request(DBusConnection *conn, DBusMessage *msg, uint16_t dev_i sa.l2_family = AF_BLUETOOTH; sa.l2_psm = 0; - hci_devba(dev_id, &sba); + hci_devba(dev_id, &sa.l2_bdaddr); - if (bacmp(&sba, BDADDR_ANY) != 0) { - bacpy(&sa.l2_bdaddr, &sba); - if (bind(sk, (struct sockaddr *) &sa, sizeof(sa)) < 0) { - if (err) - *err = errno; - goto fail; - } + if (bind(sk, (struct sockaddr *) &sa, sizeof(sa)) < 0) { + if (err) + *err = errno; + goto fail; } sa.l2_psm = htobs(SDP_PSM); str2ba(dst, &sa.l2_bdaddr); - c = pending_connect_new(conn, msg, &sa.l2_bdaddr, svc); + c = pending_connect_new(conn, msg, dst, svc); if (!c) { if (err) *err = ENOMEM; @@ -766,7 +695,7 @@ static int search_request(DBusConnection *conn, DBusMessage *msg, uint16_t dev_i fcntl(sk, F_SETFL, fcntl(sk, F_GETFL, 0)|O_NONBLOCK); if (connect(sk, (struct sockaddr *) &sa, sizeof(sa)) < 0) { - if ( !(errno == EAGAIN || errno == EINPROGRESS)) { + if (!(errno == EAGAIN || errno == EINPROGRESS)) { if (err) *err = errno; error("connect() failed:%s (%d)", strerror(errno), errno); @@ -774,7 +703,7 @@ static int search_request(DBusConnection *conn, DBusMessage *msg, uint16_t dev_i } watch = g_io_add_watch(chan, G_IO_OUT, - (GIOFunc)sdp_client_connect_cb, c); + sdp_client_connect_cb, c); pending_connects = slist_append(pending_connects, c); } else { sdp_client_connect_cb(chan, G_IO_OUT, c); @@ -796,60 +725,59 @@ static DBusHandlerResult get_identifiers(DBusConnection *conn, { char filename[PATH_MAX + 1]; struct hci_dbus_data *dbus_data = data; - struct service_provider *p; - struct slist *l; const char *dst; char *str; - DBusMessage *reply; - DBusMessageIter iter, array_iter; - bdaddr_t dba; int err = 0; if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &dst, DBUS_TYPE_INVALID)) return error_invalid_arguments(conn, msg); - - /* FIXME: validate Bluetooth address(dst) */ - - str2ba(dst, &dba); - reply = dbus_message_new_method_return(msg); - if (!reply) - return DBUS_HANDLER_RESULT_NEED_MEMORY; + if (find_pending_connect(dst)) + return error_service_search_in_progress(conn, msg); - p = service_provider_new(NULL, &dba); - if (!p) { - dbus_message_unref(reply); - return DBUS_HANDLER_RESULT_NEED_MEMORY; - } - - l = slist_find(sdp_cache, p, (cmp_func_t)service_provider_cmp); - service_provider_free(p); + /* check if it is a unknown address */ + snprintf(filename, PATH_MAX, "%s/%s/lastseen", STORAGEDIR, dbus_data->address); - if (l) { - struct slist *lr; - struct service_record *r; + str = textfile_get(filename, dst); + if (!str) + return error_unknown_address(conn, msg); - /* check the cache */ - dbus_message_iter_init_append(reply, &iter); - dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, - DBUS_TYPE_UINT32_AS_STRING, &array_iter); + free(str); - p = l->data; - for (lr = p->lrec; lr; lr = lr->next) { - r = lr->data; - dbus_message_iter_append_basic(&array_iter, - DBUS_TYPE_UINT32, &r->identifier); - } + if (search_request(conn, msg, dbus_data->dev_id, dst, NULL, &err) < 0) { + error("Search request failed: %s (%d)", strerror(err), err); + return error_failed(conn, msg, err); + } - dbus_message_iter_close_container(&iter, &array_iter); + return DBUS_HANDLER_RESULT_HANDLED; +} - return send_reply_and_unref(conn, reply); - } +static DBusHandlerResult get_identifiers_by_service(DBusConnection *conn, + DBusMessage *msg, void *data) +{ + char filename[PATH_MAX + 1]; + struct hci_dbus_data *dbus_data = data; + DBusMessage *reply; + DBusMessageIter iter, array_iter; + struct slist *lp; + struct slist *lr; + struct service_provider *p; + struct service_record *r; + char identifier[MAX_IDENTIFIER_LEN]; + const char *ptr = identifier; + const char *dst, *svc; + char *str; + int err = 0, nrec = 0; + uint32_t class; + uuid_t uuid; - if (find_pending_connect(&dba)) - return error_service_search_in_progress(conn, msg); + if (!dbus_message_get_args(msg, NULL, + DBUS_TYPE_STRING, &dst, + DBUS_TYPE_STRING, &svc, + DBUS_TYPE_INVALID)) + return error_invalid_arguments(conn, msg); /* check if it is a unknown address */ create_name(filename, PATH_MAX, STORAGEDIR, dbus_data->address, "lastseen"); @@ -860,21 +788,74 @@ static DBusHandlerResult get_identifiers(DBusConnection *conn, free(str); - if (search_request(conn, msg, dbus_data->dev_id, dst, NULL, &err) < 0) { + class = sdp_str2svclass(svc); + if (!class) { + error("Invalid service class name"); + return error_invalid_arguments(conn, msg); + } + + sdp_uuid16_create(&uuid, class); + + p = service_provider_new(NULL, dst); + if (!p) + return DBUS_HANDLER_RESULT_NEED_MEMORY; + + /* FIXME: return cache entry or query again? */ + lp = slist_find(sdp_cache, p, service_provider_cmp); + service_provider_free(p, NULL); + + if (!lp) + goto search_request; + + reply = dbus_message_new_method_return(msg); + dbus_message_iter_init_append(reply, &iter); + dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, + DBUS_TYPE_STRING_AS_STRING, &array_iter); + + p = lp->data; + for (lr = p->lrec; lr; lr = lr->next) { + sdp_list_t *ls; + uuid_t *puuid; + r = lr->data; + /* check if the pattern match */ + if (sdp_get_service_classes(r->record, &ls)) + continue; + + puuid = (uuid_t *)ls->data; + + if (sdp_uuid16_cmp(puuid, &uuid) == 0) { + snprintf(identifier, MAX_IDENTIFIER_LEN, "%s/%d", p->prov, r->id); + dbus_message_iter_append_basic(&array_iter, + DBUS_TYPE_STRING, &ptr); + nrec++; + } + + sdp_list_free(ls, free); + + } + + dbus_message_iter_close_container(&iter, &array_iter); + + if (nrec > 0) + return send_reply_and_unref(conn, reply); + + /* no record found: request search */ + dbus_message_unref(reply); + +search_request: + if (find_pending_connect(dst)) + return error_service_search_in_progress(conn, msg); + + if (search_request(conn, msg, dbus_data->dev_id, dst, svc, &err) < 0) { error("Search request failed: %s (%d)", strerror(err), err); return error_failed(conn, msg, err); } return DBUS_HANDLER_RESULT_HANDLED; -} -static DBusHandlerResult get_identifiers_by_service(DBusConnection *conn, - DBusMessage *msg, void *data) -{ - return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } -sdp_record_t *find_record(uint32_t identifier) +static sdp_record_t *find_record(const char *address, int id) { struct slist *lp, *lr; struct service_provider *p; @@ -882,9 +863,12 @@ sdp_record_t *find_record(uint32_t identifier) for (lp = sdp_cache; lp; lp = lp->next) { p = lp->data; + if (strcmp(p->prov, address)) + continue; + for (lr = p->lrec; lr; lr = lr->next) { r = lr->data; - if (r->identifier == identifier) + if (r->id == id) return r->record; } } @@ -896,18 +880,23 @@ static DBusHandlerResult get_uuid(DBusConnection *conn, DBusMessage *msg, void *data) { char uuid_str[MAX_LEN_UUID_STR]; - sdp_list_t *l; + char address[18]; + sdp_list_t *ls; DBusMessage *reply; sdp_record_t *rec; char *ptr = uuid_str; - uint32_t identifier; + const char *identifier; + int id; if (!dbus_message_get_args(msg, NULL, - DBUS_TYPE_UINT32, &identifier, + DBUS_TYPE_STRING, &identifier, DBUS_TYPE_INVALID)) return error_invalid_arguments(conn, msg); - rec = find_record(identifier); + if (str2identifier(identifier, address, &id) != 0) + return error_invalid_arguments(conn, msg); + + rec = find_record(address, id); if (!rec) return error_record_does_not_exist(conn, msg); @@ -915,11 +904,16 @@ static DBusHandlerResult get_uuid(DBusConnection *conn, reply = dbus_message_new_method_return(msg); - if (sdp_get_profile_descs(rec, &l) == 0) { - sdp_profile_desc_t *desc = (sdp_profile_desc_t *)l->data; + if (sdp_get_service_classes(rec, &ls) == 0) { + char tmp_str[MAX_LEN_UUID_STR]; + uuid_t *uuid = (uuid_t *)ls->data; - sdp_uuid2strn(&desc->uuid, uuid_str, MAX_LEN_UUID_STR); - sdp_list_free(l, free); + if (sdp_uuid2strn(uuid, tmp_str, MAX_LEN_UUID_STR) != 0) + error("Can't convert UUID to string!"); + else + snprintf(uuid_str, MAX_LEN_UUID_STR, "0x%s", tmp_str); + + sdp_list_free(ls, free); } dbus_message_append_args(reply, @@ -932,27 +926,43 @@ static DBusHandlerResult get_uuid(DBusConnection *conn, static DBusHandlerResult get_name(DBusConnection *conn, DBusMessage *msg, void *data) { + char address[18]; DBusMessage *reply; sdp_record_t *rec; - sdp_data_t *d; + sdp_list_t *ls; char name[] = ""; - char *ptr = name; - uint32_t identifier; + const char *ptr = name; + const char *identifier; + uuid_t *puuid; + int id; if (!dbus_message_get_args(msg, NULL, - DBUS_TYPE_UINT32, &identifier, + DBUS_TYPE_STRING, &identifier, DBUS_TYPE_INVALID)) return error_invalid_arguments(conn, msg); - rec = find_record(identifier); + if (str2identifier(identifier, address, &id) != 0) + return error_invalid_arguments(conn, msg); + + rec = find_record(address, id); if (!rec) return error_record_does_not_exist(conn, msg); - reply = dbus_message_new_method_return(msg); - d = sdp_data_get(rec, SDP_ATTR_SVCNAME_PRIMARY); - if (d && d->val.str) - ptr = d->val.str; + if ((sdp_get_service_classes(rec, &ls)) < 0) { + return error_failed(conn, msg, errno); + } + + puuid = (uuid_t *)ls->data; + ptr = sdp_svclass2str(puuid->value.uuid16); + sdp_list_free(ls, free); + + /* return empty string for non supported services */ + if (!ptr) + ptr = name; + + /* FIXME: it should return the service name attribute instead of the short service name */ + reply = dbus_message_new_method_return(msg); dbus_message_append_args(reply, DBUS_TYPE_STRING, &ptr, DBUS_TYPE_INVALID); @@ -964,11 +974,14 @@ static DBusHandlerResult register_rfcomm(DBusConnection *conn, DBusMessage *msg, void *data) { struct hci_dbus_data *dbus_data = data; - struct service_provider ref; + struct service_provider psearch; DBusMessage *reply; + sdp_record_t *rec; const char *owner, *name; + char identifier[MAX_IDENTIFIER_LEN]; + const char *ptr = identifier; bdaddr_t sba; - uint32_t identifier = 0, handle = 0; + int id = 0, err = 0; uint8_t channel; owner = dbus_message_get_sender(msg); @@ -979,39 +992,51 @@ static DBusHandlerResult register_rfcomm(DBusConnection *conn, DBUS_TYPE_INVALID)) return error_invalid_arguments(conn, msg); - /* FIXME: register the service */ - - hci_devba(dbus_data->dev_id, &sba); - identifier = gen_next_id(&sba, handle); - reply = dbus_message_new_method_return(msg); if (!reply) return DBUS_HANDLER_RESULT_NEED_MEMORY; - dbus_message_append_args(msg, - DBUS_TYPE_UINT32, &identifier, - DBUS_TYPE_INVALID); + str2ba(dbus_data->address, &sba); + /* register service */ + if (!(rec = sdp_service_register(name, &sba, channel, &err))) { + dbus_message_unref(reply); + error("service register error: %s (%d)", strerror(err), err); + if (err == EINVAL) + return error_invalid_arguments(conn, msg); + else + return error_failed(conn, msg, err); + } /* Only add a D-Bus unique name listener if there isn't one already registered */ - memset(&ref, 0, sizeof(ref)); - bacpy(&ref.prov, BDADDR_ANY); + memset(&psearch, 0, sizeof(psearch)); + psearch.owner = (char *)owner; - if (!slist_find(sdp_cache, &ref, (cmp_func_t)service_provider_cmp)) + if (!slist_find(sdp_cache, &psearch, service_provider_cmp)) name_listener_add(conn, owner, (name_cb_t)owner_exited, dbus_data); - /* FIXME: register the RFCOMM service */ - + /* add record in the cache */ + id = sdp_cache_append(owner, dbus_data->address, rec); + + snprintf(identifier, MAX_IDENTIFIER_LEN, "%s/%d", dbus_data->address, id); + dbus_message_append_args(reply, + DBUS_TYPE_STRING, &ptr, + DBUS_TYPE_INVALID); + return send_reply_and_unref(conn, reply); } static DBusHandlerResult unregister_rfcomm(DBusConnection *conn, DBusMessage *msg, void *data) { + char address[18]; struct hci_dbus_data *dbus_data = data; - struct service_provider *p, ref; - struct slist *match; + struct service_provider *p, psearch; + struct service_record rsearch, *r; + struct slist *lp, *lr; DBusMessage *reply; const char *owner, *identifier; + bdaddr_t sba; + int id = 0, err = 0; owner = dbus_message_get_sender(msg); @@ -1020,34 +1045,55 @@ static DBusHandlerResult unregister_rfcomm(DBusConnection *conn, DBUS_TYPE_INVALID)) return error_invalid_arguments(conn, msg); - memset(&ref, 0, sizeof(ref)); - - hci_devba(dbus_data->dev_id, &ref.prov); - ref.owner = (char *) owner; + if (str2identifier(identifier, address, &id) != 0) + return error_invalid_arguments(conn, msg); + + /* check if the local adapter match */ + if (strcmp(address, dbus_data->address)) + return error_not_authorized(conn, msg); - match = slist_find(sdp_cache, &ref, (cmp_func_t)service_provider_cmp); - if (!match) + memset(&psearch, 0, sizeof(psearch)); + + psearch.prov = address; + psearch.owner = (char *)owner; + + lp = slist_find(sdp_cache, &psearch, service_provider_cmp); + if (!lp) return error_service_does_not_exist(conn, msg); - /* FIXME: find the RFCOMM UUID in the list */ - p = match->data; - - if (strcmp(p->owner, owner)) - return error_not_authorized(conn, msg); + p = lp->data; + + memset(&rsearch, 0, sizeof(rsearch)); + rsearch.id = id; + str2ba(dbus_data->address, &sba); + lr = slist_find(p->lrec, &rsearch, service_record_cmp); + if (!lr) + return error_service_does_not_exist(conn, msg); reply = dbus_message_new_method_return(msg); if (!reply) return DBUS_HANDLER_RESULT_NEED_MEMORY; - /* FIXME: unregister the service */ + r = lr->data; + if (sdp_service_unregister(&sba, r->record, &err) < 0) + error("service unregister error: %s (%d)", strerror(err), err); + else + r->record = NULL; - sdp_cache = slist_remove(sdp_cache, p); - service_provider_free(p); + /* Remove the service record */ + service_record_free(r, NULL); + p->lrec = slist_remove(p->lrec, r); - bacpy(&ref.prov, BDADDR_ANY); + /* if the service record is empty remove the provider */ + if (!p->lrec) { + sdp_cache = slist_remove(sdp_cache, p); + service_provider_free(p, NULL); + } + + psearch.prov = NULL; /* Only remove the D-Bus unique name listener if there are no more record using this name */ - if (!slist_find(sdp_cache, &ref, (cmp_func_t)service_provider_cmp)) + if (!slist_find(sdp_cache, &psearch, service_provider_cmp)) name_listener_remove(conn, owner, (name_cb_t)owner_exited, dbus_data); return send_reply_and_unref(conn, reply); @@ -1077,3 +1123,8 @@ DBusHandlerResult handle_sdp_method(DBusConnection *conn, DBusMessage *msg, void return error_unknown_method(conn, msg); } + +void dbus_sdp_cache_free() +{ + slist_foreach(sdp_cache, service_provider_free, NULL); +} |