idevice 1.1.5.0

data/lib/idevice/sbservices.rb

@@ -0,0 +1,152 @@
+#
+# 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'
+
+module Idevice
+  class SbservicesError < IdeviceLibError
+  end
+
+  SBSError = SbservicesError
+
+  class SbservicesClient < C::ManagedOpaquePointer
+    include LibHelpers
+
+    def self.release(ptr)
+      C.sbservices_client_free(ptr) unless ptr.null?
+    end
+
+    def self.attach(opts={})
+      _attach_helper("com.apple.springboardservices", opts) do |idevice, ldsvc, p_sbs|
+        err = C.sbservices_client_new(idevice, ldsvc, p_sbs)
+        raise SbservicesError, "Springboard Services Error: #{err}" if err != :SUCCESS
+
+        sbs = p_sbs.read_pointer
+        raise SBSError, "sbservices_client_new returned a NULL client" if sbs.null?
+        return new(sbs)
+      end
+    end
+
+    def get_icon_state
+      FFI::MemoryPointer.new(:pointer) do |p_state|
+        err = C.sbservices_get_icon_state(self, p_state, nil)
+        raise SbservicesError, "Springboard Services Error: #{err}" if err != :SUCCESS
+        return p_state.read_pointer.read_plist_t
+      end
+    end
+
+    def set_icon_state(newstate)
+      err = C.sbservices_set_icon_state(self, Plist_t.from_ruby(newstate))
+      raise SbservicesError, "Springboard Services Error: #{err}" if err != :SUCCESS
+
+      return true
+    end
+
+    def get_icon_pngdata(bundleid)
+      FFI::MemoryPointer.new(:pointer) do |p_pngdata|
+        FFI::MemoryPointer.new(:uint64) do |p_pngsize|
+          err = C.sbservices_get_icon_pngdata(self, bundleid, p_pngdata, p_pngsize)
+          raise SbservicesError, "Springboard Services Error: #{err}" if err != :SUCCESS
+
+          pngdata = p_pngdata.read_pointer
+          unless pngdata.null?
+            ret=pngdata.read_bytes(p_pngsize.read_uint64)
+            C.free(pngdata)
+            return ret
+          end
+        end
+      end
+    end
+
+    INTERFACE_ORIENTATIONS = [
+      :UNKNOWN,              # => 0,
+      :PORTRAIT,             # => 1,
+      :PORTRAIT_UPSIDE_DOWN, # => 2,
+      :LANDSCAPE_RIGHT,      # => 3,
+      :LANDSCAPE_LEFT,       # => 4,
+    ]
+
+    def get_interface_orientation
+      FFI::MemoryPointer.new(:int) do |p_orientation|
+        err = C.sbservices_get_interface_orientation(self, p_orientation)
+        raise SbservicesError, "Springboard Services Error: #{err}" if err != :SUCCESS
+
+        orientation = p_orientation.read_int
+        return (INTERFACE_ORIENTATIONS[orientation] or orientation)
+      end
+    end
+
+    def get_home_screen_wallpaper_pngdata
+      FFI::MemoryPointer.new(:pointer) do |p_pngdata|
+        FFI::MemoryPointer.new(:uint64) do |p_pngsize|
+          err = C.sbservices_get_home_screen_wallpaper_pngdata(self, p_pngdata, p_pngsize)
+          raise SbservicesError, "Springboard Services Error: #{err}" if err != :SUCCESS
+
+          pngdata = p_pngdata.read_pointer
+          unless pngdata.null?
+            ret=pngdata.read_bytes(p_pngsize.read_uint64)
+            C.free(pngdata)
+            return ret
+          end
+        end
+      end
+    end
+
+  end
+
+  SBSClient = SbservicesClient
+
+  module C
+    ffi_lib 'imobiledevice'
+
+    typedef enum(
+      :SUCCESS      ,         0,
+      :INVALID_ARG  ,        -1,
+      :PLIST_ERROR  ,        -2,
+      :CONN_FAILED  ,        -3,
+      :UNKNOWN_ERROR,      -256,
+    ), :sbservices_error_t
+
+    #sbservices_error_t sbservices_client_new(idevice_t device, lockdownd_service_descriptor_t service, sbservices_client_t *client);
+    attach_function :sbservices_client_new, [Idevice, LockdownServiceDescriptor, :pointer], :sbservices_error_t
+
+    #sbservices_error_t sbservices_client_free(sbservices_client_t client);
+    attach_function :sbservices_client_free, [SBSClient], :sbservices_error_t
+
+    #sbservices_error_t sbservices_get_icon_state(sbservices_client_t client, plist_t *state, const char *format_version);
+    attach_function :sbservices_get_icon_state, [SBSClient, :pointer, :string], :sbservices_error_t
+
+    #sbservices_error_t sbservices_set_icon_state(sbservices_client_t client, plist_t newstate);
+    attach_function :sbservices_set_icon_state, [SBSClient, Plist_t], :sbservices_error_t
+
+    #sbservices_error_t sbservices_get_icon_pngdata(sbservices_client_t client, const char *bundleId, char **pngdata, uint64_t *pngsize);
+    attach_function :sbservices_get_icon_pngdata, [SBSClient, :string, :pointer, :pointer], :sbservices_error_t
+
+    #sbservices_error_t sbservices_get_interface_orientation(sbservices_client_t client, sbservices_interface_orientation_t* interface_orientation);
+    attach_function :sbservices_get_interface_orientation, [SBSClient, :pointer], :sbservices_error_t
+
+    #sbservices_error_t sbservices_get_home_screen_wallpaper_pngdata(sbservices_client_t client, char **pngdata, uint64_t *pngsize);
+    attach_function :sbservices_get_home_screen_wallpaper_pngdata, [SBSClient, :pointer, :pointer], :sbservices_error_t
+
+  end
+end

