idevice 1.1.5.0

data/lib/idevice/mobilesync.rb

@@ -0,0 +1,306 @@
+#
+# Copyright (c) 2013 Eric Monti - Bluebox Security
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+require 'idevice/c'
+require 'idevice/plist'
+require 'idevice/idevice'
+require 'idevice/lockdown'
+require 'time'
+
+module Idevice
+  class MobileSyncError < IdeviceLibError
+  end
+
+  # Used to synchronize data classes with a device and computer.
+  class MobileSyncClient < C::ManagedOpaquePointer
+    include LibHelpers
+
+    def self.release(ptr)
+      C.mobilesync_client_free(ptr) unless ptr.null?
+    end
+
+    def self.attach(opts={})
+        _attach_helper("com.apple.mobilesync", opts) do |idevice, ldsvc, p_ms|
+        err = C.mobilesync_client_new(idevice, ldsvc, p_ms)
+        raise MobileSyncError, "MobileSync error: #{err}" if err != :SUCCESS
+
+        ms = p_ms.read_pointer
+        raise MobileSyncError, "mobilesync_client_new returned a NULL client" if ms.null?
+        return new(ms)
+      end
+    end
+
+    def receive_plist
+      FFI::MemoryPointer.new(:pointer) do |p_result|
+        err = C.mobilesync_receive(self, p_result)
+        raise MobileSyncError, "MobileSync error: #{err}" if err != :SUCCESS
+        return p_result.read_pointer.read_plist_t
+      end
+    end
+
+    def send_plist(request)
+      err = C.mobilesync_send(self, Plist_t.from_ruby(request))
+      raise MobileSyncError, "MobileSync error: #{err}" if err != :SUCCESS
+
+      return true
+    end
+
+    SYNC_TYPES = [
+      :FAST,  # Fast-sync requires that only the changes made since the last synchronization should be reported by the computer.
+      :SLOW,  # Slow-sync requires that all data from the computer needs to be synchronized/sent.
+      :RESET, # Reset-sync signals that the computer should send all data again.
+    ]
+
+    def start(data_class, anchors, data_class_version=106)
+      anchors = C.mobilesync_anchors_new(*anchors)
+
+      FFI::MemoryPointer.new(:int) do |p_sync_type|
+        FFI::MemoryPointer.new(:uint64) do |p_dev_data_class_version|
+          FFI::MemoryPointer.new(:pointer) do |p_error|
+            err = C.mobilesync_send(self, data_class, anchors, data_class_version, p_sync_type, p_dev_data_class_version, p_error)
+            errstr = nil
+            p_errstr = p_error.read_pointer
+            unless p_errstr.null?
+              errstr = p_errstr.read_string
+              C.free(p_errstr)
+            end
+
+            if err != :SUCCESS
+              msg = "MobileSync error: #{err}"
+              msg << "(#{errstr})" if errstr
+              raise MobileSyncError, msg
+            end
+
+            sync_type = sync_type.read_int
+            ddc_ver = p_device_data_class_version.read_uint64
+
+            return({
+              sync_type: (SYNC_TYPES[sync_type] || sync_type),
+              device_data_class_version: ddc_ver,
+              error: errstr,
+            })
+          end
+        end
+      end
+    end
+
+    def cancel(reason)
+      err = C.mobilesync_cancel(self, reason)
+      raise MobileSyncError, "MobileSync error: #{err}" if err != :SUCCESS
+
+      return true
+    end
+
+    def finish
+      err = C.mobilesync_finish(self)
+      raise MobileSyncError, "MobileSync error: #{err}" if err != :SUCCESS
+
+      return true
+    end
+
+    def request_all_records_from_device
+      err = C.mobilesync_get_all_records_from_device(self)
+      raise MobileSyncError, "MobileSync error: #{err}" if err != :SUCCESS
+
+      return true
+    end
+
+    def request_changes_from_device
+      err = C.mobilesync_get_changes_from_device(self)
+      raise MobileSyncError, "MobileSync error: #{err}" if err != :SUCCESS
+
+      return true
+    end
+
+    def clear_all_records_on_device
+      err = C.mobilesync_clear_all_records_on_device(self)
+      raise MobileSyncError, "MobileSync error: #{err}" if err != :SUCCESS
+
+      return true
+    end
+
+    def receive_changes
+      ret = []
+
+      FFI::MemoryPointer.new(:pointer) do |p_entities|
+        FFI::MemoryPointer.new(:uint8) do |p_is_last_record|
+          FFI::MemoryPointer.new(:pointer) do |p_actions|
+            last_record = false
+            until last_record
+              err = C.mobilesync_receive_changes(self, p_entities, p_is_last_record, p_actions)
+              raise MobileSyncError, "MobileSync error: #{err}" if err != :SUCCESS
+
+              last_record = (p_is_last_record.read_uint8 != 0)
+              ret << {
+                entities: p_entities.read_pointer.read_plist_t,
+                actions:  p_actions.read_pointer.read_plist_t,
+              }
+            end
+          end
+        end
+      end
+
+      return ret
+    end
+
+    def acknowledge_changes_from_device
+      err = C.mobilesync_acknowledge_changes_from_device(self)
+      raise MobileSyncError, "MobileSync error: #{err}" if err != :SUCCESS
+
+      return true
+    end
+
+    def signal_ready_to_send_changes_from_computer
+      err = C.mobilesync_ready_to_send_changes_from_computer(self)
+      raise MobileSyncError, "MobileSync error: #{err}" if err != :SUCCESS
+
+      return true
+    end
+
+    def _send_changes(entities, is_last, actions=nil)
+      act = actions ? Plist_t.from_ruby(actions) : nil
+      err = C.mobilesync_send_changes(self, Plist_t.from_ruby(entities), is_last, act)
+      raise MobileSyncError, "MobileSync error: #{err}" if err != :SUCCESS
+    end
+
+    def send_changes(changes)
+      raise TypeError, "changes must be an array" unless changes.is_a? Array
+      raise ArgumentError, "changes must not be empty" if changes.empty?
+
+      lastchange = changes.unshift
+      changes.each { |change| _send_changes(change[:entities], 0, change[:actions]) }
+      _send_changes(lastchange[:entities], 1, lastchange[:actions])
+      return true
+    end
+
+    #mobilesync_error_t mobilesync_remap_identifiers(mobilesync_client_t client, plist_t *mapping);
+    def remap_identifiers(mappings)
+      raise TypeError, "mappings must be an array" unless changes.is_a? Array
+      raise ArgumentError, "mappings must not be empty" if changes.empty?
+
+      FFI::MemoryPointer.new(FFI::Pointer.size * (mappings.count+1)) do |p_mapping|
+        p_mapping.write_array_of_pointer(mappings.map{|m| Plist_t.from_ruby(m)} + nil)
+        err = C.mobilesync_remap_identifiers(self, p_mapping)
+        raise MobileSyncError, "MobileSync error: #{err}" if err != :SUCCESS
+        return true
+      end
+    end
+  end
+
+  # Mobile Sync anchors used by the device and computer
+  class MobileSyncAnchors < FFI::ManagedStruct
+    def self.release(ptr)
+      C.mobilesync_anchors_free(ptr) unless ptr.null?
+    end
+
+    layout(
+      :device_anchor,   :string,
+      :computer_anchor, :string,
+    )
+  end
+
+  module C
+    ffi_lib 'imobiledevice'
+
+    typedef enum(
+      :SUCCESS        ,       0,
+      :INVALID_ARG    ,      -1,
+      :PLIST_ERROR    ,      -2,
+      :MUX_ERROR      ,      -3,
+      :BAD_VERSION    ,      -4,
+      :SYNC_REFUSED   ,      -5,
+      :CANCELLED      ,      -6,
+      :WRONG_DIRECTION,      -7,
+      :NOT_READY      ,      -8,
+      :UNKNOWN_ERROR  ,    -256,
+    ), :mobilesync_error_t
+
+    ## The sync type of the current sync session.
+    typedef enum(
+      :FAST, # Fast-sync requires that only the changes made since the last synchronization should be reported by the computer.
+      :SLOW, # Slow-sync requires that all data from the computer needs to be synchronized/sent.
+      :RESET, # Reset-sync signals that the computer should send all data again.
+    ), :mobilesync_sync_type_t
+
+    #mobilesync_error_t mobilesync_client_new(idevice_t device, lockdownd_service_descriptor_t service, mobilesync_client_t * client);
+    attach_function :mobilesync_client_new, [Idevice, LockdownServiceDescriptor, :pointer], :mobilesync_error_t
+
+    #mobilesync_error_t mobilesync_client_free(mobilesync_client_t client);
+    attach_function :mobilesync_client_free, [MobileSyncClient], :mobilesync_error_t
+
+    #mobilesync_error_t mobilesync_receive(mobilesync_client_t client, plist_t *plist);
+    attach_function :mobilesync_receive, [MobileSyncClient, :pointer], :mobilesync_error_t
+
+    #mobilesync_error_t mobilesync_send(mobilesync_client_t client, plist_t plist);
+    attach_function :mobilesync_send, [MobileSyncClient, Plist_t], :mobilesync_error_t
+
+    #mobilesync_error_t mobilesync_start(mobilesync_client_t client, const char *data_class, mobilesync_anchors_t anchors, uint64_t computer_data_class_version, mobilesync_sync_type_t *sync_type, uint64_t *device_data_class_version, char** error_description);
+    attach_function :mobilesync_start, [MobileSyncClient, :string, MobileSyncAnchors, :uint64, :pointer, :pointer, :pointer], :mobilesync_error_t
+
+    #mobilesync_error_t mobilesync_cancel(mobilesync_client_t client, const char* reason);
+    attach_function :mobilesync_cancel, [MobileSyncClient, :string], :mobilesync_error_t
+
+    #mobilesync_error_t mobilesync_finish(mobilesync_client_t client);
+    attach_function :mobilesync_finish, [MobileSyncClient], :mobilesync_error_t
+
+    #mobilesync_error_t mobilesync_get_all_records_from_device(mobilesync_client_t client);
+    attach_function :mobilesync_get_all_records_from_device, [MobileSyncClient], :mobilesync_error_t
+
+    #mobilesync_error_t mobilesync_get_changes_from_device(mobilesync_client_t client);
+    attach_function :mobilesync_get_changes_from_device, [MobileSyncClient], :mobilesync_error_t
+
+    #mobilesync_error_t mobilesync_clear_all_records_on_device(mobilesync_client_t client);
+    attach_function :mobilesync_clear_all_records_on_device, [MobileSyncClient], :mobilesync_error_t
+
+    #mobilesync_error_t mobilesync_receive_changes(mobilesync_client_t client, plist_t *entities, uint8_t *is_last_record, plist_t *actions);
+    attach_function :mobilesync_receive_changes, [MobileSyncClient, :pointer, :pointer, :pointer], :mobilesync_error_t
+
+    #mobilesync_error_t mobilesync_acknowledge_changes_from_device(mobilesync_client_t client);
+    attach_function :mobilesync_acknowledge_changes_from_device, [MobileSyncClient], :mobilesync_error_t
+
+    #mobilesync_error_t mobilesync_ready_to_send_changes_from_computer(mobilesync_client_t client);
+    attach_function :mobilesync_ready_to_send_changes_from_computer, [MobileSyncClient], :mobilesync_error_t
+
+    #mobilesync_error_t mobilesync_send_changes(mobilesync_client_t client, plist_t entities, uint8_t is_last_record, plist_t actions);
+    attach_function :mobilesync_send_changes, [MobileSyncClient, Plist_t, :uint8, Plist_t], :mobilesync_error_t
+
+    #mobilesync_error_t mobilesync_remap_identifiers(mobilesync_client_t client, plist_t *mapping);
+    attach_function :mobilesync_remap_identifiers, [MobileSyncClient, :pointer], :mobilesync_error_t
+
+    #mobilesync_anchors_t mobilesync_anchors_new(const char *device_anchor, const char *computer_anchor);
+    attach_function :mobilesync_anchors_new, [:string, :string], MobileSyncAnchors
+
+    #void mobilesync_anchors_free(mobilesync_anchors_t anchors);
+    attach_function :mobilesync_anchors_free, [MobileSyncAnchors], :void
+
+
+    ### actions Helpers
+
+    #plist_t mobilesync_actions_new();
+    attach_function :mobilesync_actions_new, [], Plist_t
+
+    #void mobilesync_actions_add(plist_t actions, ...);
+    attach_function :mobilesync_actions_add, [Plist_t, :varargs], Plist_t
+
+    #void mobilesync_actions_free(plist_t actions);
+    attach_function :mobilesync_actions_free, [Plist_t], :void
+
+  end
+end

