bluetooth 1.0

data/ext/bluetooth/linux/ruby_bluetooth.h

@@ -0,0 +1,68 @@
+#include <unistd.h>
+#include <sys/socket.h>
+#include <bluetooth/bluetooth.h>
+#include <bluetooth/rfcomm.h>
+#include <bluetooth/l2cap.h>
+#include <bluetooth/hci.h>
+#include <bluetooth/hci_lib.h>
+#include <bluetooth/sdp.h>
+#include <bluetooth/sdp_lib.h>
+
+// Prototype for the initialization method - Ruby calls this, not you
+void Init_ruby_bluetooth();
+
+struct bluetooth_device_struct
+{
+    VALUE addr;
+    VALUE name;
+};
+
+struct bluetooth_service_struct
+{
+    VALUE uuid;
+    VALUE name;
+    VALUE description;
+    VALUE provider;
+    VALUE registered;
+	sdp_session_t *session;
+};
+
+static VALUE bt_device_new(VALUE self, VALUE name, VALUE addr);
+
+static VALUE bt_devices_scan(VALUE self);
+
+static int bt_ruby_socket(int domain, int type, int proto);
+
+static VALUE bt_init_sock(VALUE sock, int fd);
+
+static VALUE bt_socket_inspect(VALUE self);
+
+static VALUE bt_socket_s_for_fd(VALUE klass, VALUE fd);
+
+static VALUE bt_socket_listen(VALUE klass, VALUE backlog);
+
+static VALUE bt_socket_accept(VALUE sock);
+
+static VALUE bt_rfcomm_socket_init(int argc, VALUE *argv, VALUE sock);
+
+static VALUE bt_rfcomm_socket_connect(VALUE sock, VALUE host, VALUE port);
+
+static VALUE bt_rfcomm_socket_bind(VALUE sock, VALUE port);
+
+static VALUE bt_l2cap_socket_init(int argc, VALUE *argv, VALUE sock);
+
+static VALUE bt_l2cap_socket_connect(VALUE sock, VALUE host, VALUE port);
+
+static VALUE bt_l2cap_socket_bind(VALUE sock, VALUE port);
+
+static VALUE bt_service_new(VALUE self, VALUE uuid, VALUE name, VALUE description, VALUE provider);
+
+static VALUE bt_service_register(VALUE self, VALUE sock);
+
+static VALUE bt_service_unregister(VALUE self);
+
+static VALUE bt_service_registered(VALUE self);
+
+int str2uuid(char *uuid_str, uuid_t *uuid);
+
+static VALUE s_accept(VALUE klass, int fd, struct sockaddr *sockaddr, socklen_t *len);

data/ext/bluetooth/macosx/device.m