data/lib/idevice/screenshotr.rb

@@ -0,0 +1,88 @@
+#
+# 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 ScreenShotrError < IdeviceLibError
+  end
+
+  class ScreenShotrClient < C::ManagedOpaquePointer
+    include LibHelpers
+
+    def self.release(ptr)
+      C.screenshotr_client_free(ptr) unless ptr.null?
+    end
+
+    def self.attach(opts={})
+      _attach_helper("com.apple.mobile.screenshotr", opts) do |idevice, ldsvc, p_ss|
+        err = C.screenshotr_client_new(idevice, ldsvc, p_ss)
+        raise ScreenShotrError, "ScreenShotr Error: #{err}" if err != :SUCCESS
+
+        ss = p_ss.read_pointer
+        raies ScreenShotrError, "screenshotr_client_new returned a NULL client" if ss.null?
+        return new(ss)
+      end
+    end
+
+    def take_screenshot
+      FFI::MemoryPointer.new(:pointer) do |p_imgdata|
+        FFI::MemoryPointer.new(:uint64) do |p_imgsize|
+          err = C.screenshotr_take_screenshot(self, p_imgdata, p_imgsize)
+          raise ScreenShotrError, "ScreenShotr Error: #{err}" if err != :SUCCESS
+
+          imgdata = p_imgdata.read_pointer
+          unless imgdata.null?
+            ret=imgdata.read_bytes(p_imgsize.read_uint64)
+            C.free(imgdata)
+            return ret
+          end
+        end
+      end
+    end
+  end
+
+  module C
+    ffi_lib 'imobiledevice'
+
+    typedef enum(
+      :SUCCESS      ,         0,
+      :INVALID_ARG  ,        -1,
+      :PLIST_ERROR  ,        -2,
+      :MUX_ERROR    ,        -3,
+      :BAD_VERSION  ,        -4,
+      :UNKNOWN_ERROR,      -256,
+    ), :screenshotr_error_t
+
+    #screenshotr_error_t screenshotr_client_new(idevice_t device, lockdownd_service_descriptor_t service, screenshotr_client_t * client);
+    attach_function :screenshotr_client_new, [Idevice, LockdownServiceDescriptor, :pointer], :screenshotr_error_t
+
+    #screenshotr_error_t screenshotr_client_free(screenshotr_client_t client);
+    attach_function :screenshotr_client_free, [ScreenShotrClient], :screenshotr_error_t
+
+    #screenshotr_error_t screenshotr_take_screenshot(screenshotr_client_t client, char **imgdata, uint64_t *imgsize);
+    attach_function :screenshotr_take_screenshot, [ScreenShotrClient, :pointer, :pointer], :screenshotr_error_t
+
+  end
+end
+

data/lib/idevice/version.rb

@@ -0,0 +1,3 @@
+module Idevice
+  VERSION = "1.1.5.0"
+end

data/lib/idevice/webinspector.rb