data/lib/idevice/notification_proxy.rb

@@ -0,0 +1,168 @@
+#
+# Copyright (c) 2013 Eric Monti - Bluebox Security
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+require 'idevice/c'
+require 'idevice/idevice'
+require 'idevice/lockdown'
+
+module Idevice
+  class NotificationProxyError < IdeviceLibError
+  end
+
+  # Aliased short name for NotificationProxyError
+  NPError = NotificationProxyError
+
+  # Notifications that can be received from the device
+  module NPRecvNotifications
+    SYNC_CANCEL_REQUEST       = "com.apple.itunes-client.syncCancelRequest"
+    SYNC_SUSPEND_REQUEST      = "com.apple.itunes-client.syncSuspendRequest"
+    SYNC_RESUME_REQUEST       = "com.apple.itunes-client.syncResumeRequest"
+    PHONE_NUMBER_CHANGED      = "com.apple.mobile.lockdown.phone_number_changed"
+    DEVICE_NAME_CHANGED       = "com.apple.mobile.lockdown.device_name_changed"
+    TIMEZONE_CHANGED          = "com.apple.mobile.lockdown.timezone_changed"
+    TRUSTED_HOST_ATTACHED     = "com.apple.mobile.lockdown.trusted_host_attached"
+    HOST_DETACHED             = "com.apple.mobile.lockdown.host_detached"
+    HOST_ATTACHED             = "com.apple.mobile.lockdown.host_attached"
+    REGISTRATION_FAILED       = "com.apple.mobile.lockdown.registration_failed"
+    ACTIVATION_STATE          = "com.apple.mobile.lockdown.activation_state"
+    BRICK_STATE               = "com.apple.mobile.lockdown.brick_state"
+    DISK_USAGE_CHANGED        = "com.apple.mobile.lockdown.disk_usage_changed"# /**< iOS 4.0+ */
+    DS_DOMAIN_CHANGED         = "com.apple.mobile.data_sync.domain_changed"
+    BACKUP_DOMAIN_CHANGED     = "com.apple.mobile.backup.domain_changed"
+    APP_INSTALLED             = "com.apple.mobile.application_installed"
+    APP_UNINSTALLED           = "com.apple.mobile.application_uninstalled"
+    DEV_IMAGE_MOUNTED         = "com.apple.mobile.developer_image_mounted"
+    ATTEMPTACTIVATION         = "com.apple.springboard.attemptactivation"
+    ITDBPREP_DID_END          = "com.apple.itdbprep.notification.didEnd"
+    LANGUAGE_CHANGED          = "com.apple.language.changed"
+    ADDRESS_BOOK_PREF_CHANGED = "com.apple.AddressBook.PreferenceChanged"
+  end
+
+  # Notifications that can be sent to the device
+  module NPSendNotifications
+    SYNC_WILL_START           = "com.apple.itunes-mobdev.syncWillStart"
+    SYNC_DID_START            = "com.apple.itunes-mobdev.syncDidStart"
+    SYNC_DID_FINISH           = "com.apple.itunes-mobdev.syncDidFinish"
+    SYNC_LOCK_REQUEST         = "com.apple.itunes-mobdev.syncLockRequest"
+  end
+
+  # Used to receive and post device notifications
+  class NotificationProxyClient < C::ManagedOpaquePointer
+    include LibHelpers
+
+    def self.release(ptr)
+      C.np_client_free(ptr) unless ptr.null?
+    end
+
+    def self.attach(opts={})
+      _attach_helper("com.apple.mobile.notification_proxy", opts) do |idevice, ldsvc, p_np|
+        err = C.np_client_new(idevice, ldsvc, p_np)
+        raise NotificationProxyError, "Notification Proxy Error: #{err}" if err != :SUCCESS
+
+        np = p_np.read_pointer
+        raise NPError, "np_client_new returned a NULL client" if np.null?
+        return new(np)
+      end
+    end
+
+    def post_notification(notification)
+      err = C.np_post_notification(self, notification)
+      raise NotificationProxyError, "Notification Proxy Error: #{err}" if err != :SUCCESS
+
+      return true
+    end
+
+    def observe_notification
+      FFI::MemoryPointer.new(:pointer) do |p_notification|
+        err = C.np_observe_notification(self, p_notification)
+        raise NotificationProxyError, "Notification Proxy Error: #{err}" if err != :SUCCESS
+
+        notification = p_notification.read_pointer
+        unless notification.null?
+          ret = notification.read_string
+          C.free(notification)
+          return ret
+        end
+      end
+    end
+
+    def observe_notifications
+      FFI::MemoryPointer.new(:pointer) do |p_notifications|
+        err = C.np_observe_notifications(self, p_notifications)
+        raise NotificationProxyError, "Notification Proxy Error: #{err}" if err != :SUCCESS
+
+        return _unbound_list_to_array(p_notifications)
+      end
+    end
+
+    def set_notify_callback(&block)
+      err = C.np_set_notify_callback(self, _cb(&block), nil)
+      raise NotificationProxyError, "Notification Proxy Error: #{err}" if err != :SUCCESS
+
+      @notify_callback = block
+      return true
+    end
+
+  private
+    def _cb
+      lambda do |notification, junk|
+        yield(notification)
+      end
+    end
+  end
+
+  # Aliased short name for NotificationProxyClient
+  NPClient = NotificationProxyClient
+
+  module C
+    ffi_lib 'imobiledevice'
+
+    typedef enum(
+      :SUCCESS      ,         0,
+      :INVALID_ARG  ,        -1,
+      :PLIST_ERROR  ,        -2,
+      :CONN_FAILED  ,        -3,
+      :UNKNOWN_ERROR,      -256,
+    ), :np_error_t
+
+    #np_error_t np_client_new(idevice_t device, lockdownd_service_descriptor_t service, np_client_t *client);
+    attach_function :np_client_new, [Idevice, LockdownServiceDescriptor, :pointer], :np_error_t
+
+    #np_error_t np_client_free(np_client_t client);
+    attach_function :np_client_free, [NPClient], :np_error_t
+
+    #np_error_t np_post_notification(np_client_t client, const char *notification);
+    attach_function :np_post_notification, [NPClient, :string], :np_error_t
+
+    #np_error_t np_observe_notification(np_client_t client, const char *notification);
+    attach_function :np_observe_notification, [NPClient, :string], :np_error_t
+
+    #np_error_t np_observe_notifications(np_client_t client, const char **notification_spec);
+    attach_function :np_observe_notifications, [NPClient, :pointer], :np_error_t
+
+    #/** Reports which notification was received. */
+    #typedef void (*np_notify_cb_t) (const char *notification, void *user_data);
+    callback :np_notify_cb_t, [:string, :pointer], :void
+
+    #np_error_t np_set_notify_callback(np_client_t client, np_notify_cb_t notify_cb, void *userdata);
+    attach_function :np_set_notify_callback, [NPClient, :np_notify_cb_t, :pointer], :np_error_t
+
+  end
+end