main.cpp - mozsearch

++ // Copyright (C) 2016 The Qt Company Ltd.

++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0

++

++ #include <QtCore/QByteArray>

++ #include <QtCore/QDebug>

++ #include <QtCore/QUrl>

++ #include <stdio.h>

++ #include <string>

++ #include <bluetooth/bluetooth.h>

++ #include <bluetooth/sdp.h>

++ #include <bluetooth/sdp_lib.h>

++

++ #include <cstdio>

++

++ #define RETURN_SUCCESS      0

++ #define RETURN_USAGE        1

++ #define RETURN_INVALPARAM   2

++ #define RETURN_SDP_ERROR    3

++

++ void usage()

++ {

++     fprintf(stderr, "Usage:\n");

++     fprintf(stderr, "\tsdpscanner <remote bdaddr> <local bdaddr> [Options] ({uuids})\n\n");

++     fprintf(stderr, "Performs an SDP scan on remote device, using the SDP server\n"

++                     "represented by the local Bluetooth device.\n\n"

++                     "Options:\n"

++                     "   -p                  Show scan results in human-readable form\n"

++                     "   -u [list of uuids]  List of uuids which should be scanned for.\n"

++                     "                       Each uuid must be enclosed in {}.\n"

++                     "                       If the list is empty PUBLIC_BROWSE_GROUP scan is used.\n");

++ }

++

++ #define BUFFER_SIZE 1024

++

++ static void parseAttributeValues(sdp_data_t *data, int indentation,

++                                  QByteArray &xmlOutput, int depth = 0)