@@ -0,0 +1,96 @@
+#
+# 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'
+
+module Idevice
+  class WebInspectorError < IdeviceLibError
+  end
+
+  class WebInspectorClient < C::ManagedOpaquePointer
+    include LibHelpers
+
+    def self.release(ptr)
+      C.webinspector_client_free(ptr) unless ptr.null?
+    end
+
+    def self.attach(opts={})
+      _attach_helper("com.apple.webinspector", opts) do |idevice, ldsvc, p_wic|
+        err = C.webinspector_client_new(idevice, ldsvc, p_wic)
+        raise WebInspectorError, "WebInspector error: #{err}" if err != :SUCCESS
+
+        wic = p_wic.read_pointer
+        raise WebInspectorError, "webinspector_client_new returned a NULL client" if wic.null?
+
+        return new(wic)
+      end
+    end
+
+    def send_plist(obj)
+      err = C.webinspector_send(self, Plist_t.from_ruby(obj))
+      raise WebInspectorError, "WebInspector error: #{err}" if err != :SUCCESS
+      return true
+    end
+
+    def receive_plist
+      FFI::MemoryPointer.new(:pointer) do |p_plist|
+        err = C.webinspector_receive(self, p_plist)
+        raise WebInspectorError, "WebInspector error: #{err}" if err != :SUCCESS
+        return p_plist.to_pointer.to_plist_t
+      end
+    end
+  end
+
+  module C
+
+    typedef enum(
+      :SUCCESS      ,         0,
+      :INVALID_ARG  ,        -1,
+      :PLIST_ERROR  ,        -2,
+      :MUX_ERROR    ,        -3,
+      :SSL_ERROR    ,        -4,
+      :UNKNOWN_ERROR,      -256,
+    ), :webinspector_error_t
+
+    #webinspector_error_t webinspector_client_new(idevice_t device, lockdownd_service_descriptor_t service, webinspector_client_t * client);
+    attach_function :webinspector_client_new, [Idevice, LockdownServiceDescriptor, :pointer], :webinspector_error_t
+
+    #webinspector_error_t webinspector_client_start_service(idevice_t device, webinspector_client_t * client, const char* label);
+    attach_function :webinspector_client_start_service, [Idevice, :pointer, :string], :webinspector_error_t
+
+    #webinspector_error_t webinspector_client_free(webinspector_client_t client);
+    attach_function :webinspector_client_free, [WebInspectorClient], :webinspector_error_t
+
+    #webinspector_error_t webinspector_send(webinspector_client_t client, plist_t plist);
+    attach_function :webinspector_send, [WebInspectorClient, Plist_t], :webinspector_error_t
+
+    #webinspector_error_t webinspector_receive(webinspector_client_t client, plist_t * plist);
+    attach_function :webinspector_receive, [WebInspectorClient, :pointer], :webinspector_error_t
+
+    #webinspector_error_t webinspector_receive_with_timeout(webinspector_client_t client, plist_t * plist, uint32_t timeout_ms);
+    attach_function :webinspector_receive_with_timeout, [WebInspectorClient, :pointer, :uint32], :webinspector_error_t
+
+  end
+end
+
+

data/spec/afc_devicespec.rb

