# # Copyright 2002 - 2004, Microsoft Corporation # #//////////////////////////////////////////////////////////////////////////// {.deadCodeElim: on.} when not defined(windows): {.error: "MSBT is supported by windows".} const libbluetooth* = "bthprops.cpl" import ms_bthdef, ms_bthsdpdef const BTH_MAX_PIN_SIZE = 16 const BLUETOOTH_MAX_NAME_SIZE* = (248) BLUETOOTH_MAX_PASSKEY_SIZE* = (16) BLUETOOTH_MAX_PASSKEY_BUFFER_SIZE* = (BLUETOOTH_MAX_PASSKEY_SIZE + 1) BLUETOOTH_MAX_SERVICE_NAME_SIZE* = (256) BLUETOOTH_DEVICE_NAME_SIZE* = (256) # *************************************************************************** # # Bluetooth Address # # *************************************************************************** type INNER_C_UNION_1866013399* = object {.union.} ullLong*: BTH_ADDR # easier to compare again BLUETOOTH_NULL_ADDRESS rgBytes*: array[6, BYTE] # easier to format when broken out BLUETOOTH_ADDRESS_STRUCT* = object ano_116103095*: INNER_C_UNION_1866013399 BLUETOOTH_ADDRESS* = BLUETOOTH_ADDRESS_STRUCT const BLUETOOTH_NULL_ADDRESS* = 0x0'i64 type BLUETOOTH_LOCAL_SERVICE_INFO_STRUCT* = object Enabled*: BOOL # If TRUE, the enable the services btAddr*: BLUETOOTH_ADDRESS # If service is to be advertised for a particular remote device szName*: array[BLUETOOTH_MAX_SERVICE_NAME_SIZE, WCHAR] # SDP Service Name to be advertised. szDeviceString*: array[BLUETOOTH_DEVICE_NAME_SIZE, WCHAR] # Local device name (if any) like COM4 or LPT1 BLUETOOTH_LOCAL_SERVICE_INFO* = BLUETOOTH_LOCAL_SERVICE_INFO_STRUCT PBLUETOOTH_LOCAL_SERVICE_INFO* = ptr BLUETOOTH_LOCAL_SERVICE_INFO # *************************************************************************** # # Radio Enumeration # # Description: # This group of APIs enumerates the installed Bluetooth radios. # # Sample Usage: # HANDLE hRadio; # BLUETOOTH_FIND_RADIO_PARAMS btfrp = { sizeof(btfrp) }; # # HBLUETOOTH_RADIO_FIND hFind = BluetoothFindFirstRadio( &btfrp, &hRadio ); # if ( NULL != hFind ) # { # do # { # // # // TODO: Do something with the radio handle. # // # # CloseHandle( hRadio ); # # } while( BluetoothFindNextRadio( hFind, &hRadio ) ); # # BluetoothFindRadioClose( hFind ); # } # # *************************************************************************** type BLUETOOTH_FIND_RADIO_PARAMS* = object dwSize*: DWORD # IN sizeof this structure HBLUETOOTH_RADIO_FIND* = HANDLE # # Description: # Begins the enumeration of local Bluetooth radios. # # Parameters: # pbtfrp # A pointer to a BLUETOOTH_FIND_RADIO_PARAMS structure. The dwSize # member of this structure must match the sizeof the of the structure. # # phRadio # A pointer where the first radio HANDLE enumerated will be returned. # # Return Values: # NULL # Error opening radios or no devices found. Use GetLastError() for # more info. # # ERROR_INVALID_PARAMETER # pbtfrp parameter is NULL. # # ERROR_REVISION_MISMATCH # The pbtfrp structure is not the right length. # # ERROR_OUTOFMEMORY # Out of memory. # # other Win32 errors. # # any other # Success. The return handle is valid and phRadio points to a valid handle. # proc BluetoothFindFirstRadio*(pbtfrp: ptr BLUETOOTH_FIND_RADIO_PARAMS; phRadio: ptr HANDLE): HBLUETOOTH_RADIO_FIND {. stdcall, importc: "BluetoothFindFirstRadio", dynlib: libbluetooth.} # # Description: # Finds the next installed Bluetooth radio. # # Parameters: # hFind # The handle returned by BluetoothFindFirstRadio(). # # phRadio # A pointer where the next radio HANDLE enumerated will be returned. # # Return Values: # TRUE # Next device succesfully found. pHandleOut points to valid handle. # # FALSE # No device found. pHandleOut points to an invalid handle. Call # GetLastError() for more details. # # ERROR_INVALID_HANDLE # The handle is NULL. # # ERROR_NO_MORE_ITEMS # No more radios found. # # ERROR_OUTOFMEMORY # Out of memory. # # other Win32 errors # proc BluetoothFindNextRadio*(hFind: HBLUETOOTH_RADIO_FIND; phRadio: ptr HANDLE): BOOL {.stdcall, importc: "BluetoothFindNextRadio", dynlib: libbluetooth.} # # Description: # Closes the enumeration handle. # # Parameters # hFind # The handle returned by BluetoothFindFirstRadio(). # # Return Values: # TRUE # Handle succesfully closed. # # FALSE # Failure. Check GetLastError() for details. # # ERROR_INVALID_HANDLE # The handle is NULL. # proc BluetoothFindRadioClose*(hFind: HBLUETOOTH_RADIO_FIND): BOOL {.stdcall, importc: "BluetoothFindRadioClose", dynlib: libbluetooth.} # *************************************************************************** # # Radio Information # # *************************************************************************** type BLUETOOTH_RADIO_INFO* = object dwSize*: DWORD # Size, in bytes, of this entire data structure address*: BLUETOOTH_ADDRESS # Address of the local radio szName*: array[BLUETOOTH_MAX_NAME_SIZE, WCHAR] # Name of the local radio ulClassofDevice*: ULONG # Class of device for the local radio lmpSubversion*: USHORT # lmpSubversion, manufacturer specifc. manufacturer*: USHORT # Manufacturer of the radio, BTH_MFG_Xxx value. For the most up to date # list, goto the Bluetooth specification website and get the Bluetooth # assigned numbers document. PBLUETOOTH_RADIO_INFO* = ptr BLUETOOTH_RADIO_INFO # # Description: # Retrieves the information about the radio represented by the handle. # # Parameters: # hRadio # Handle to a local radio retrieved through BluetoothFindFirstRadio() # et al or SetupDiEnumerateDeviceInterfaces() # # pRadioInfo # Radio information to be filled in. The dwSize member must match the # size of the structure. # # Return Values: # ERROR_SUCCESS # The information was retrieved successfully. # # ERROR_INVALID_PARAMETER # pRadioInfo or hRadio is NULL. # # ERROR_REVISION_MISMATCH # pRadioInfo->dwSize is invalid. # # other Win32 error codes. # proc BluetoothGetRadioInfo*(hRadio: HANDLE; pRadioInfo: PBLUETOOTH_RADIO_INFO): DWORD {. stdcall, importc: "BluetoothGetRadioInfo", dynlib: libbluetooth.} # *************************************************************************** # # Device Information Stuctures # # *************************************************************************** type BLUETOOTH_DEVICE_INFO_STRUCT* = object dwSize*: DWORD # size, in bytes, of this structure - must be the sizeof(BLUETOOTH_DEVICE_INFO) Address*: BLUETOOTH_ADDRESS # Bluetooth address ulClassofDevice*: ULONG # Bluetooth "Class of Device" fConnected*: BOOL # Device connected/in use fRemembered*: BOOL # Device remembered fAuthenticated*: BOOL # Device authenticated/paired/bonded stLastSeen*: SYSTEMTIME # Last time the device was seen stLastUsed*: SYSTEMTIME # Last time the device was used for other than RNR, inquiry, or SDP szName*: array[BLUETOOTH_MAX_NAME_SIZE, WCHAR] # Name of the device BLUETOOTH_DEVICE_INFO* = BLUETOOTH_DEVICE_INFO_STRUCT PBLUETOOTH_DEVICE_INFO* = ptr BLUETOOTH_DEVICE_INFO # # Support added after KB942567 # type INNER_C_UNION_2689769052* = object {.union.} Numeric_Value*: ULONG Passkey*: ULONG type BLUETOOTH_AUTHENTICATION_METHOD* {.size: sizeof(cint).} = enum BLUETOOTH_AUTHENTICATION_METHOD_LEGACY = 0x00000001, BLUETOOTH_AUTHENTICATION_METHOD_OOB, BLUETOOTH_AUTHENTICATION_METHOD_NUMERIC_COMPARISON, BLUETOOTH_AUTHENTICATION_METHOD_PASSKEY_NOTIFICATION, BLUETOOTH_AUTHENTICATION_METHOD_PASSKEY PBLUETOOTH_AUTHENTICATION_METHOD* = ptr BLUETOOTH_AUTHENTICATION_METHOD BLUETOOTH_IO_CAPABILITY* {.size: sizeof(cint).} = enum BLUETOOTH_IO_CAPABILITY_DISPLAYONLY = 0x00000000, BLUETOOTH_IO_CAPABILITY_DISPLAYYESNO = 0x00000001, BLUETOOTH_IO_CAPABILITY_KEYBOARDONLY = 0x00000002, BLUETOOTH_IO_CAPABILITY_NOINPUTNOOUTPUT = 0x00000003, BLUETOOTH_IO_CAPABILITY_UNDEFINED = 0x000000FF BLUETOOTH_AUTHENTICATION_REQUIREMENTS* {.size: sizeof(cint).} = enum BLUETOOTH_MITM_ProtectionNotRequired = 0, BLUETOOTH_MITM_ProtectionRequired = 0x00000001, BLUETOOTH_MITM_ProtectionNotRequiredBonding = 0x00000002, BLUETOOTH_MITM_ProtectionRequiredBonding = 0x00000003, BLUETOOTH_MITM_ProtectionNotRequiredGeneralBonding = 0x00000004, BLUETOOTH_MITM_ProtectionRequiredGeneralBonding = 0x00000005, BLUETOOTH_MITM_ProtectionNotDefined = 0x000000FF BLUETOOTH_AUTHENTICATION_CALLBACK_PARAMS* = object deviceInfo*: BLUETOOTH_DEVICE_INFO authenticationMethod*: BLUETOOTH_AUTHENTICATION_METHOD ioCapability*: BLUETOOTH_IO_CAPABILITY authenticationRequirements*: BLUETOOTH_AUTHENTICATION_REQUIREMENTS ano_869376366*: INNER_C_UNION_2689769052 PBLUETOOTH_AUTHENTICATION_CALLBACK_PARAMS* = ptr BLUETOOTH_AUTHENTICATION_CALLBACK_PARAMS # *************************************************************************** # # Device Enumeration # # Description: # Enumerates the Bluetooth devices. The types of returned device depends # on the flags set in the BLUETOOTH_DEVICE_SEARCH_PARAMS (see structure # definition for details). # # Sample Usage: # HBLUETOOTH_DEVICE_FIND hFind; # BLUETOOTH_DEVICE_SEARCH_PARAMS btsp = { sizeof(btsp) }; # BLUETOOTH_DEVICE_INFO btdi = { sizeof(btdi) }; # # btsp.fReturnAuthenticated = TRUE; # btsp.fReturnRemembered = TRUE; # # hFind = BluetoothFindFirstDevice( &btsp, &btdi ); # if ( NULL != hFind ) # { # do # { # // # // TODO: Do something useful with the device info. # // # # } while( BluetoothFindNextDevice( hFind, &btdi ) ); # # BluetoothFindDeviceClose( hFind ); # } # # *************************************************************************** type BLUETOOTH_DEVICE_SEARCH_PARAMS* = object dwSize*: DWORD # IN sizeof this structure fReturnAuthenticated*: BOOL # IN return authenticated devices fReturnRemembered*: BOOL # IN return remembered devices fReturnUnknown*: BOOL # IN return unknown devices fReturnConnected*: BOOL # IN return connected devices fIssueInquiry*: BOOL # IN issue a new inquiry cTimeoutMultiplier*: UCHAR # IN timeout for the inquiry hRadio*: HANDLE # IN handle to radio to enumerate - NULL == all radios will be searched HBLUETOOTH_DEVICE_FIND* = HANDLE # # Description: # Begins the enumeration of Bluetooth devices. # # Parameters: # pbtsp # A pointer to a BLUETOOTH_DEVICE_SEARCH_PARAMS structure. This # structure contains the flags and inputs used to conduct the search. # See BLUETOOTH_DEVICE_SEARCH_PARAMS for details. # # pbtdi # A pointer to a BLUETOOTH_DEVICE_INFO structure to return information # about the first Bluetooth device found. Note that the dwSize member # of the structure must be the sizeof(BLUETOOTH_DEVICE_INFO) before # calling because the APIs hast to know the size of the buffer being # past in. The dwSize member must also match the exact # sizeof(BLUETOOTH_DEVICE_INFO) or the call will fail. # # Return Values: # NULL # Error opening radios or not devices found. Use GetLastError for more info. # # ERROR_INVALID_PARAMETER # pbtsp parameter or pbtdi parameter is NULL. # # ERROR_REVISION_MISMATCH # The pbtfrp structure is not the right length. # # other Win32 errors # # any other value # Success. The return handle is valid and pbtdi points to valid data. # proc BluetoothFindFirstDevice*(pbtsp: ptr BLUETOOTH_DEVICE_SEARCH_PARAMS; pbtdi: ptr BLUETOOTH_DEVICE_INFO): HBLUETOOTH_DEVICE_FIND {. stdcall, importc: "BluetoothFindFirstDevice", dynlib: libbluetooth.} # # Description: # Finds the next Bluetooth device in the enumeration. # # Parameters: # hFind # The handle returned from BluetoothFindFirstDevice(). # # pbtdi # A pointer to a BLUETOOTH_DEVICE_INFO structure to return information # about the first Bluetooth device found. Note that the dwSize member # of the structure must be the sizeof(BLUETOOTH_DEVICE_INFO) before # calling because the APIs hast to know the size of the buffer being # past in. The dwSize member must also match the exact # sizeof(BLUETOOTH_DEVICE_INFO) or the call will fail. # # Return Values: # TRUE # Next device succesfully found. pHandleOut points to valid handle. # # FALSE # No device found. pHandleOut points to an invalid handle. Call # GetLastError() for more details. # # ERROR_INVALID_HANDLE # The handle is NULL. # # ERROR_NO_MORE_ITEMS # No more radios found. # # ERROR_OUTOFMEMORY # Out of memory. # # other Win32 errors # proc BluetoothFindNextDevice*(hFind: HBLUETOOTH_DEVICE_FIND; pbtdi: ptr BLUETOOTH_DEVICE_INFO): BOOL {. stdcall, importc: "BluetoothFindNextDevice", dynlib: libbluetooth.} # # Description: # Closes the enumeration handle. # # Parameters: # hFind # The handle returned from BluetoothFindFirstDevice(). # # Return Values: # TRUE # Handle succesfully closed. # # FALSE # Failure. Check GetLastError() for details. # # ERROR_INVALID_HANDLE # The handle is NULL. # proc BluetoothFindDeviceClose*(hFind: HBLUETOOTH_DEVICE_FIND): BOOL {. stdcall, importc: "BluetoothFindDeviceClose", dynlib: libbluetooth.} # # Description: # Retrieves information about a remote device. # # Fill in the dwSize and the Address members of the pbtdi structure # being passed in. On success, the rest of the members will be filled # out with the information that the system knows. # # Parameters: # hRadio # Handle to a local radio retrieved through BluetoothFindFirstRadio() # et al or SetupDiEnumerateDeviceInterfaces() # # pbtdi # A pointer to a BLUETOOTH_DEVICE_INFO structure to return information # about the first Bluetooth device found. The dwSize member of the # structure must be the sizeof the structure in bytes. The Address # member must be filled out with the Bluetooth address of the remote # device. # # Return Values: # ERROR_SUCCESS # Success. Information returned. # # ERROR_REVISION_MISMATCH # The size of the BLUETOOTH_DEVICE_INFO isn't compatible. Check # the dwSize member of the BLUETOOTH_DEVICE_INFO structure you # passed in. # # ERROR_NOT_FOUND # The radio is not known by the system or the Address field of # the BLUETOOTH_DEVICE_INFO structure is all zeros. # # ERROR_INVALID_PARAMETER # pbtdi is NULL. # # other error codes # proc BluetoothGetDeviceInfo*(hRadio: HANDLE; pbtdi: ptr BLUETOOTH_DEVICE_INFO): DWORD {. stdcall, importc: "BluetoothGetDeviceInfo", dynlib: libbluetooth.} # # Description: # Updates the computer local cache about the device. # # Parameters: # pbtdi # A pointer to the BLUETOOTH_DEVICE_INFO structure to be updated. # The following members must be valid: # dwSize # Must match the size of the structure. # Address # Must be a previously found radio address. # szName # New name to be stored. # # Return Values: # ERROR_SUCCESS # The device information was updated successfully. # # ERROR_INVALID_PARAMETER # pbtdi is NULL. # # ERROR_REVISION_MISMATCH # pbtdi->dwSize is invalid. # # other Win32 error codes. # proc BluetoothUpdateDeviceRecord*(pbtdi: ptr BLUETOOTH_DEVICE_INFO): DWORD {. stdcall, importc: "BluetoothUpdateDeviceRecord", dynlib: libbluetooth.} # # Description: # Delete the authentication (aka "bond") between the computer and the # device. Also purges any cached information about the device. # # Return Values: # ERROR_SUCCESS # The device was removed successfully. # # ERROR_NOT_FOUND # The device was not found. If no Bluetooth radio is installed, # the devices could not be enumerated or removed. # proc BluetoothRemoveDevice*(pAddress: ptr BLUETOOTH_ADDRESS): DWORD {. stdcall, importc: "BluetoothRemoveDevice", dynlib: libbluetooth.} when not (hostCPU == "arm"): # # *************************************************************************** # # Device Picker Dialog # # Description: # Invokes a common dialog for selecting Bluetooth devices. The list # of devices displayed to the user is determined by the flags and # settings the caller specifies in the BLUETOOTH_SELECT_DEVICE_PARAMS # (see structure definition for more details). # # If BluetoothSelectDevices() returns TRUE, the caller must call # BluetoothSelectDevicesFree() or memory will be leaked within the # process. # # Sample Usage: # # BLUETOOTH_SELECT_DEVICE_PARAMS btsdp = { sizeof(btsdp) }; # # btsdp.hwndParent = hDlg; # btsdp.fShowUnknown = TRUE; # btsdp.fAddNewDeviceWizard = TRUE; # # BOOL b = BluetoothSelectDevices( &btsdp ); # if ( b ) # { # BLUETOOTH_DEVICE_INFO * pbtdi = btsdp.pDevices; # for ( ULONG cDevice = 0; cDevice < btsdp.cNumDevices; cDevice ++ ) # { # if ( pbtdi->fAuthenticated || pbtdi->fRemembered ) # { # // # // TODO: Do something usefull with the device info # // # } # # pbtdi = (BLUETOOTH_DEVICE_INFO *) ((LPBYTE)pbtdi + pbtdi->dwSize); # } # # BluetoothSelectDevicesFree( &btsdp ); # } # # # *************************************************************************** type BLUETOOTH_COD_PAIRS* = object ulCODMask*: ULONG # ClassOfDevice mask to compare pcszDescription*: LPCWSTR # Descriptive string of mask PFN_DEVICE_CALLBACK* = proc (pvParam: LPVOID; pDevice: ptr BLUETOOTH_DEVICE_INFO): BOOL {. stdcall.} BLUETOOTH_SELECT_DEVICE_PARAMS* = object dwSize*: DWORD # IN sizeof this structure cNumOfClasses*: ULONG # IN Number in prgClassOfDevice - if ZERO search for all devices prgClassOfDevices*: ptr BLUETOOTH_COD_PAIRS # IN Array of CODs to find. pszInfo*: LPWSTR # IN If not NULL, sets the "information" text hwndParent*: HWND # IN parent window - NULL == no parent fForceAuthentication*: BOOL # IN If TRUE, authenication will be forced before returning fShowAuthenticated*: BOOL # IN If TRUE, authenticated devices will be shown in the picker fShowRemembered*: BOOL # IN If TRUE, remembered devices will be shown in the picker fShowUnknown*: BOOL # IN If TRUE, unknown devices that are not authenticated or "remember" will be shown. fAddNewDeviceWizard*: BOOL # IN If TRUE, invokes the add new device wizard. fSkipServicesPage*: BOOL # IN If TRUE, skips the "Services" page in the wizard. pfnDeviceCallback*: PFN_DEVICE_CALLBACK # IN If non-NULL, a callback that will be called for each device. If the # the callback returns TRUE, the item will be added. If the callback is # is FALSE, the item will not be shown. pvParam*: LPVOID # IN Parameter to be passed to pfnDeviceCallback as the pvParam. cNumDevices*: DWORD # IN number calles wants - ZERO == no limit. # OUT the number of devices returned. pDevices*: PBLUETOOTH_DEVICE_INFO # OUT pointer to an array for BLUETOOTH_DEVICE_INFOs. # call BluetoothSelectDevicesFree() to free # # Description: # (See header above) # # Return Values: # TRUE # User selected a device. pbtsdp->pDevices points to valid data. # Caller should check the fAuthenticated && fRemembered flags to # determine which devices we successfuly authenticated or valid # selections by the user. # # Use BluetoothSelectDevicesFree() to free the nessecary data # such as pDevices only if this function returns TRUE. # # FALSE # No valid data returned. Call GetLastError() for possible details # of the failure. If GLE() is: # # ERROR_CANCELLED # The user cancelled the request. # # ERROR_INVALID_PARAMETER # The pbtsdp is NULL. # # ERROR_REVISION_MISMATCH # The structure passed in as pbtsdp is of an unknown size. # # other WIN32 errors # proc BluetoothSelectDevices*(pbtsdp: ptr BLUETOOTH_SELECT_DEVICE_PARAMS): BOOL {. stdcall, importc: "BluetoothSelectDevices", dynlib: libbluetooth.} # # Description: # This function should only be called if BluetoothSelectDevices() returns # TRUE. This function will free any memory and resource returned by the # BluetoothSelectDevices() in the BLUETOOTH_SELECT_DEVICE_PARAMS # structure. # # Return Values: # TRUE # Success. # # FALSE # Nothing to free. # proc BluetoothSelectDevicesFree*(pbtsdp: ptr BLUETOOTH_SELECT_DEVICE_PARAMS): BOOL {. stdcall, importc: "BluetoothSelectDevicesFree", dynlib: libbluetooth.} # *************************************************************************** # # Device Property Sheet # # *************************************************************************** # # Description: # Invokes the CPLs device info property sheet. # # Parameters: # hwndParent # HWND to parent the property sheet. # # pbtdi # A pointer to a BLUETOOTH_DEVICE_INFO structure of the device # to be displayed. # # Return Values: # TRUE # The property page was successfully displayed. # # FALSE # Failure. The property page was not displayed. Check GetLastError # for more details. # proc BluetoothDisplayDeviceProperties*(hwndParent: HWND; pbtdi: ptr BLUETOOTH_DEVICE_INFO): BOOL {.stdcall, importc: "BluetoothDisplayDeviceProperties", dynlib: libbluetooth.} # *************************************************************************** # # Radio Authentication # # *************************************************************************** # # Description: # Sends an authentication request to a remote device. # # There are two modes of operation. "Wizard mode" and "Blind mode." # # "Wizard mode" is invoked when the pszPasskey is NULL. This will cause # the "Bluetooth Connection Wizard" to be invoked. The user will be # prompted to enter a passkey during the wizard after which the # authentication request will be sent. The user will see the success # or failure of the authentication attempt. The user will also be # given the oppurtunity to try to fix a failed authentication. # # "Blind mode" is invoked when the pszPasskey is non-NULL. This will # cause the computer to send a authentication request to the remote # device. No UI is ever displayed. The Bluetooth status code will be # mapped to a Win32 Error code. # # Parameters: # # hwndParent # The window to parent the authentication wizard. If NULL, the # wizard will be parented off the desktop. # # hRadio # A valid local radio handle or NULL. If NULL, then all radios will # be tired. If any of the radios succeed, then the call will # succeed. # # pbtdi # BLUETOOTH_DEVICE_INFO record of the device to be authenticated. # # pszPasskey # PIN to be used to authenticate the device. If NULL, then UI is # displayed and the user steps through the authentication process. # If not NULL, no UI is shown. The passkey is NOT NULL terminated. # # ulPasskeyLength # Length of szPassKey in bytes. The length must be less than or # equal to BLUETOOTH_MAX_PASSKEY_SIZE * sizeof(WCHAR). # # Return Values: # # ERROR_SUCCESS # Success. # # ERROR_CANCELLED # User aborted the operation. # # ERROR_INVALID_PARAMETER # The device structure in pbtdi is invalid. # # ERROR_NO_MORE_ITEMS # The device in pbtdi is already been marked as authenticated. # # other WIN32 error # Failure. Return value is the error code. # # For "Blind mode," here is the current mapping of Bluetooth status # code to Win32 error codes: # # { BTH_ERROR_SUCCESS, ERROR_SUCCESS }, # { BTH_ERROR_NO_CONNECTION, ERROR_DEVICE_NOT_CONNECTED }, # { BTH_ERROR_PAGE_TIMEOUT, WAIT_TIMEOUT }, # { BTH_ERROR_HARDWARE_FAILURE, ERROR_GEN_FAILURE }, # { BTH_ERROR_AUTHENTICATION_FAILURE, ERROR_NOT_AUTHENTICATED }, # { BTH_ERROR_MEMORY_FULL, ERROR_NOT_ENOUGH_MEMORY }, # { BTH_ERROR_CONNECTION_TIMEOUT, WAIT_TIMEOUT }, # { BTH_ERROR_LMP_RESPONSE_TIMEOUT, WAIT_TIMEOUT }, # { BTH_ERROR_MAX_NUMBER_OF_CONNECTIONS, ERROR_REQ_NOT_ACCEP }, # { BTH_ERROR_PAIRING_NOT_ALLOWED, ERROR_ACCESS_DENIED }, # { BTH_ERROR_UNSPECIFIED_ERROR, ERROR_NOT_READY }, # { BTH_ERROR_LOCAL_HOST_TERMINATED_CONNECTION, ERROR_VC_DISCONNECTED }, # proc BluetoothAuthenticateDevice*(hwndParent: HWND; hRadio: HANDLE; pbtbi: ptr BLUETOOTH_DEVICE_INFO; pszPasskey: PWSTR; ulPasskeyLength: ULONG): DWORD {. stdcall, importc: "BluetoothAuthenticateDevice", dynlib: libbluetooth, deprecated.} # # Support added after KB942567 # # # Replaces previous API # # # Common header for all PIN related structures # type BLUETOOTH_PIN_INFO* = object pin*: array[BTH_MAX_PIN_SIZE, UCHAR] pinLength*: UCHAR PBLUETOOTH_PIN_INFO* = ptr BLUETOOTH_PIN_INFO BLUETOOTH_OOB_DATA_INFO* = object C*: array[16, UCHAR] R*: array[16, UCHAR] PBLUETOOTH_OOB_DATA_INFO* = ptr BLUETOOTH_OOB_DATA_INFO BLUETOOTH_NUMERIC_COMPARISON_INFO* = object NumericValue*: ULONG PBLUETOOTH_NUMERIC_COMPARISON_INFO* = ptr BLUETOOTH_NUMERIC_COMPARISON_INFO BLUETOOTH_PASSKEY_INFO* = object passkey*: ULONG PBLUETOOTH_PASSKEY_INFO* = ptr BLUETOOTH_PASSKEY_INFO # # Description: # Sends an authentication request to a remote device. # # There are two modes of operation. "Wizard mode" and "Blind mode." # # "Wizard mode" is invoked when the pbtOobData is NULL. This will cause # the "Bluetooth Connection Wizard" to be invoked. The user will be # prompted to respond to the device authentication during the wizard # after which the authentication request will be sent. The user will see the success # or failure of the authentication attempt. The user will also be # given the oppurtunity to try to fix a failed authentication. # # "Blind mode" is invoked when the pbtOobData is non-NULL. This will # cause the computer to send a authentication request to the remote # device. No UI is ever displayed. The Bluetooth status code will be # mapped to a Win32 Error code. # # Parameters: # # hwndParent # The window to parent the authentication wizard. If NULL, the # wizard will be parented off the desktop. # # hRadio # A valid local radio handle or NULL. If NULL, then all radios will # be tired. If any of the radios succeed, then the call will # succeed. # # pbtdi # BLUETOOTH_DEVICE_INFO record of the device to be authenticated. # # pbtOobData # Out of band data to be used to authenticate the device. If NULL, then UI is # displayed and the user steps through the authentication process. # If not NULL, no UI is shown. # # authenticationRequirement # The Authentication Requirement of the caller. MITMProtection* # # # Return Values: # # ERROR_SUCCESS # Success. # # ERROR_CANCELLED # User aborted the operation. # # ERROR_INVALID_PARAMETER # The device structure in pbtdi is invalid. # # ERROR_NO_MORE_ITEMS # The device in pbtdi is already been marked as authenticated. # # other WIN32 error # Failure. Return value is the error code. # # For "Blind mode," here is the current mapping of Bluetooth status # code to Win32 error codes: # # { BTH_ERROR_SUCCESS, ERROR_SUCCESS }, # { BTH_ERROR_NO_CONNECTION, ERROR_DEVICE_NOT_CONNECTED }, # { BTH_ERROR_PAGE_TIMEOUT, WAIT_TIMEOUT }, # { BTH_ERROR_HARDWARE_FAILURE, ERROR_GEN_FAILURE }, # { BTH_ERROR_AUTHENTICATION_FAILURE, ERROR_NOT_AUTHENTICATED }, # { BTH_ERROR_MEMORY_FULL, ERROR_NOT_ENOUGH_MEMORY }, # { BTH_ERROR_CONNECTION_TIMEOUT, WAIT_TIMEOUT }, # { BTH_ERROR_LMP_RESPONSE_TIMEOUT, WAIT_TIMEOUT }, # { BTH_ERROR_MAX_NUMBER_OF_CONNECTIONS, ERROR_REQ_NOT_ACCEP }, # { BTH_ERROR_PAIRING_NOT_ALLOWED, ERROR_ACCESS_DENIED }, # { BTH_ERROR_UNSPECIFIED_ERROR, ERROR_NOT_READY }, # { BTH_ERROR_LOCAL_HOST_TERMINATED_CONNECTION, ERROR_VC_DISCONNECTED }, # proc BluetoothAuthenticateDeviceEx*(hwndParentIn: HWND; hRadioIn: HANDLE; pbtdiInout: ptr BLUETOOTH_DEVICE_INFO; pbtOobData: PBLUETOOTH_OOB_DATA_INFO; authenticationRequirement: BLUETOOTH_AUTHENTICATION_REQUIREMENTS): DWORD {. stdcall, importc: "BluetoothAuthenticateDeviceEx", dynlib: libbluetooth.} # # Description: # Allows the caller to prompt for multiple devices to be authenticated # within a single instance of the "Bluetooth Connection Wizard." # # Parameters: # # hwndParent # The window to parent the authentication wizard. If NULL, the # wizard will be parented off the desktop. # # hRadio # A valid local radio handle or NULL. If NULL, then all radios will # be tired. If any of the radios succeed, then the call will # succeed. # # cDevices # Number of devices in the rgbtdi array. # # rgbtdi # An array BLUETOOTH_DEVICE_INFO records of the devices to be # authenticated. # # Return Values: # # ERROR_SUCCESS # Success. Check the fAuthenticate flag on each of the devices. # # ERROR_CANCELLED # User aborted the operation. Check the fAuthenticate flags on # each device to determine if any of the devices were authenticated # before the user cancelled the operation. # # ERROR_INVALID_PARAMETER # One of the items in the array of devices is invalid. # # ERROR_NO_MORE_ITEMS # All the devices in the array of devices are already been marked as # being authenticated. # # other WIN32 error # Failure. Return value is the error code. # proc BluetoothAuthenticateMultipleDevices*(hwndParent: HWND; hRadio: HANDLE; cDevices: DWORD; rgbtdi: ptr BLUETOOTH_DEVICE_INFO): DWORD {.stdcall, importc: "BluetoothAuthenticateMultipleDevices", dynlib: libbluetooth, deprecated.} # # Deprecated after Vista SP1 and KB942567 # # *************************************************************************** # # Bluetooth Services # # *************************************************************************** const BLUETOOTH_SERVICE_DISABLE* = 0x00000000 BLUETOOTH_SERVICE_ENABLE* = 0x00000001 BLUETOOTH_SERVICE_MASK* = ( BLUETOOTH_SERVICE_DISABLE or BLUETOOTH_SERVICE_ENABLE) # # Description: # Enables/disables the services for a particular device. # # The system maintains a mapping of service guids to supported drivers for # Bluetooth-enabled devices. Enabling a service installs the corresponding # device driver. Disabling a service removes the corresponding device driver. # # If a non-supported service is enabled, a driver will not be installed. # # Parameters # hRadio # Handle of the local Bluetooth radio device. # # pbtdi # Pointer to a BLUETOOTH_DEVICE_INFO record. # # pGuidService # The service GUID on the remote device. # # dwServiceFlags # Flags to adjust the service. # BLUETOOTH_SERVICE_DISABLE - disable the service # BLUETOOTH_SERVICE_ENABLE - enables the service # # Return Values: # ERROR_SUCCESS # The call was successful. # # ERROR_INVALID_PARAMETER # dwServiceFlags are invalid. # # ERROR_SERVICE_DOES_NOT_EXIST # The GUID in pGuidService is not supported. # # other WIN32 error # The call failed. # proc BluetoothSetServiceState*(hRadio: HANDLE; pbtdi: ptr BLUETOOTH_DEVICE_INFO; pGuidService: ptr GUID; dwServiceFlags: DWORD): DWORD {. stdcall, importc: "BluetoothSetServiceState", dynlib: libbluetooth.} # # Description: # Enumerates the services guids enabled on a particular device. If hRadio # is NULL, all device will be searched for the device and all the services # enabled will be returned. # # Parameters: # hRadio # Handle of the local Bluetooth radio device. If NULL, it will search # all the radios for the address in the pbtdi. # # pbtdi # Pointer to a BLUETOOTH_DEVICE_INFO record. # # pcService # On input, the number of records pointed to by pGuidServices. # On output, the number of valid records return in pGuidServices. # # pGuidServices # Pointer to memory that is at least *pcService in length. # # Return Values: # ERROR_SUCCESS # The call succeeded. pGuidServices is valid. # # ERROR_MORE_DATA # The call succeeded. pGuidService contains an incomplete list of # enabled service GUIDs. # # other WIN32 errors # The call failed. # proc BluetoothEnumerateInstalledServices*(hRadio: HANDLE; pbtdi: ptr BLUETOOTH_DEVICE_INFO; pcServiceInout: ptr DWORD; pGuidServices: ptr GUID): DWORD {.stdcall, importc: "BluetoothEnumerateInstalledServices", dynlib: libbluetooth.} # # Description: # Change the discovery state of the local radio(s). # If hRadio is NULL, all the radios will be set. # # Use BluetoothIsDiscoverable() to determine the radios current state. # # The system ensures that a discoverable system is connectable, thus # the radio must allow incoming connections (see # BluetoothEnableIncomingConnections) prior to making a radio # discoverable. Failure to do so will result in this call failing # (returns FALSE). # # Parameters: # hRadio # If not NULL, changes the state of a specific radio. # If NULL, the API will interate through all the radios. # # fEnabled # If FALSE, discovery will be disabled. # # Return Values # TRUE # State was successfully changed. If the caller specified NULL for # hRadio, at least of the radios accepted the state change. # # FALSE # State was not changed. If the caller specified NULL for hRadio, all # of the radios did not accept the state change. # proc BluetoothEnableDiscovery*(hRadio: HANDLE; fEnabled: BOOL): BOOL {. stdcall, importc: "BluetoothEnableDiscovery", dynlib: libbluetooth.} # # Description: # Determines if the Bluetooth radios are discoverable. If there are # multiple radios, the first one to say it is discoverable will cause # this function to return TRUE. # # Parameters: # hRadio # Handle of the radio to check. If NULL, it will check all local # radios. # # Return Values: # TRUE # A least one radio is discoverable. # # FALSE # No radios are discoverable. # proc BluetoothIsDiscoverable*(hRadio: HANDLE): BOOL {.stdcall, importc: "BluetoothIsDiscoverable", dynlib: libbluetooth.} # # Description: # Enables/disables the state of a radio to accept incoming connections. # If hRadio is NULL, all the radios will be set. # # Use BluetoothIsConnectable() to determine the radios current state. # # The system enforces that a radio that is not connectable is not # discoverable too. The radio must be made non-discoverable (see # BluetoothEnableDiscovery) prior to making a radio non-connectionable. # Failure to do so will result in this call failing (returns FALSE). # # Parameters: # hRadio # If not NULL, changes the state of a specific radio. # If NULL, the API will interate through all the radios. # # fEnabled # If FALSE, incoming connection will be disabled. # # Return Values # TRUE # State was successfully changed. If the caller specified NULL for # hRadio, at least of the radios accepted the state change. # # FALSE # State was not changed. If the caller specified NULL for hRadio, all # of the radios did not accept the state change. # proc BluetoothEnableIncomingConnections*(hRadio: HANDLE; fEnabled: BOOL): BOOL {. stdcall, importc: "BluetoothEnableIncomingConnections", dynlib: libbluetooth.} # # Description: # Determines if the Bluetooth radios are connectable. If there are # multiple radios, the first one to say it is connectable will cause # this function to return TRUE. # # Parameters: # hRadio # Handle of the radio to check. If NULL, it will check all local # radios. # # Return Values: # TRUE # A least one radio is allowing incoming connections. # # FALSE # No radios are allowing incoming connections. # proc BluetoothIsConnectable*(hRadio: HANDLE): BOOL {.stdcall, importc: "BluetoothIsConnectable", dynlib: libbluetooth.} # *************************************************************************** # # Authentication Registration # # *************************************************************************** type HBLUETOOTH_AUTHENTICATION_REGISTRATION* = HANDLE PFN_AUTHENTICATION_CALLBACK* = proc (pvParam: LPVOID; pDevice: PBLUETOOTH_DEVICE_INFO): BOOL {.stdcall.} # # Description: # Registers a callback function to be called when a particular device # requests authentication. The request is sent to the last application # that requested authentication for a particular device. # # Parameters: # pbtdi # A pointer to a BLUETOOTH_DEVICE_INFO structure. The Bluetooth # address will be used for comparision. # # phRegHandle # A pointer to where the registration HANDLE value will be # stored. Call BluetoothUnregisterAuthentication() to close # the handle. # # pfnCallback # The function that will be called when the authentication event # occurs. This function should match PFN_AUTHENTICATION_CALLBACK's # prototype. # # pvParam # Optional parameter to be past through to the callback function. # This can be anything the application was to define. # # Return Values: # ERROR_SUCCESS # Success. A valid registration handle was returned. # # ERROR_OUTOFMEMORY # Out of memory. # # other Win32 error. # Failure. The registration handle is invalid. # proc BluetoothRegisterForAuthentication*(pbtdi: ptr BLUETOOTH_DEVICE_INFO; phRegHandle: ptr HBLUETOOTH_AUTHENTICATION_REGISTRATION; pfnCallback: PFN_AUTHENTICATION_CALLBACK; pvParam: PVOID): DWORD {. stdcall, importc: "BluetoothRegisterForAuthentication", dynlib: libbluetooth, deprecated.} # # Support added in KB942567 # # # Replaces previous API # type PFN_AUTHENTICATION_CALLBACK_EX* = proc (pvParam: LPVOID; pAuthCallbackParams: PBLUETOOTH_AUTHENTICATION_CALLBACK_PARAMS): BOOL {. stdcall.} # # Description: # Registers a callback function to be called when a particular device # requests authentication. The request is sent to the last application # that requested authentication for a particular device. # # Parameters: # pbtdi # A pointer to a BLUETOOTH_DEVICE_INFO structure. The Bluetooth # address will be used for comparision. # # phRegHandle # A pointer to where the registration HANDLE value will be # stored. Call BluetoothUnregisterAuthentication() to close # the handle. # # pfnCallback # The function that will be called when the authentication event # occurs. This function should match PFN_AUTHENTICATION_CALLBACK_EX's # prototype. # # pvParam # Optional parameter to be past through to the callback function. # This can be anything the application was to define. # # Return Values: # ERROR_SUCCESS # Success. A valid registration handle was returned. # # ERROR_OUTOFMEMORY # Out of memory. # # other Win32 error. # Failure. The registration handle is invalid. # proc BluetoothRegisterForAuthenticationEx*( pbtdiIn: ptr BLUETOOTH_DEVICE_INFO; phRegHandleOut: ptr HBLUETOOTH_AUTHENTICATION_REGISTRATION; pfnCallbackIn: PFN_AUTHENTICATION_CALLBACK_EX; pvParam: PVOID): DWORD {. stdcall, importc: "BluetoothRegisterForAuthenticationEx", dynlib: libbluetooth.} # # Description: # Unregisters an authentication callback and closes the handle. See # BluetoothRegisterForAuthentication() for more information about # authentication registration. # # Parameters: # hRegHandle # Handle returned by BluetoothRegisterForAuthentication(). # # Return Value: # TRUE # The handle was successfully closed. # # FALSE # The handle was not successfully closed. Check GetLastError for # more details. # # ERROR_INVALID_HANDLE # The handle is NULL. # # other Win32 errors. # proc BluetoothUnregisterAuthentication*( hRegHandle: HBLUETOOTH_AUTHENTICATION_REGISTRATION): BOOL {.stdcall, importc: "BluetoothUnregisterAuthentication", dynlib: libbluetooth.} # # Description: # This function should be called after receiving an authentication request # to send the passkey response. # # Parameters: # # hRadio # Optional handle to the local radio. If NULL, the function will try # each radio until one succeeds. # # pbtdi # A pointer to a BLUETOOTH_DEVICE_INFO structure describing the device # being authenticated. This can be the same structure passed to the # callback function. # # pszPasskey # A pointer to UNICODE zero-terminated string of the passkey response # that should be sent back to the authenticating device. # # Return Values: # ERROR_SUCESS # The device accepted the passkey response. The device is authenticated. # # ERROR_CANCELED # The device denied the passkey reponse. This also will returned if there # is a communications problem with the local radio. # # E_FAIL # The device returned a failure code during authentication. # # other Win32 error codes # proc BluetoothSendAuthenticationResponse*(hRadio: HANDLE; pbtdi: ptr BLUETOOTH_DEVICE_INFO; pszPasskey: LPCWSTR): DWORD {.stdcall, importc: "BluetoothSendAuthenticationResponse", dynlib: libbluetooth, deprecated.} # # Support added in KB942567 # # # Replaces previous API # # # Structure used when responding to BTH_REMOTE_AUTHENTICATE_REQUEST event # type INNER_C_UNION_1965546500* = object {.union.} pinInfo*: BLUETOOTH_PIN_INFO oobInfo*: BLUETOOTH_OOB_DATA_INFO numericCompInfo*: BLUETOOTH_NUMERIC_COMPARISON_INFO passkeyInfo*: BLUETOOTH_PASSKEY_INFO type BLUETOOTH_AUTHENTICATE_RESPONSE* = object bthAddressRemote*: BLUETOOTH_ADDRESS authMethod*: BLUETOOTH_AUTHENTICATION_METHOD ano_660658457*: INNER_C_UNION_1965546500 negativeResponse*: UCHAR PBLUETOOTH_AUTHENTICATE_RESPONSE* = ptr BLUETOOTH_AUTHENTICATE_RESPONSE # # Description: # This function should be called after receiving an authentication request # to send the authentication response. (Bluetooth 2.1 and above) # # Parameters: # # hRadio # Optional handle to the local radio. If NULL, the function will try # each radio until one succeeds. # # pbtdi # A pointer to a BLUETOOTH_DEVICE_INFO structure describing the device # being authenticated. This can be the same structure passed to the # callback function. # # pauthResponse # A pointer to a BTH_AUTHENTICATION_RESPONSE structure. # # Return Values: # ERROR_SUCESS # The device accepted the passkey response. The device is authenticated. # # ERROR_CANCELED # The device denied the passkey reponse. This also will returned if there # is a communications problem with the local radio. # # E_FAIL # The device returned a failure code during authentication. # # other Win32 error codes # proc BluetoothSendAuthenticationResponseEx*(hRadioIn: HANDLE; pauthResponse: PBLUETOOTH_AUTHENTICATE_RESPONSE): DWORD {.stdcall, importc: "BluetoothSendAuthenticationResponseEx", dynlib: libbluetooth.} # *************************************************************************** # # SDP Parsing Functions # # *************************************************************************** type INNER_C_STRUCT_3139021411* = object value*: LPBYTE # raw string buffer, may not be encoded as ANSI, use # BluetoothSdpGetString to convert the value if it is described # by the base language attribute ID list # raw length of the string, may not be NULL terminuated length*: ULONG type INNER_C_STRUCT_467337881* = object value*: LPBYTE length*: ULONG type INNER_C_STRUCT_4155600511* = object value*: LPBYTE # raw sequence, starts at sequence element header # raw sequence length length*: ULONG type INNER_C_STRUCT_1234813489* = object value*: LPBYTE # raw alternative, starts at alternative element header # raw alternative length length*: ULONG type INNER_C_UNION_122694421* = object {.union.} int128*: SDP_LARGE_INTEGER_16 # type == SDP_TYPE_INT # specificType == SDP_ST_INT128 int64*: LONGLONG # specificType == SDP_ST_INT64 int32*: LONG # specificType == SDP_ST_INT32 int16*: SHORT # specificType == SDP_ST_INT16 int8*: CHAR # specificType == SDP_ST_INT8 # type == SDP_TYPE_UINT uint128*: SDP_ULARGE_INTEGER_16 # specificType == SDP_ST_UINT128 uint64*: ULONGLONG # specificType == SDP_ST_UINT64 uint32*: ULONG # specificType == SDP_ST_UINT32 uint16*: USHORT # specificType == SDP_ST_UINT16 uint8*: UCHAR # specificType == SDP_ST_UINT8 # type == SDP_TYPE_BOOLEAN booleanVal*: UCHAR # type == SDP_TYPE_UUID uuid128*: GUID # specificType == SDP_ST_UUID128 uuid32*: ULONG # specificType == SDP_ST_UUID32 uuid16*: USHORT # specificType == SDP_ST_UUID32 # type == SDP_TYPE_STRING string*: INNER_C_STRUCT_3139021411 # type == SDP_TYPE_URL url*: INNER_C_STRUCT_467337881 # type == SDP_TYPE_SEQUENCE sequence*: INNER_C_STRUCT_4155600511 # type == SDP_TYPE_ALTERNATIVE alternative*: INNER_C_STRUCT_1234813489 type SDP_ELEMENT_DATA* = object `type`*: SDP_TYPE # # Enumeration of SDP element types. Generic element types will have a # specificType value other then SDP_ST_NONE. The generic types are: # o SDP_TYPE_UINT # o SDP_TYPE_INT # o SDP_TYPE_UUID # # # Specific types for the generic SDP element types. # specificType*: SDP_SPECIFICTYPE # # Union of all possible data types. type and specificType will indicate # which field is valid. For types which do not have a valid specificType, # specific type will be SDP_ST_NONE. # data*: INNER_C_UNION_122694421 PSDP_ELEMENT_DATA* = ptr SDP_ELEMENT_DATA # # Description: # Retrieves and parses the element found at pSdpStream # # Parameters: # IN pSdpStream # pointer to valid SDP stream # # IN cbSdpStreamLength # length of pSdpStream in bytes # # OUT pData # pointer to be filled in with the data of the SDP element at the # beginning of pSdpStream # # Return Values: # ERROR_INVALID_PARAMETER # one of required parameters is NULL or the pSdpStream is invalid # # ERROR_SUCCESS # the sdp element was parsed correctly # proc BluetoothSdpGetElementData*(pSdpStream: LPBYTE; cbSdpStreamLength: ULONG; pData: PSDP_ELEMENT_DATA): DWORD {.stdcall, importc: "BluetoothSdpGetElementData", dynlib: libbluetooth.} type HBLUETOOTH_CONTAINER_ELEMENT* = HANDLE # # Description: # Iterates over a container stream, returning each elemetn contained with # in the container element at the beginning of pContainerStream # # Parameters: # IN pContainerStream # pointer to valid SDP stream whose first element is either a sequence # or alternative # # IN cbContainerlength # length in bytes of pContainerStream # # IN OUT pElement # Value used to keep track of location within the stream. The first # time this function is called for a particular container, *pElement # should equal NULL. Upon subsequent calls, the value should be # unmodified. # # OUT pData # pointer to be filled in with the data of the SDP element at the # current element of pContainerStream # # Return Values: # ERROR_SUCCESS # The call succeeded, pData contains the data # # ERROR_NO_MORE_ITEMS # There are no more items in the list, the caller should cease calling # BluetoothSdpGetContainerElementData for this container. # # ERROR_INVALID_PARAMETER # A required pointer is NULL or the container is not a valid SDP # stream # # Usage example: # # HBLUETOOTH_CONTAINER_ELEMENT element; # SDP_ELEMENT_DATA data; # ULONG result; # # element = NULL; # # while (TRUE) { # result = BluetoothSdpGetContainerElementData( # pContainer, ulContainerLength, &element, &data); # # if (result == ERROR_NO_MORE_ITEMS) { # // We are done # break; # } # else if (result != ERROR_SUCCESS) { # // error # } # # // do something with data ... # } # # proc BluetoothSdpGetContainerElementData*(pContainerStream: LPBYTE; cbContainerLength: ULONG; pElement: ptr HBLUETOOTH_CONTAINER_ELEMENT; pData: PSDP_ELEMENT_DATA): DWORD {.stdcall, importc: "BluetoothSdpGetContainerElementData", dynlib: libbluetooth.} # # Description: # Retrieves the attribute value for the given attribute ID. pRecordStream # must be an SDP stream that is formatted as an SDP record, a SEQUENCE # containing UINT16 + element pairs. # # Parameters: # IN pRecordStream # pointer to a valid SDP stream which is formatted as a singl SDP # record # # IN cbRecordlnegh # length of pRecordStream in bytes # # IN usAttributeId # the attribute ID to search for. see bthdef.h for SDP_ATTRIB_Xxx # values. # # OUT pAttributeData # pointer that will contain the attribute ID's value # # Return Values: # ERRROR_SUCCESS # Call succeeded, pAttributeData contains the attribute value # # ERROR_INVALID_PARAMETER # One of the required pointers was NULL, pRecordStream was not a valid # SDP stream, or pRecordStream was not a properly formatted SDP record # # ERROR_FILE_NOT_FOUND # usAttributeId was not found in the record # # Usage: # # ULONG result; # SDP_DATA_ELEMENT data; # # result = BluetoothSdpGetAttributeValue( # pRecordStream, cbRecordLength, SDP_ATTRIB_RECORD_HANDLE, &data); # if (result == ERROR_SUCCESS) { # printf("record handle is 0x%x\n", data.data.uint32); # } # proc BluetoothSdpGetAttributeValue*(pRecordStream: LPBYTE; cbRecordLength: ULONG; usAttributeId: USHORT; pAttributeData: PSDP_ELEMENT_DATA): DWORD {. stdcall, importc: "BluetoothSdpGetAttributeValue", dynlib: libbluetooth.} # # These three fields correspond one to one with the triplets defined in the # SDP specification for the language base attribute ID list. # type SDP_STRING_TYPE_DATA* = object encoding*: USHORT # # How the string is encoded according to ISO 639:1988 (E/F): "Code # for the representation of names of languages". # # # MIBE number from IANA database # mibeNum*: USHORT # # The base attribute where the string is to be found in the record # attributeId*: USHORT PSDP_STRING_TYPE_DATA* = ptr SDP_STRING_TYPE_DATA # # Description: # Converts a raw string embedded in the SDP record into a UNICODE string # # Parameters: # IN pRecordStream # a valid SDP stream which is formatted as an SDP record # # IN cbRecordLength # length of pRecordStream in bytes # # IN pStringData # if NULL, then the calling thread's locale will be used to search # for a matching string in the SDP record. If not NUL, the mibeNum # and attributeId will be used to find the string to convert. # # IN usStringOffset # the SDP string type offset to convert. usStringOffset is added to # the base attribute id of the string. SDP specification defined # offsets are: STRING_NAME_OFFSET, STRING_DESCRIPTION_OFFSET, and # STRING_PROVIDER_NAME_OFFSET (found in bthdef.h). # # OUT pszString # if NULL, pcchStringLength will be filled in with the required number # of characters (not bytes) to retrieve the converted string. # # IN OUT pcchStringLength # Upon input, if pszString is not NULL, will contain the length of # pszString in characters. Upon output, it will contain either the # number of required characters including NULL if an error is returned # or the number of characters written to pszString (including NULL). # # Return Values: # ERROR_SUCCES # Call was successful and pszString contains the converted string # # ERROR_MORE_DATA # pszString was NULL or too small to contain the converted string, # pccxhStringLength contains the required length in characters # # ERROR_INVALID_DATA # Could not perform the conversion # # ERROR_NO_SYSTEM_RESOURCES # Could not allocate memory internally to perform the conversion # # ERROR_INVALID_PARAMETER # One of the rquired pointers was NULL, pRecordStream was not a valid # SDP stream, pRecordStream was not a properly formatted record, or # the desired attribute + offset was not a string. # # Other HRESULTs returned by COM # proc BluetoothSdpGetString*(pRecordStream: LPBYTE; cbRecordLength: ULONG; pStringData: PSDP_STRING_TYPE_DATA; usStringOffset: USHORT; pszString: PWSTR; pcchStringLength: PULONG): DWORD {.stdcall, importc: "BluetoothSdpGetString", dynlib: libbluetooth.} # *************************************************************************** # # Raw Attribute Enumeration # # *************************************************************************** type PFN_BLUETOOTH_ENUM_ATTRIBUTES_CALLBACK* = proc (uAttribId: ULONG; pValueStream: LPBYTE; cbStreamSize: ULONG; pvParam: LPVOID): BOOL {. stdcall.} # # Description: # Enumerates through the SDP record stream calling the Callback function # for each attribute in the record. If the Callback function returns # FALSE, the enumeration is stopped. # # Return Values: # TRUE # Success! Something was enumerated. # # FALSE # Failure. GetLastError() could be one of the following: # # ERROR_INVALID_PARAMETER # pSDPStream or pfnCallback is NULL. # # ERROR_INVALID_DATA # The SDP stream is corrupt. # # other Win32 errors. # proc BluetoothSdpEnumAttributes*(pSDPStream: LPBYTE; cbStreamSize: ULONG; pfnCallback: PFN_BLUETOOTH_ENUM_ATTRIBUTES_CALLBACK; pvParam: LPVOID): BOOL {. stdcall, importc: "BluetoothSdpEnumAttributes", dynlib: libbluetooth.} const BluetoothEnumAttributes* = BluetoothSdpEnumAttributes # # The following APIs are only available on Vista or later # proc BluetoothSetLocalServiceInfo*(hRadioIn: HANDLE; pClassGuid: ptr GUID; ulInstance: ULONG; pServiceInfoIn: ptr BLUETOOTH_LOCAL_SERVICE_INFO): DWORD {. stdcall, importc: "BluetoothSetLocalServiceInfo", dynlib: libbluetooth.} # # Support added in KB942567 # # # IsBluetoothVersionAvailable # # Description: # Indicate if the installed Bluetooth binary set supports # the requested version # # Return Values: # TRUE if the installed bluetooth binaries support the given # Major & Minor versions # # Note this function is only exported in version 2.1 and later. # proc BluetoothIsVersionAvailable*(MajorVersion: UCHAR; MinorVersion: UCHAR): BOOL {. stdcall, importc: "BluetoothIsVersionAvailable", dynlib: libbluetooth.}