++ {

++     // same as in src/bluetooth/qbluetoothservicediscoveryagent_p.h

++     static constexpr int kMaxSdpRecursionDepth = 64;

++

++     if (depth > kMaxSdpRecursionDepth)

++         return;

++

++     while (data) {

++         const int length = indentation*2 + 1;

++         QByteArray indentString(length, ' ');

++

++         char snBuffer[BUFFER_SIZE];

++

++         xmlOutput.append(indentString);

++

++         // deal with every dtd type

++         switch (data->dtd) {

++         case SDP_DATA_NIL:

++             xmlOutput.append("<nil/>\n");

++             break;

++         case SDP_UINT8:

++             std::snprintf(snBuffer, BUFFER_SIZE, "<uint8 value=\"0x%02x\"/>\n", data->val.uint8);

++             xmlOutput.append(snBuffer);

++             break;

++         case SDP_UINT16:

++             std::snprintf(snBuffer, BUFFER_SIZE, "<uint16 value=\"0x%04x\"/>\n", data->val.uint16);

++             xmlOutput.append(snBuffer);

++             break;

++         case SDP_UINT32:

++             std::snprintf(snBuffer, BUFFER_SIZE, "<uint32 value=\"0x%08x\"/>\n", data->val.uint32);

++             xmlOutput.append(snBuffer);

++             break;

++         case SDP_UINT64:

++             std::snprintf(snBuffer, BUFFER_SIZE, "<uint64 value=\"0x%016llx\"/>\n",

++                           qulonglong(data->val.uint64));

++             xmlOutput.append(snBuffer);

++             break;

++         case SDP_UINT128:

++             xmlOutput.append("<uint128 value=\"0x");

++             for (int i = 0; i < 16; i++)

++                 std::sprintf(&snBuffer[i * 2], "%02x", data->val.uint128.data[i]);

++             xmlOutput.append(snBuffer);

++             xmlOutput.append("\"/>\n");

++             break;

++         case SDP_INT8:

++             std::snprintf(snBuffer, BUFFER_SIZE, "<int8 value=\"%d\"/>/n", data->val.int8);

++             xmlOutput.append(snBuffer);

++             break;

++         case SDP_INT16:

++             std::snprintf(snBuffer, BUFFER_SIZE, "<int16 value=\"%d\"/>/n", data->val.int16);

++             xmlOutput.append(snBuffer);

++             break;

++         case SDP_INT32:

++             std::snprintf(snBuffer, BUFFER_SIZE, "<int32 value=\"%d\"/>/n", data->val.int32);

++             xmlOutput.append(snBuffer);

++             break;

++         case SDP_INT64:

++             std::snprintf(snBuffer, BUFFER_SIZE, "<int64 value=\"%lld\"/>/n",

++                           qlonglong(data->val.int64));

++             xmlOutput.append(snBuffer);

++             break;

++         case SDP_INT128:

++             xmlOutput.append("<int128 value=\"0x");

++             for (int i = 0; i < 16; i++)

++                 std::sprintf(&snBuffer[i * 2], "%02x", data->val.int128.data[i]);

++             xmlOutput.append(snBuffer);

++             xmlOutput.append("\"/>\n");

++             break;

++         case SDP_UUID_UNSPEC:

++             break;

++         case SDP_UUID16:

++         case SDP_UUID32:

++             xmlOutput.append("<uuid value=\"0x");

++             sdp_uuid2strn(&(data->val.uuid), snBuffer, BUFFER_SIZE);

++             xmlOutput.append(snBuffer);

++             xmlOutput.append("\"/>\n");

++             break;

++         case SDP_UUID128:

++             xmlOutput.append("<uuid value=\"");

++             sdp_uuid2strn(&(data->val.uuid), snBuffer, BUFFER_SIZE);

++             xmlOutput.append(snBuffer);

++             xmlOutput.append("\"/>\n");

++             break;

++         case SDP_TEXT_STR_UNSPEC:

++             break;

++         case SDP_TEXT_STR8:

++         case SDP_TEXT_STR16:

++         case SDP_TEXT_STR32:

++         {

++             xmlOutput.append("<text ");

++             QByteArray text = QByteArray::fromRawData(data->val.str, data->unitSize);

++

++             bool hasNonPrintableChar = false;

++             for (qsizetype i = 0; i < text.size(); ++i) {

++                 if (text[i] == '\0') {

++                     text.resize(i); // cut trailing content

++                     break;

++                 } else if (!isprint(text[i])) {

++                     hasNonPrintableChar = true;

++                     const auto firstNullIdx = text.indexOf('\0');

++                     if (firstNullIdx > 0)

++                         text.resize(firstNullIdx); // cut trailing content

++                     break;

++                 }

++             }

++

++             if (hasNonPrintableChar) {

++                 xmlOutput.append("encoding=\"hex\" value=\"");

++                 xmlOutput.append(text.toHex());

++             } else {

++                 text.replace('&', "&amp;");

++                 text.replace('<', "&lt;");

++                 text.replace('>', "&gt;");

++                 text.replace('"', "&quot;");

++

++                 xmlOutput.append("value=\"");

++                 xmlOutput.append(text);

++             }

++

++             xmlOutput.append("\"/>\n");

++             break;

++         }

++         case SDP_BOOL:

++             if (data->val.uint8)

++                 xmlOutput.append("<boolean value=\"true\"/>\n");

++             else

++                 xmlOutput.append("<boolean value=\"false\"/>\n");

++             break;

++         case SDP_SEQ_UNSPEC:

++             break;

++         case SDP_SEQ8:

++         case SDP_SEQ16:

++         case SDP_SEQ32:

++             xmlOutput.append("<sequence>\n");

++             parseAttributeValues(data->val.dataseq, indentation + 1, xmlOutput, depth + 1);

++             xmlOutput.append(indentString);

++             xmlOutput.append("</sequence>\n");

++             break;

++         case SDP_ALT_UNSPEC:

++             break;

++         case SDP_ALT8:

++         case SDP_ALT16:

++         case SDP_ALT32:

++             xmlOutput.append("<alternate>\n");

++             parseAttributeValues(data->val.dataseq, indentation + 1, xmlOutput, depth + 1);

++             xmlOutput.append(indentString);

++             xmlOutput.append("</alternate>\n");

++             break;

++         case SDP_URL_STR_UNSPEC:

++             break;

++         case SDP_URL_STR8:

++         case SDP_URL_STR16:

++         case SDP_URL_STR32:

++         {

++             xmlOutput.append("<url value=\"");

++             const QByteArray urlData =

++                     QByteArray::fromRawData(data->val.str, qstrnlen(data->val.str, data->unitSize));

++             const QUrl url = QUrl::fromEncoded(urlData);

++             // Encoded url %-encodes all of the XML special characters except '&',

++             // so we need to do that manually

++             xmlOutput.append(url.toEncoded().replace('&', "&amp;"));

++             xmlOutput.append("\"/>\n");

++             break;

++         }

++         default:

++             fprintf(stderr, "Unknown dtd type\n");

++         }

++

++         data = data->next;

++     }

++ }