@@ -0,0 +1,409 @@
+#
+# 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_relative 'spec_helper'
+require 'time'
+
+describe Idevice::AFCClient do
+  before :all do
+    @fromfile = sample_file("plist.bin")
+  end
+
+  before :each do
+    @afc = Idevice::AFCClient.attach(idevice:shared_idevice)
+  end
+
+  it "should attach" do
+    @afc.should be_a Idevice::AFCClient
+  end
+
+  it "should return device info" do
+    result = @afc.device_info
+    result.should be_a Hash
+    result.keys.sort.should == [:FSBlockSize, :FSFreeBytes, :FSTotalBytes, :Model]
+    result[:FSBlockSize].should =~ /^\d+$/
+    result[:FSFreeBytes].should =~ /^\d+$/
+    result[:FSTotalBytes].should =~ /^\d+$/
+    result[:FSTotalBytes].to_i.should > result["FSFreeBytes"].to_i
+  end
+
+  it "should return device info for specific keys" do
+    totbytes = @afc.device_info("FSTotalBytes")
+    totbytes.should be_a String
+    totbytes.should =~ /^\d+$/
+
+    freebytes = @afc.device_info("FSFreeBytes")
+    freebytes.should be_a String
+    freebytes.should =~ /^\d+$/
+
+    totbytes.to_i.should > freebytes.to_i
+  end
+
+  it "should list directory contents" do
+    result = @afc.read_directory('/')
+    result.should be_a Array
+    result[0,2].should == ['.', '..']
+  end
+
+  it "should raise an error listing an invalid directory" do
+    lambda{ @afc.read_directory('/TOTALLYNOTREALLYTHERE') }.should raise_error(Idevice::AFCError)
+  end
+
+  it "should get file information" do
+    result = @afc.file_info('/')
+    result.should be_a Hash
+    result.keys.sort.should == [:st_birthtime, :st_blocks, :st_ifmt, :st_mtime, :st_nlink, :st_size]
+    result[:st_ifmt].should == :S_IFDIR
+  end
+
+  it "should raise an error getting info for an invalid path" do
+    lambda{ @afc.file_info('/TOTALLYNOTREALLYTHERE') }.should raise_error(Idevice::AFCError)
+  end
+
+  it "should remove a file path" do
+    remotepath='TOTALLYATESTFILECREATEDTEST'
+
+    @afc.put_path(@fromfile.to_s, remotepath).should == @fromfile.size
+    @afc.remove_path(remotepath).should be_true
+  end
+
+  it "should remove an (empty) directory path" do
+    remotepath='TOTALLYATESTDIRCREATEDTEST'
+    @afc.make_directory(remotepath).should be_true
+    @afc.remove_path(remotepath).should be_true
+  end
+
+  it "should rename a file path" do
+    remotepath='TOTALLYATESTFILECREATEDTEST'
+    renamepath = remotepath+'2'
+
+    begin
+      @afc.put_path(@fromfile.to_s, remotepath).should == @fromfile.size
+      originfo = @afc.file_info(remotepath)
+      @afc.rename_path(remotepath, renamepath).should be_true
+      lambda{ @afc.file_info(remotepath) }.should raise_error Idevice::AFCError
+      info = @afc.file_info(renamepath)
+      info.should == originfo
+    ensure
+      @afc.remove_path(remotepath) rescue nil
+      @afc.remove_path(renamepath).should be_true
+    end
+
+  end
+
+  it "should rename a directory path" do
+    remotepath = 'TOTALLYATESTDIRCREATEDTEST'
+    renamepath = remotepath+'2'
+    begin
+      @afc.make_directory(remotepath).should be_true
+      originfo = @afc.file_info(remotepath)
+      @afc.rename_path(remotepath, renamepath).should be_true
+      lambda{ @afc.file_info(remotepath) }.should raise_error Idevice::AFCError
+      info = @afc.file_info(renamepath)
+      info.should == originfo
+    ensure
+      @afc.remove_path(remotepath) rescue nil
+      @afc.remove_path(renamepath).should be_true
+    end
+  end
+
+  it "should make a directory" do
+    remotepath = 'TOTALLYATESTDIR'
+    begin
+      @afc.make_directory(remotepath).should be_true
+      result = @afc.file_info(remotepath)
+      result[:st_ifmt].should == :S_IFDIR
+    ensure
+      @afc.remove_path(remotepath) rescue nil
+    end
+  end
+
+  it "should make a symbolic link to a directory" do
+    begin
+      @afc.symlink('.', 'TOTALLYATESTSYMLINKTOCURRENTDIR').should be_true
+      result = @afc.file_info('TOTALLYATESTSYMLINKTOCURRENTDIR')
+      result[:st_ifmt].should == :S_IFLNK
+    ensure
+      @afc.remove_path('TOTALLYATESTSYMLINKTOCURRENTDIR') rescue nil
+    end
+  end
+
+  it "should make a symbolic link to a file" do
+    remotefile = 'TOTALLYATESTFILE3'
+    remotelink = 'TOTEALLYATESTSYMLINK3'
+
+    begin
+      @afc.touch(remotefile).should be_true
+      @afc.symlink(remotefile, remotelink).should be_true
+      @afc.file_info(remotefile)[:st_ifmt].should == :S_IFREG
+      @afc.file_info(remotelink)[:st_ifmt].should == :S_IFLNK
+
+      # opening a symlinked file via AFC seems to give PERM_DENIED ?
+      #@afc.open(remotelink,'a'){|f| f.write("meep") }
+      #@afc.cat(remotefile).should == "meep"
+
+      #@afc.file_info(remotefile)[:st_ifmt].should == :S_IFREG
+      #@afc.file_info(remotelink)[:st_ifmt].should == :S_IFLNK
+    ensure
+      @afc.remove_path(remotefile) rescue nil
+      @afc.remove_path(remotelink) rescue nil
+    end
+  end
+
+  it "should make a hard link to a file" do
+    remotefile = 'TOTALLYATESTFILE2'
+    remotelink = 'TOTEALLYATESTHARDLINK'
+
+    begin
+      @afc.touch(remotefile).should be_true
+      @afc.hardlink(remotefile, remotelink).should be_true
+      @afc.file_info(remotefile)[:st_ifmt].should == :S_IFREG
+      @afc.file_info(remotelink)[:st_ifmt].should == :S_IFREG
+
+      @afc.open(remotelink,'a'){|f| f.write("meep") }
+      @afc.cat(remotefile).should == "meep"
+
+      @afc.file_info(remotefile)[:st_ifmt].should == :S_IFREG
+      @afc.file_info(remotelink)[:st_ifmt].should == :S_IFREG
+    ensure
+      @afc.remove_path(remotefile) rescue nil
+      @afc.remove_path(remotelink) rescue nil
+    end
+  end
+
+  it "should raise an error removing a non-existent path" do
+    lambda{ @afc.remove_path('TOTALLYNOTREALLYTHERE') }.should raise_error(Idevice::AFCError)
+  end
+
+  it "should put a file and cat it" do
+    remotepath = 'TESTFILEUPLOAD'
+
+    begin
+      @afc.put_path(@fromfile.to_s, remotepath).should == @fromfile.size
+      @afc.cat(remotepath).should == @fromfile.read()
+    ensure
+      @afc.remove_path(remotepath) rescue nil
+    end
+  end
+
+  it "should put a file and cat it with a small chunk size" do
+    remotepath = 'TESTFILEUPLOAD'
+
+    begin
+      gotblock=false
+      @afc.put_path(@fromfile.to_s, remotepath, 2) do |chunksz|
+        gotblock=true
+        (0..2).should include(chunksz)
+      end.should == @fromfile.size
+      gotblock.should be_true
+
+      catsize = 0
+      catbuf = StringIO.new
+      gotblock=false
+
+      @afc.cat(remotepath, 2) do |chunk|
+        catbuf << chunk
+        catsize += chunk.size
+        gotblock=true
+        (0..2).should include(chunk.size)
+      end
+
+      catsize.should == @fromfile.size
+      catbuf.string.should == @fromfile.read()
+      gotblock.should be_true
+    ensure
+      @afc.remove_path(remotepath) rescue nil
+    end
+  end
+
+  it "should get a file" do
+    tmpfile = Tempfile.new('TESTFILEUPLOADFORGETlocal')
+    tmppath = tmpfile.path
+    tmpfile.close
+    remotepath = 'TESTFILEUPLOADFORGET'
+    begin
+      @afc.put_path(@fromfile.to_s, remotepath).should == @fromfile.size
+      @afc.getpath(remotepath, tmppath).should == @fromfile.size
+      File.read(tmppath).should == @fromfile.read()
+    ensure
+      @afc.remove_path(remotepath) rescue nil
+      File.unlink(tmppath)
+    end
+  end
+
+  it "should truncate a file path" do
+    remotepath = 'TESTFILEUPLOADFORTRUNCATE'
+
+    begin
+      (@fromfile.size > 10).should be_true
+      @afc.put_path(@fromfile.to_s, remotepath).should == @fromfile.size
+      @afc.size(remotepath).should == @fromfile.size
+      @afc.truncate(remotepath, 10).should be_true
+      @afc.size(remotepath).should == 10
+    ensure
+      @afc.remove_path(remotepath) rescue nil
+    end
+  end
+
+  it "should get file mtime" do
+    res = @afc.mtime('.')
+    res.should be_a Time
+    # between first iphone release and 30-sec from now
+    res.should > Time.parse("June 29, 2007")
+    res.should < (Time.now+30)
+  end
+
+  it "should get file ctime" do
+    res = @afc.mtime('.')
+    res.should be_a Time
+    # between first iphone release and 30-sec from now
+    res.should > Time.parse("June 29, 2007")
+    res.should < (Time.now+30)
+  end
+
+  it "should touch a file" do
+    remotefile = "TESTFILETOUCH"
+    begin
+      @afc.touch(remotefile).should be_true
+      @afc.cat(remotefile).should == ""
+      @afc.ctime(remotefile).should == @afc.mtime(remotefile)
+    ensure
+      @afc.remove_path(remotefile) rescue nil
+    end
+  end
+
+  it "should set file time" do
+    remotefile = "TESTINGFILETIMESETTING"
+    settime = Time.parse("June 29, 2007 4:20 UTC")
+    begin
+      @afc.touch(remotefile).should be_true
+      @afc.ctime(remotefile).should_not == settime
+      @afc.mtime(remotefile).should_not == settime
+
+      @afc.set_file_time(remotefile, settime).should be_true
+      @afc.ctime(remotefile).should == settime
+      @afc.mtime(remotefile).should == settime
+    ensure
+      @afc.remove_path(remotefile) rescue nil
+    end
+  end
+
+  it "should open a file and read all its contents" do
+    remotepath = 'TESTFILEUPLOADFOROPENANDREAD'
+
+    begin
+      @afc.put_path(@fromfile.to_s, remotepath).should == @fromfile.size
+      dat = @afc.open(remotepath, 'r') { |f| f.read() }
+      dat.should == @fromfile.read()
+    ensure
+      @afc.remove_path(remotepath) rescue nil
+    end
+  end
+
+  it "should open a file and read a few bytes from it" do
+    remotepath = 'TESTFILEUPLOADFOROPENANDREAD'
+
+    begin
+      @afc.put_path(@fromfile.to_s, remotepath).should == @fromfile.size
+      @afc.open(remotepath, 'r') do |f|
+        f.read(6).should == "bplist"
+      end
+    ensure
+      @afc.remove_path(remotepath) rescue nil
+    end
+  end
+
+  it "should open a file skip ahead a few bytes offset and read from it" do
+    remotepath = 'TESTFILEUPLOADFOROPENANDREADOFFSET'
+
+    begin
+      @afc.put_path(@fromfile.to_s, remotepath).should == @fromfile.size
+      @afc.open(remotepath, 'r') do |f|
+        f.pos=2
+        f.read(4).should == "list"
+      end
+    ensure
+      @afc.remove_path(remotepath) rescue nil
+    end
+  end
+
+  it "should open a file and write to it" do
+    remotepath = 'TESTFILEUPLOADFOROPENANDWRITE'
+    testdata = "hellotest"
+
+    begin
+      @afc.open(remotepath, 'w') do |f|
+        f.write(testdata).should == testdata.size
+      end
+      @afc.cat(remotepath).should == testdata
+    ensure
+      @afc.remove_path(remotepath) rescue nil
+    end
+  end
+
+  it "should open a file and append to it" do
+    remotepath = 'TESTFILEUPLOADFOROPENANDAPEND'
+    testdata = "hellotest"
+
+    begin
+      @afc.open(remotepath, 'w') do |f|
+        f.write(testdata).should == testdata.size
+      end
+      @afc.cat(remotepath).should == testdata
+      @afc.open(remotepath, 'a') do |f|
+        f.pos.should == 0
+        f.pos+= testdata.size
+        f.pos.should == testdata.size
+        f.write(testdata).should == testdata.size
+      end
+      @afc.cat(remotepath).should == testdata + testdata
+    ensure
+      @afc.remove_path(remotepath) rescue nil
+    end
+  end
+
+  it "should open a file jump around positions and read/write to it" do
+    remotepath = 'TESTFILEUPLOADFOROPENANDWRITE'
+    testdata = "hellotest"
+
+    begin
+      @afc.open(remotepath, 'w') do |f|
+        f.write(testdata).should == testdata.size
+      end
+      @afc.open(remotepath, 'r+') do |f|
+        f.pos.should == 0
+        f.read().should == testdata
+        f.pos.should == testdata.size
+        f.rewind
+        f.pos.should == 0
+        f.seek(0, :SEEK_END)
+        f.pos.should == testdata.size
+        f.write(testdata).should == testdata.size
+        f.pos.should == testdata.size*2
+        f.rewind
+        f.read().should == testdata*2
+      end
+      @afc.cat(remotepath).should == testdata*2
+    ensure
+      @afc.remove_path(remotepath) rescue nil
+    end
+  end
+
+end