@@ -0,0 +1,230 @@
+#import "ruby_bluetooth.h"
+
+#import <IOBluetooth/objc/IOBluetoothDevicePair.h>
+
+static IOBluetoothDevice *rbt_device_get(VALUE self) {
+    BluetoothDeviceAddress address;
+    IOBluetoothDevice *device;
+    VALUE address_bytes;
+    char * tmp = NULL;
+
+    address_bytes = rb_funcall(self, rb_intern("address_bytes"), 0);
+
+    if (RSTRING_LEN(address_bytes) != 6) {
+        VALUE inspect = rb_inspect(address_bytes);
+        rb_raise(rb_eArgError, "%s doesn't look like a bluetooth address",
+                 StringValueCStr(inspect));
+    }
+
+    tmp = StringValuePtr(address_bytes);
+
+    memcpy(address.data, tmp, 6);
+
+    device = [IOBluetoothDevice withAddress: &address];
+
+    return device;
+}
+
+VALUE rbt_device_link_quality(VALUE self) {
+    HCIDelegate *delegate;
+    IOBluetoothDevice *device;
+    IOBluetoothHostController *controller;
+    IOReturn status;
+    NSAutoreleasePool *pool;
+
+    pool = [[NSAutoreleasePool alloc] init];
+
+    device = rbt_device_get(self);
+
+    delegate = [[HCIDelegate alloc] init];
+    delegate.device = self;
+
+    controller = [IOBluetoothHostController defaultController];
+    [controller setDelegate: delegate];
+
+    status = [controller readLinkQualityForDevice: device];
+
+    if (status != noErr) {
+        [pool release];
+        return Qfalse;
+    }
+
+    CFRunLoopRun();
+
+    [pool release];
+
+    status = (IOReturn)NUM2INT(rb_iv_get(self, "@link_quality_error"));
+
+    rbt_check_status(status, nil);
+
+    return rb_iv_get(self, "@link_quality");
+}
+
+VALUE rbt_device_open_connection(VALUE self) {
+    IOBluetoothDevice *device;
+    IOReturn status;
+    NSAutoreleasePool *pool;
+    VALUE result;
+
+    pool = [[NSAutoreleasePool alloc] init];
+
+    device = rbt_device_get(self);
+
+    if (![device isConnected]) {
+        status = [device openConnection];
+
+        rbt_check_status(status, pool);
+    }
+
+    result = rb_yield(Qundef);
+
+    status = [device closeConnection];
+
+    [pool release];
+
+    rbt_check_status(status, nil);
+
+    return result;
+}
+
+VALUE rbt_device_pair(VALUE self) {
+    PairingDelegate *delegate;
+    IOBluetoothDevice *device;
+    IOBluetoothDevicePair *device_pair;
+    IOReturn status;
+    NSAutoreleasePool *pool;
+
+    pool = [[NSAutoreleasePool alloc] init];
+
+    device = rbt_device_get(self);
+
+    delegate = [[PairingDelegate alloc] init];
+    delegate.device = self;
+
+    device_pair = [IOBluetoothDevicePair pairWithDevice: device];
+    [device_pair setDelegate: delegate];
+
+    status = [device_pair start];
+
+    rbt_check_status(status, pool);
+
+    CFRunLoopRun();
+
+    [pool release];
+
+    status = (IOReturn)NUM2INT(rb_iv_get(self, "@pair_error"));
+
+    rbt_check_status(status, nil);
+
+    return Qtrue;
+}
+
+VALUE rbt_device_request_name(VALUE self) {
+    IOBluetoothDevice *device;
+    IOReturn status;
+    VALUE name;
+    NSAutoreleasePool *pool;
+
+    pool = [[NSAutoreleasePool alloc] init];
+
+    device = rbt_device_get(self);
+
+    status = [device remoteNameRequest: nil];
+
+    rbt_check_status(status, pool);
+
+    name = rb_str_new2([[device name] UTF8String]);
+
+    [pool release];
+
+    return name;
+}
+
+VALUE rbt_device_rssi(VALUE self) {
+    HCIDelegate *delegate;
+    IOBluetoothDevice *device;
+    IOBluetoothHostController *controller;
+    IOReturn status;
+    NSAutoreleasePool *pool;
+
+    pool = [[NSAutoreleasePool alloc] init];
+
+    device = rbt_device_get(self);
+
+    delegate = [[HCIDelegate alloc] init];
+    delegate.device = self;
+
+    controller = [IOBluetoothHostController defaultController];
+    [controller setDelegate: delegate];
+
+    status = [controller readRSSIForDevice: device];
+
+    if (status != noErr) {
+        [pool release];
+        return Qfalse;
+    }
+
+    CFRunLoopRun();
+
+    [pool release];
+
+    status = (IOReturn)NUM2INT(rb_iv_get(self, "@rssi_error"));
+
+    rbt_check_status(status, nil);
+
+    return rb_iv_get(self, "@rssi");
+}
+
+@implementation PairingDelegate
+
+- (VALUE) device {
+    return device;
+}
+
+- (void) setDevice: (VALUE)input {
+    device = input;
+}
+
+- (void) devicePairingConnecting: (id)sender {
+}
+
+- (void) devicePairingStarted: (id)sender {
+}
+
+- (void) devicePairingFinished: (id)sender
+                         error: (IOReturn)error {
+    CFRunLoopStop(CFRunLoopGetCurrent());
+
+    rb_iv_set(device, "@pair_error", INT2NUM(error));
+}
+
+- (void) devicePairingPasskeyNotification: (id)sender
+				  passkey: (BluetoothPasskey)passkey {
+    printf("passkey %ld!  I don't know what to do!", (unsigned long)passkey);
+}
+
+- (void) devicePairingPINCodeRequest: (id)sender {
+    puts("PIN code! I don't know what to do!");
+}
+
+- (void) devicePairingUserConfirmationRequest: (id)sender
+				 numericValue: (BluetoothNumericValue)numericValue {
+    BOOL confirm;
+    VALUE result = Qtrue;
+    VALUE numeric_value = ULONG2NUM((unsigned long)numericValue);
+    VALUE callback = rb_iv_get(device, "@pair_confirmation_callback");
+
+    if (RTEST(callback))
+        result = rb_funcall(callback, rb_intern("call"), 1, numeric_value);
+
+    if (RTEST(result)) {
+        confirm = YES;
+    } else {
+        confirm = NO;
+    }
+
+    [sender replyUserConfirmation: confirm];
+}
+
+@end
+