++

++ static void parseAttribute(void *value, void *extraData)

++ {

++     sdp_data_t *data = (sdp_data_t *) value;

++     QByteArray *xmlOutput = static_cast<QByteArray *>(extraData);

++

++     char buffer[BUFFER_SIZE];

++

++     std::snprintf(buffer, BUFFER_SIZE, "  <attribute id=\"0x%04x\">\n", data->attrId);

++     xmlOutput->append(buffer);

++

++     parseAttributeValues(data, 2, *xmlOutput);

++

++     xmlOutput->append("  </attribute>\n");

++ }

++

++ // the resulting xml output is based on the already used xml parser

++ QByteArray parseSdpRecord(sdp_record_t *record)

++ {

++     if (!record || !record->attrlist)

++         return QByteArray();

++

++     QByteArray xmlOutput;

++

++     xmlOutput.append("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n<record>\n");

++

++     sdp_list_foreach(record->attrlist, parseAttribute, &xmlOutput);

++     xmlOutput.append("</record>");

++

++     return xmlOutput;

++ }

++

++

++ int main(int argc, char **argv)

++ {

++     if (argc < 3) {

++         usage();

++         return RETURN_USAGE;

++     }

++

++     fprintf(stderr, "SDP for %s %s\n", argv[1], argv[2]);

++

++     bdaddr_t remote;

++     bdaddr_t local;

++     int result = str2ba(argv[1], &remote);

++     if (result < 0) {

++         fprintf(stderr, "Invalid remote address: %s\n", argv[1]);

++         return RETURN_INVALPARAM;

++     }

++

++     result = str2ba(argv[2], &local);

++     if (result < 0) {

++         fprintf(stderr, "Invalid local address: %s\n", argv[2]);

++         return RETURN_INVALPARAM;

++     }

++

++     bool showHumanReadable = false;

++     std::vector<std::string> targetServices;

++

++     for (int i = 3; i < argc; i++) {

++         if (argv[i][0] != '-') {

++             usage();

++             return RETURN_USAGE;

++         }

++

++         switch (argv[i][1])

++         {

++         case 'p':

++             showHumanReadable = true;

++             break;

++         case 'u':

++             i++;

++

++             for ( ; i < argc && argv[i][0] == '{'; i++)

++                 targetServices.push_back(argv[i]);

++

++             i--; // outer loop increments again

++             break;

++         default:

++             fprintf(stderr, "Wrong argument: %s\n", argv[i]);

++             usage();

++             return RETURN_USAGE;

++         }

++     }

++

++     std::vector<uuid_t> uuids;

++     for (std::vector<std::string>::const_iterator iter = targetServices.cbegin();

++          iter != targetServices.cend(); ++iter) {

++

++         uint128_t temp128;

++         uint16_t field1, field2, field3, field5;

++         uint32_t field0, field4;

++

++         fprintf(stderr, "Target scan for %s\n", (*iter).c_str());

++         if (sscanf((*iter).c_str(), "{%08x-%04hx-%04hx-%04hx-%08x%04hx}", &field0,

++                    &field1, &field2, &field3, &field4, &field5) != 6) {

++             fprintf(stderr, "Skipping invalid uuid: %s\n", ((*iter).c_str()));

++             continue;

++         }

++

++         // we need uuid_t conversion based on

++         // http://www.spinics.net/lists/linux-bluetooth/msg20356.html

++         field0 = htonl(field0);

++         field4 = htonl(field4);

++         field1 = htons(field1);

++         field2 = htons(field2);

++         field3 = htons(field3);

++         field5 = htons(field5);

++

++         uint8_t* temp = (uint8_t*) &temp128;

++         memcpy(&temp[0], &field0, 4);

++         memcpy(&temp[4], &field1, 2);

++         memcpy(&temp[6], &field2, 2);

++         memcpy(&temp[8], &field3, 2);

++         memcpy(&temp[10], &field4, 4);

++         memcpy(&temp[14], &field5, 2);

++

++         uuid_t sdpUuid;

++         sdp_uuid128_create(&sdpUuid, &temp128);

++         uuids.push_back(sdpUuid);

++     }

++

++     sdp_session_t *session = sdp_connect( &local, &remote, SDP_RETRY_IF_BUSY);

++     if (!session) {

++         //try one more time if first time failed

++         session = sdp_connect( &local, &remote, SDP_RETRY_IF_BUSY);

++     }

++

++     if (!session) {

++         fprintf(stderr, "Cannot establish sdp session\n");

++         return RETURN_SDP_ERROR;

++     }

++

++     // set the filter for service matches

++     if (uuids.empty()) {

++         fprintf(stderr, "Using PUBLIC_BROWSE_GROUP for SDP search\n");

++         uuid_t publicBrowseGroupUuid;

++         sdp_uuid16_create(&publicBrowseGroupUuid, PUBLIC_BROWSE_GROUP);

++         uuids.push_back(publicBrowseGroupUuid);

++     }

++

++     uint32_t attributeRange = 0x0000ffff; //all attributes

++     sdp_list_t *attributes;

++     attributes = sdp_list_append(nullptr, &attributeRange);

++

++     sdp_list_t *sdpResults, *sdpIter;

++     sdp_list_t *totalResults = nullptr;

++     sdp_list_t* serviceFilter;

++

++     for (uuid_t &uuid : uuids) { // can't be const, d/t sdp_list_append signature

++         serviceFilter = sdp_list_append(nullptr, &uuid);

++         result = sdp_service_search_attr_req(session, serviceFilter,

++                                          SDP_ATTR_REQ_RANGE,

++                                          attributes, &sdpResults);

++         sdp_list_free(serviceFilter, nullptr);

++         if (result != 0) {

++             fprintf(stderr, "sdp_service_search_attr_req failed\n");

++             sdp_list_free(attributes, nullptr);

++             sdp_close(session);

++             return RETURN_SDP_ERROR;

++         }

++

++         if (!sdpResults)

++             continue;

++

++         if (!totalResults) {

++             totalResults = sdpResults;

++             sdpIter = totalResults;

++         } else {

++             // attach each new result list to the end of totalResults

++             sdpIter->next = sdpResults;

++         }

++

++         while (sdpIter->next) // skip to end of list

++             sdpIter = sdpIter->next;

++     }

++     sdp_list_free(attributes, nullptr);

++

++     // start XML generation from the front

++     sdpResults = totalResults;

++

++     QByteArray total;

++     while (sdpResults) {

++         sdp_record_t *record = (sdp_record_t *) sdpResults->data;

++

++         const QByteArray xml = parseSdpRecord(record);

++         total += xml;

++

++         sdpIter = sdpResults;

++         sdpResults = sdpResults->next;

++         free(sdpIter);

++         sdp_record_free(record);

++     }

++

++     if (!total.isEmpty()) {

++         if (showHumanReadable)

++             printf("%s", total.constData());

++         else

++             printf("%s", total.toBase64().constData());

++     }

++

++     sdp_close(session);

++

++     return RETURN_SUCCESS;

++ }

Revision control