data/ext/bluetooth/macosx/error.m

@@ -0,0 +1,269 @@
+#import "ruby_bluetooth.h"
+#import <IOKit/IOKitLib.h>
+
+extern VALUE rbt_mBluetooth;
+extern VALUE rbt_cBluetoothError;
+
+VALUE errors;
+
+void rbt_check_status(IOReturn status, NSAutoreleasePool *pool) {
+    if (status != kIOReturnSuccess || status != noErr) {
+        [pool release];
+
+        rb_funcall(rbt_cBluetoothError, rb_intern("raise"), 1, INT2NUM(status));
+    }
+}
+
+void add_error(IOReturn status, const char *name, const char *message) {
+    VALUE klass;
+    VALUE value;
+
+    klass = rb_define_class_under(rbt_mBluetooth, name, rbt_cBluetoothError);
+    value = rb_ary_new3(2, klass, rb_str_new2(message));
+    rb_hash_aset(errors, INT2NUM(status), value);
+}
+
+void init_rbt_error() {
+    VALUE tmp;
+
+    errors = rb_const_get(rbt_mBluetooth, rb_intern("ERRORS"));
+
+    tmp = rb_ary_new3(2, rbt_cBluetoothError, rb_str_new2("general error"));
+    rb_hash_aset(errors, INT2NUM(kIOReturnError), tmp);
+
+    // IOKit
+    add_error(kIOReturnNoMemory,         "NoMemoryError",
+            "can't allocate memory");
+    add_error(kIOReturnNoResources,      "NoResourcesError",
+            "resource shortage");
+    add_error(kIOReturnIPCError,         "IPCError",
+            "error during IPC");
+    add_error(kIOReturnNoDevice,         "NoDeviceError",
+            "no such device");
+    add_error(kIOReturnNotPrivileged,    "NotPrivilegedError",
+            "privilege violation");
+    add_error(kIOReturnBadArgument,      "BadArgumentError",
+            "invalid argument");
+    add_error(kIOReturnLockedRead,       "LockedReadError",
+            "device read locked");
+    add_error(kIOReturnLockedWrite,      "LockedWriteError",
+            "device write locked");
+    add_error(kIOReturnExclusiveAccess,  "ExclusiveAccessError",
+            "exclusive access and device already open");
+    add_error(kIOReturnBadMessageID,     "BadMessageIDError",
+            "sent/received messages had different msg_id");
+    add_error(kIOReturnUnsupported,      "UnsupportedError",
+            "unsupported function");
+    add_error(kIOReturnVMError,          "VMError",
+            "misc. VM failure");
+    add_error(kIOReturnInternalError,    "InternalError",
+            "internal error");
+    add_error(kIOReturnIOError,          "IOError",
+            "General I/O error");
+    add_error(kIOReturnCannotLock,       "CannotLockError",
+            "can't acquire lock");
+    add_error(kIOReturnNotOpen,          "NotOpenError",
+            "device not open");
+    add_error(kIOReturnNotReadable,      "NotReadableError",
+            "read not supported");
+    add_error(kIOReturnNotWritable,      "NotWritableError",
+            "write not supported");
+    add_error(kIOReturnNotAligned,       "NotAlignedError",
+            "alignment error");
+    add_error(kIOReturnBadMedia,         "BadMediaError",
+            "Media Error");
+    add_error(kIOReturnStillOpen,        "StillOpenError",
+            "device(s) still open");
+    add_error(kIOReturnRLDError,         "RLDError",
+            "rld failure");
+    add_error(kIOReturnDMAError,         "DMAError",
+            "DMA failure");
+    add_error(kIOReturnBusy,             "BusyError",
+            "Device Busy");
+    add_error(kIOReturnTimeout,          "TimeoutError",
+            "I/O Timeout");
+    add_error(kIOReturnOffline,          "OfflineError",
+            "device offline");
+    add_error(kIOReturnNotReady,         "NotReadyError",
+            "not ready");
+    add_error(kIOReturnNotAttached,      "NotAttachedError",
+            "device not attached");
+    add_error(kIOReturnNoChannels,       "NoChannelsError",
+            "no DMA channels left");
+    add_error(kIOReturnNoSpace,          "NoSpaceError",
+            "no space for data");
+    add_error(kIOReturnPortExists,       "PortExistsError",
+            "port already exists");
+    add_error(kIOReturnCannotWire,       "CannotWireError",
+            "can't wire down physical memory");
+    add_error(kIOReturnNoInterrupt,      "NoInterruptError",
+            "no interrupt attached");
+    add_error(kIOReturnNoFrames,         "NoFramesError",
+            "no DMA frames enqueued");
+    add_error(kIOReturnMessageTooLarge,  "MessageTooLargeError",
+            "oversized msg received on interrupt port");
+    add_error(kIOReturnNotPermitted,     "NotPermittedError",
+            "not permitted");
+    add_error(kIOReturnNoPower,          "NoPowerError",
+            "no power to device");
+    add_error(kIOReturnNoMedia,          "NoMediaError",
+            "media not present");
+    add_error(kIOReturnUnformattedMedia, "UnformattedMediaError",
+            "media not formatted");
+    add_error(kIOReturnUnsupportedMode,  "UnsupportedModeError",
+            "no such mode");
+    add_error(kIOReturnUnderrun,         "UnderrunError",
+            "data underrun");
+    add_error(kIOReturnOverrun,          "OverrunError",
+            "data overrun");
+    add_error(kIOReturnDeviceError,      "DeviceError",
+            "the device is not working properly!");
+    add_error(kIOReturnNoCompletion,     "NoCompletionError",
+            "a completion routine is required");
+    add_error(kIOReturnAborted,          "AbortedError",
+            "operation aborted");
+    add_error(kIOReturnNoBandwidth,      "NoBandwidthError",
+            "bus bandwidth would be exceeded");
+    add_error(kIOReturnNotResponding,    "NotRespondingError",
+            "device not responding");
+    add_error(kIOReturnIsoTooOld,        "IsoTooOldError",
+            "isochronous I/O request for distant past!");
+    add_error(kIOReturnIsoTooNew,        "IsoTooNewError",
+            "isochronous I/O request for distant future");
+    add_error(kIOReturnNotFound,         "NotFoundError",
+            "data was not found");
+    add_error(kIOReturnInvalid,          "InvalidError",
+            "should never be seen");
+
+    // Bluetooth
+    add_error(kBluetoothHCIErrorUnknownHCICommand, "UnknownHCICommandError",
+            "unknown HCI command");
+	add_error(kBluetoothHCIErrorNoConnection, "NoConnectionError",
+            "no connection");
+    add_error(kBluetoothHCIErrorHardwareFailure, "HardwareFailureError",
+            "hardware failure");
+	add_error(kBluetoothHCIErrorPageTimeout, "PageTimeoutError",
+            "page timeout");
+    add_error(kBluetoothHCIErrorAuthenticationFailure,
+            "AuthenticationFailureError", "authentication failure");
+	add_error(kBluetoothHCIErrorKeyMissing, "KeyMissingError", "key missing");
+	add_error(kBluetoothHCIErrorMemoryFull, "MemoryFullError", "memory full");
+	add_error(kBluetoothHCIErrorConnectionTimeout, "ConnectionTimeoutError",
+            "connection timeout");
+    add_error(kBluetoothHCIErrorMaxNumberOfConnections,
+            "MaxNumberOfConnectionsError", "maximum number of connections");
+    add_error(kBluetoothHCIErrorMaxNumberOfSCOConnectionsToADevice,
+            "MaxNumberOfSCOConnectionsToADeviceError",
+            "maximum number of synchronous connections to a device");
+    add_error(kBluetoothHCIErrorACLConnectionAlreadyExists,
+            "ACLConnectionAlreadyExistsError",
+            "ACL connection already exists");
+    add_error(kBluetoothHCIErrorCommandDisallowed, "CommandDisallowedError",
+            "command disallowed");
+    add_error(kBluetoothHCIErrorHostRejectedLimitedResources,
+            "HostRejectedLimitedResourcesError",
+            "host rejected, limited resources");
+    add_error(kBluetoothHCIErrorHostRejectedSecurityReasons,
+            "HostRejectedSecurityReasonsError",
+            "host rejected, security reasons");
+    add_error(kBluetoothHCIErrorHostRejectedRemoteDeviceIsPersonal,
+            "HostRejectedRemoteDeviceIsPersonalError",
+            "host rejected, remote device is personal");
+	add_error(kBluetoothHCIErrorHostTimeout, "HostTimeoutError",
+            "host timeout");
+    add_error(kBluetoothHCIErrorUnsupportedFeatureOrParameterValue,
+            "UnsupportedFeatureOrParameterValueError",
+            "unsupported feature or parameter value");
+    add_error(kBluetoothHCIErrorInvalidHCICommandParameters,
+            "InvalidHCICommandParametersError",
+            "invalid HCI command parameters");
+    add_error(kBluetoothHCIErrorOtherEndTerminatedConnectionUserEnded,
+            "OtherEndTerminatedConnectionUserEndedError",
+            "the other end terminated the connection, by user");
+    add_error(kBluetoothHCIErrorOtherEndTerminatedConnectionLowResources,
+            "OtherEndTerminatedConnectionLowResourcesError",
+            "the other end terminated the connection, low resources");
+    add_error(kBluetoothHCIErrorOtherEndTerminatedConnectionAboutToPowerOff,
+            "OtherEndTerminatedConnectionAboutToPowerOffError",
+            "the other end terminated the connection, about to power off");
+    add_error(kBluetoothHCIErrorConnectionTerminatedByLocalHost,
+            "ConnectionTerminatedByLocalHostError",
+            "connection terminated by local host");
+	add_error(kBluetoothHCIErrorRepeatedAttempts, "RepeatedAttemptsError",
+            "repeated attempts");
+	add_error(kBluetoothHCIErrorPairingNotAllowed, "PairingNotAllowedError",
+            "pairing is not allowed");
+	add_error(kBluetoothHCIErrorUnknownLMPPDU, "UnknownLMPPDUError",
+            "unknown LMP PDU");
+    add_error(kBluetoothHCIErrorUnsupportedRemoteFeature,
+            "UnsupportedRemoteFeatureError", "unsupported remote feature");
+	add_error(kBluetoothHCIErrorSCOOffsetRejected, "SCOOffsetRejectedError",
+            "SCO offset rejected");
+    add_error(kBluetoothHCIErrorSCOIntervalRejected, "SCOIntervalRejectedError",
+            "SCO interval rejected");
+	add_error(kBluetoothHCIErrorSCOAirModeRejected, "SCOAirModeRejectedError",
+            "SCO air mode rejected");
+    add_error(kBluetoothHCIErrorInvalidLMPParameters,
+            "InvalidLMPParametersError",
+            "invalid LMP parameters");
+	add_error(kBluetoothHCIErrorUnspecifiedError, "UnspecifiedError",
+            "unspecified error");
+    add_error(kBluetoothHCIErrorUnsupportedLMPParameterValue,
+            "UnsupportedLMPParameterValueError",
+            "unsupported LMP parameter value");
+    add_error(kBluetoothHCIErrorRoleChangeNotAllowed,
+            "RoleChangeNotAllowedError",
+            "role change not allowed");
+	add_error(kBluetoothHCIErrorLMPResponseTimeout, "LMPResponseTimeoutError",
+            "LMP response timeout");
+    add_error(kBluetoothHCIErrorLMPErrorTransactionCollision,
+            "LMPErrorTransactionCollisionError",
+            "LMP error transaction collision");
+	add_error(kBluetoothHCIErrorLMPPDUNotAllowed, "LMPPDUNotAllowedError",
+            "LMP DU not allowed");
+    add_error(kBluetoothHCIErrorEncryptionModeNotAcceptable,
+            "EncryptionModeNotAcceptableError",
+            "encryption mode not acceptable");
+	add_error(kBluetoothHCIErrorUnitKeyUsed, "UnitKeyUsedError",
+            "unit key used");
+	add_error(kBluetoothHCIErrorQoSNotSupported, "QoSNotSupportedError",
+            "QoS not supported");
+	add_error(kBluetoothHCIErrorInstantPassed, "InstantPassedError",
+            "instant passed");
+    add_error(kBluetoothHCIErrorPairingWithUnitKeyNotSupported,
+            "PairingWithUnitKeyNotSupportedError",
+            "pairing with unit key not supported");
+    add_error(kBluetoothHCIErrorHostRejectedUnacceptableDeviceAddress,
+            "HostRejectedUnacceptableDeviceAddressError",
+            "host rejected, unacceptable device address");
+    add_error(kBluetoothHCIErrorDifferentTransactionCollision,
+            "DifferentTransactionCollisionError",
+            "different transaction collision");
+    add_error(kBluetoothHCIErrorQoSUnacceptableParameter,
+            "QoSUnacceptableParameterError",
+            "Qos unacceptable parameter");
+	add_error(kBluetoothHCIErrorQoSRejected, "QoSRejectedError",
+            "QoS rejected");
+    add_error(kBluetoothHCIErrorChannelClassificationNotSupported,
+            "ChannelClassificationNotSupportedError",
+            "channel classification not supported");
+    add_error(kBluetoothHCIErrorInsufficientSecurity,
+            "InsufficientSecurityError",
+            "insufficient security");
+    add_error(kBluetoothHCIErrorParameterOutOfMandatoryRange,
+            "ParameterOutOfMandatoryRangeError",
+            "parameter out of mandatory range");
+	add_error(kBluetoothHCIErrorRoleSwitchPending, "RoleSwitchPendingError",
+            "role switch pending");
+    add_error(kBluetoothHCIErrorReservedSlotViolation,
+            "ReservedSlotViolationError", "reserved slot violation");
+    add_error(kBluetoothHCIErrorRoleSwitchFailed, "RoleSwitchFailedError",
+            "role switch failed");
+    add_error(kBluetoothHCIErrorExtendedInquiryResponseTooLarge,
+            "ExtendedInquiryResponseTooLargeError",
+            "extended inquiry response too large");
+    add_error(kBluetoothHCIErrorSecureSimplePairingNotSupportedByHost,
+            "SecureSimplePairingNotSupportedByHostError",
+            "secure simple pairing not supported by host");
+}
+