iphone.c File Reference

iPhone USB Ethernet driver More...

#include <stdint.h>
#include <string.h>
#include <stdio.h>
#include <errno.h>
#include <ipxe/netdevice.h>
#include <ipxe/ethernet.h>
#include <ipxe/if_ether.h>
#include <ipxe/profile.h>
#include <ipxe/base64.h>
#include <ipxe/sha256.h>
#include <ipxe/rsa.h>
#include <ipxe/x509.h>
#include <ipxe/pem.h>
#include <ipxe/xfer.h>
#include <ipxe/tls.h>
#include <ipxe/usb.h>
#include "iphone.h"

Go to the source code of this file.

Macros
#define	EPIPE_NO_MUX   __einfo_error ( EINFO_EPIPE_NO_MUX )
#define	EINFO_EPIPE_NO_MUX
#define	EINPROGRESS_PAIRING   __einfo_error ( EINFO_EINPROGRESS_PAIRING )
#define	EINFO_EINPROGRESS_PAIRING
#define	ENOTCONN_DISABLED   __einfo_error ( EINFO_ENOTCONN_DISABLED )
#define	EINFO_ENOTCONN_DISABLED
#define	ENOTCONN_STATUS(status)
#define	icert_key_suffix   a
	Key pair selection.
#define	icert_key_variable(prefix)
#define	icert_public   icert_key_variable ( icert_public_ )
#define	icert_private   icert_key_variable ( icert_private_ )

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
	FILE_SECBOOT (PERMITTED)
static int	ipair_create (struct interface *xfer, unsigned int flags)
	Create a pairing client.
static	LIST_HEAD (imuxes)
	List of USB multiplexers.
static	LIST_HEAD (iphones)
	List of iPhone network devices.
static void	icert_free (struct icert *icert)
	Free pairing certificates.
static int	icert_cert (struct icert *icert, struct asn1_cursor *subject, struct asn1_cursor *issuer, struct asn1_cursor *private, struct asn1_cursor *public, struct asn1_cursor *exts, struct x509_certificate **cert)
	Construct certificate.
static int	icert_certs (struct icert *icert, struct asn1_cursor *key)
	Construct certificates.
static int	icert_encode (struct icert *icert, struct x509_certificate *cert, char **encenc)
	Construct doubly base64-encoded certificate.
static int	imux_tx (struct imux *imux, struct io_buffer *iobuf)
	Transmit message.
static int	imux_tx_version (struct imux *imux)
	Transmit version message.
static int	imux_tx_tcp (struct imux *imux, struct io_buffer *iobuf)
	Transmit pseudo-TCP message.
static int	imux_tx_syn (struct imux *imux)
	Transmit pseudo-TCP SYN.
static int	imux_start_pair (struct imux *imux)
	Open pairing client.
static void	imux_rx_version (struct imux *imux)
	Receive version message.
static void	imux_rx_log (struct imux *imux, struct imux_header *hdr, size_t len)
	Receive log message.
static void	imux_rx_syn (struct imux *imux)
	Receive pseudo-TCP SYN+ACK.
static void	imux_rx_tcp (struct imux *imux, struct io_buffer *iobuf)
	Receive pseudo-TCP message.
static void	imux_in_complete (struct usb_endpoint *ep, struct io_buffer *iobuf, int rc)
	Complete bulk IN transfer.
static void	imux_out_complete (struct usb_endpoint *ep, struct io_buffer *iobuf, int rc)
	Complete bulk OUT transfer.
static void	imux_shutdown (struct imux *imux)
	Shut down USB multiplexer.
static void	imux_close (struct imux *imux, int rc)
	Close USB multiplexer.
static struct io_buffer *	imux_alloc_iob (struct imux *imux __unused, size_t len)
	Allocate I/O buffer for pseudo-TCP socket.
static int	imux_deliver (struct imux *imux, struct io_buffer *iobuf, struct xfer_metadata *meta __unused)
	Transmit packet via pseudo-TCP socket.
static void	imux_step (struct imux *imux)
	Multiplexer process.
static int	imux_probe (struct usb_function *func, struct usb_configuration_descriptor *config)
	Probe device.
static void	imux_remove (struct usb_function *func)
	Remove device.
static int	ipair_tx_pubkey (struct ipair *ipair)
	Transmit DevicePublicKey message.
static int	ipair_rx_pubkey (struct ipair *ipair, char *msg)
	Receive DevicePublicKey message.
static int	ipair_tx_pair (struct ipair *ipair)
	Transmit Pair message.
static int	ipair_rx_pair (struct ipair *ipair, char *msg)
	Receive Pair message.
static int	ipair_tx_session (struct ipair *ipair)
	Transmit StartSession message.
static int	ipair_rx_session (struct ipair *ipair, char *msg)
	Receive StartSession message.
static void	ipair_free (struct refcnt *refcnt)
	Free pairing client.
static void	ipair_close (struct ipair *ipair, int rc)
	Shut down pairing client.
static int	ipair_tx (struct ipair *ipair, const char *fmt,...)
	Transmit XML message.
static int	ipair_rx (struct ipair *ipair, char *msg, size_t len)
	Receive XML message payload.
static int	ipair_tag (struct ipair *ipair, const char *msg, const char *tag, char **start, char **end)
	Locate XML tag.
static int	ipair_key (struct ipair *ipair, const char *msg, const char *key, const char *type, char **start, char **end)
	Locate XML property list dictionary value.
static int	ipair_rx_pair_error (struct ipair *ipair, char *error)
	Receive Pair message error.
static int	ipair_rx_session_error (struct ipair *ipair, char *error)
	Receive StartSession message error.
static void	ipair_window_changed (struct ipair *ipair)
	Handle window change notification.
static int	ipair_deliver (struct ipair *ipair, struct io_buffer *iobuf, struct xfer_metadata *meta __unused)
	Handle received data.
static void	ipair_expired (struct retry_timer *timer, int over __unused)
	Pairing transmission timer.
static void	iphone_in_complete (struct usb_endpoint *ep, struct io_buffer *iobuf, int rc)
	Complete bulk IN transfer.
static int	iphone_out_transmit (struct iphone *iphone, struct io_buffer *iobuf)
	Transmit packet.
static void	iphone_out_complete (struct usb_endpoint *ep, struct io_buffer *iobuf, int rc)
	Complete bulk OUT transfer.
static int	iphone_check_pair (struct iphone *iphone)
	Check pairing status.
static void	iphone_check_link (struct net_device *netdev)
	Check link status.
static void	iphone_expired (struct retry_timer *timer, int over __unused)
	Periodically update link status.
static int	iphone_open (struct net_device *netdev)
	Open network device.
static void	iphone_close (struct net_device *netdev)
	Close network device.
static int	iphone_transmit (struct net_device *netdev, struct io_buffer *iobuf)
	Transmit packet.
static void	iphone_poll (struct net_device *netdev)
	Poll for completed and received packets.
static int	iphone_probe (struct usb_function *func, struct usb_configuration_descriptor *config)
	Probe device.
static void	iphone_remove (struct usb_function *func)
	Remove device.
	REQUIRING_SYMBOL (iphone_driver)
	REQUIRE_OBJECT (rsa_sha256)

Variables
static struct profiler iphone_in_profiler	__profiler
	Bulk IN completion profiler.
static uint8_t	icert_root_fingerprint [SHA256_DIGEST_SIZE]
	iPhone root certificate fingerprint
static struct x509_root	icert_root
	Root of trust for iPhone certificates.
static const uint8_t	icert_nul [] = { 0x00 }
	Single zero byte used in constructed certificates.
static const uint8_t	icert_rsa []
	"RSA algorithm" identifier used in constructed certificates
static const uint8_t	icert_sha256_rsa []
	"SHA-256 with RSA algorithm" identifier used in constructed certificates
static const uint8_t	icert_root_exts_data []
	Extensions used in constructed root certificate.
static struct asn1_cursor	icert_root_exts
	Extensions used in constructed root certificate.
static const uint8_t	icert_leaf_exts_data []
	Extensions used in constructed leaf certificates.
static struct asn1_cursor	icert_leaf_exts
	Extensions used in constructed leaf certificates.
static const uint8_t	icert_tbs_prefix []
	"TBSCertificate" prefix in constructed certificates
static const uint8_t	icert_validity []
	Validity period in constructed certificates.
static const uint8_t	icert_name_root_data []
	"Root" subject name
static struct asn1_cursor	icert_name_root
	"Root" subject name
static const uint8_t	icert_name_ipxe_data []
	"iPXE" subject name
static struct asn1_cursor	icert_name_ipxe
	"iPXE" subject name
static const uint8_t	icert_name_iphone_data []
	"iPhone" subject name
static struct asn1_cursor	icert_name_iphone
	"iPhone" subject name
static const uint8_t icert_public_a[]	__unused
	Public key(s) used for pairing.
static const char	icert_begin [] = "-----BEGIN CERTIFICATE-----\n"
	PEM certificate prefix.
static const char	icert_end [] = "\n-----END CERTIFICATE-----\n"
	PEM certificate suffix.
static struct usb_endpoint_driver_operations	imux_in_operations
	Bulk IN endpoint operations.
static struct usb_endpoint_driver_operations	imux_out_operations
	Bulk OUT endpoint operations.
static struct interface_operation	imux_tcp_operations []
	Pseudo-TCP socket interface operations.
static struct interface_descriptor	imux_tcp_desc
	Pseudo-TCP socket interface descriptor.
static struct process_descriptor	imux_process_desc
	Multiplexer process descriptor.
static struct usb_device_id	imux_ids []
	USB multiplexer device IDs.
struct usb_driver imux_driver	__usb_driver
	USB multiplexer driver.
static const char	ipair_prefix []
	Common prefix for all pairing messages.
static const char	ipair_suffix []
	Common suffix for all pairing messages.
static const char	ipair_system_buid [] = "E4DB92D2-248A-469A-AC34-92045D07E695"
	Arbitrary system BUID used for pairing.
static const char	ipair_host_id [] = "93CEBC27-8457-4804-9108-F42549DF6143"
	Arbitrary host ID used for pairing.
static struct interface_operation	ipair_xfer_operations []
	Pairing client interface operations.
static struct interface_descriptor	ipair_xfer_desc
	Pairing client interface descriptor.
static struct usb_endpoint_driver_operations	iphone_in_operations
	Bulk IN endpoint operations.
static struct usb_endpoint_driver_operations	iphone_out_operations
	Bulk OUT endpoint operations.
static struct net_device_operations	iphone_operations
	iPhone network device operations
static struct usb_device_id	iphone_ids []
	iPhone device IDs

Detailed Description

iPhone USB Ethernet driver

Definition in file iphone.c.

Macro Definition Documentation

EPIPE_NO_MUX

#define EPIPE_NO_MUX   __einfo_error ( EINFO_EPIPE_NO_MUX )

Definition at line 52 of file iphone.c.

Referenced by iphone_check_pair().

EINFO_EPIPE_NO_MUX

#define EINFO_EPIPE_NO_MUX

Value:

        __einfo_uniqify ( EINFO_EPIPE, 0x01,                          \
                          "No USB multiplexer" )

Definition at line 53 of file iphone.c.

#define EINFO_EPIPE_NO_MUX                                              \
        __einfo_uniqify ( EINFO_EPIPE, 0x01,                            \
                          "No USB multiplexer" )

EINPROGRESS_PAIRING

#define EINPROGRESS_PAIRING   __einfo_error ( EINFO_EINPROGRESS_PAIRING )

Definition at line 56 of file iphone.c.

Referenced by imux_probe().

EINFO_EINPROGRESS_PAIRING

#define EINFO_EINPROGRESS_PAIRING

Value:

        __einfo_uniqify ( EINFO_EINPROGRESS, 0x01,                      \
                          "Pairing in progress" )

Definition at line 57 of file iphone.c.

#define EINFO_EINPROGRESS_PAIRING                                       \
        __einfo_uniqify ( EINFO_EINPROGRESS, 0x01,                      \
                          "Pairing in progress" )

ENOTCONN_DISABLED

#define ENOTCONN_DISABLED   __einfo_error ( EINFO_ENOTCONN_DISABLED )

Definition at line 60 of file iphone.c.

EINFO_ENOTCONN_DISABLED

#define EINFO_ENOTCONN_DISABLED

Value:

        __einfo_uniqify ( EINFO_ENOTCONN, IPHONE_LINK_DISABLED,                \
                          "Personal Hotspot disabled" )

Definition at line 61 of file iphone.c.

#define EINFO_ENOTCONN_DISABLED                                         \
        __einfo_uniqify ( EINFO_ENOTCONN, IPHONE_LINK_DISABLED,         \
                          "Personal Hotspot disabled" )

ENOTCONN_STATUS

#define ENOTCONN_STATUS

(

status

)

Value:

        EUNIQ ( EINFO_ENOTCONN, ( (status) & 0x1f ),                   \
                ENOTCONN_DISABLED )

Definition at line 64 of file iphone.c.

#define ENOTCONN_STATUS( status )                                       \
        EUNIQ ( EINFO_ENOTCONN, ( (status) & 0x1f ),                    \
                ENOTCONN_DISABLED )

Referenced by iphone_check_link().

icert_key_suffix

#define icert_key_suffix   a

Key pair selection.

This exists only to allow for testing of the process for handling a failed TLS negotiation.

Definition at line 315 of file iphone.c.

icert_key_variable

#define icert_key_variable

(

prefix

)

Value:

_C2 ( prefix, icert_key_suffix )

Definition at line 316 of file iphone.c.

icert_public

#define icert_public   icert_key_variable ( icert_public_ )

Definition at line 317 of file iphone.c.

Referenced by icert_certs().

icert_private

#define icert_private   icert_key_variable ( icert_private_ )

Definition at line 318 of file iphone.c.

Referenced by icert_certs().

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

FILE_SECBOOT()

FILE_SECBOOT

(

PERMITTED

)

ipair_create()

int ipair_create ( struct interface * xfer, unsigned int flags )

static

Create a pairing client.

Parameters

xfer	Data transfer interface
flags	Initial state flags

Return values

rc	Return status code

Definition at line 1831 of file iphone.c.

                                                                       {
        struct ipair *ipair;
        int rc;
 
        /* Allocate and initialise structure */
        ipair = zalloc ( sizeof ( *ipair ) );
        if ( ! ipair ) {
                rc = -ENOMEM;
                goto err_alloc;
        }
        ref_init ( &ipair->refcnt, ipair_free );
        intf_init ( &ipair->xfer, &ipair_xfer_desc, &ipair->refcnt );
        timer_init ( &ipair->timer, ipair_expired, &ipair->refcnt );
        ipair->tx = ipair_tx_pubkey;
        ipair->rx = ipair_rx_pubkey;
        ipair->flags = flags;
 
        /* Schedule initial transmission */
        start_timer_nodelay ( &ipair->timer );
 
        /* Attach to parent interface, mortalise self, and return */
        intf_plug_plug ( &ipair->xfer, xfer );
        ref_put ( &ipair->refcnt );
        return 0;
 
        ref_put ( &ipair->refcnt );
 err_alloc:
        return rc;
}

References ENOMEM, flags, ipair::flags, intf_init(), intf_plug_plug(), ipair_expired(), ipair_free(), ipair_rx_pubkey(), ipair_tx_pubkey(), ipair_xfer_desc, rc, ref_init, ref_put, ipair::refcnt, ipair::rx, start_timer_nodelay(), ipair::timer, ipair::tx, ipair::xfer, and zalloc().

Referenced by imux_start_pair().

LIST_HEAD() [1/2]

LIST_HEAD ( imuxes )

static

List of USB multiplexers.

LIST_HEAD() [2/2]

LIST_HEAD ( iphones )

static

List of iPhone network devices.

icert_free()

void icert_free ( struct icert * icert )

static

Free pairing certificates.

Parameters

icert

Pairing certificates

Definition at line 331 of file iphone.c.

                                               {
 
        privkey_put ( icert->key );
        x509_put ( icert->root );
        x509_put ( icert->host );
        x509_put ( icert->device );
        memset ( icert, 0, sizeof ( *icert ) );
}

References icert::device, icert::host, icert::key, memset(), privkey_put(), icert::root, and x509_put().

Referenced by icert_certs(), and ipair_free().

icert_cert()

int icert_cert ( struct icert * icert, struct asn1_cursor * subject, struct asn1_cursor * issuer, struct asn1_cursor * private, struct asn1_cursor * public, struct asn1_cursor * exts, struct x509_certificate ** cert )

static

Construct certificate.

Parameters

icert	Pairing certificates
subject	Subject name
issuer	Issuer name
private	Private key
public	Public key
exts	Certificate extensions
cert	Certificate to fill in

Return values

rc	Return status code

On success, the caller is responsible for eventually calling x509_put() on the allocated encoded certificate.

Definition at line 355 of file iphone.c.

                                                         {
        struct digest_algorithm *digest = &sha256_algorithm;
        struct pubkey_algorithm *pubkey = &rsa_algorithm;
        struct asn1_builder spki = { NULL, 0 };
        struct asn1_builder tbs = { NULL, 0 };
        struct asn1_builder raw = { NULL, 0 };
        uint8_t digest_ctx[SHA256_CTX_SIZE];
        uint8_t digest_out[SHA256_DIGEST_SIZE];
        int rc;
 
        /* Construct subjectPublicKeyInfo */
        if ( ( rc = ( asn1_prepend_raw ( &spki, public->data, public->len ),
                      asn1_prepend_raw ( &spki, icert_nul,
                                         sizeof ( icert_nul ) ),
                      asn1_wrap ( &spki, ASN1_BIT_STRING ),
                      asn1_prepend_raw ( &spki, icert_rsa,
                                         sizeof ( icert_rsa ) ),
                      asn1_wrap ( &spki, ASN1_SEQUENCE ) ) ) != 0 ) {
                DBGC ( icert, "ICERT %p could not build subjectPublicKeyInfo: "
                       "%s\n", icert, strerror ( rc ) );
                goto err_spki;
        }
 
        /* Construct tbsCertificate */
        if ( ( rc = ( asn1_prepend_raw ( &tbs, exts->data, exts->len ),
                      asn1_prepend_raw ( &tbs, spki.data, spki.len ),
                      asn1_prepend_raw ( &tbs, subject->data, subject->len ),
                      asn1_prepend_raw ( &tbs, icert_validity,
                                         sizeof ( icert_validity ) ),
                      asn1_prepend_raw ( &tbs, issuer->data, issuer->len ),
                      asn1_prepend_raw ( &tbs, icert_tbs_prefix,
                                         sizeof ( icert_tbs_prefix ) ),
                      asn1_wrap ( &tbs, ASN1_SEQUENCE ) ) ) != 0 ) {
                DBGC ( icert, "ICERT %p could not build tbsCertificate: %s\n",
                       icert, strerror ( rc ) );
                goto err_tbs;
        }
 
        /* Calculate certificate digest */
        digest_init ( digest, digest_ctx );
        digest_update ( digest, digest_ctx, tbs.data, tbs.len );
        digest_final ( digest, digest_ctx, digest_out );
 
        /* Construct signature using "private" key */
        if ( ( rc = pubkey_sign ( pubkey, private, digest, digest_out,
                                  &raw ) ) != 0 ) {
                DBGC ( icert, "ICERT %p could not sign: %s\n",
                       icert, strerror ( rc ) );
                goto err_pubkey_sign;
        }
 
        /* Construct raw certificate data */
        if ( ( rc = ( asn1_prepend_raw ( &raw, icert_nul,
                                         sizeof ( icert_nul ) ),
                      asn1_wrap ( &raw, ASN1_BIT_STRING ),
                      asn1_prepend_raw ( &raw, icert_sha256_rsa,
                                         sizeof ( icert_sha256_rsa ) ),
                      asn1_prepend_raw ( &raw, tbs.data, tbs.len ),
                      asn1_wrap ( &raw, ASN1_SEQUENCE ) ) ) != 0 ) {
                DBGC ( icert, "ICERT %p could not build certificate: %s\n",
                       icert, strerror ( rc ) );
                goto err_raw;
        }
 
        /* Parse certificate */
        if ( ( rc = x509_certificate ( raw.data, raw.len, cert ) ) != 0 ) {
                DBGC ( icert, "ICERT %p invalid certificate: %s\n",
                       icert, strerror ( rc ) );
                DBGC_HDA ( icert, 0, raw.data, raw.len );
                goto err_x509;
        }
 
 err_x509:
 err_raw:
 err_pubkey_sign:
 err_tbs:
 err_spki:
        free ( raw.data );
        free ( tbs.data );
        free ( spki.data );
        return rc;
}

References ASN1_BIT_STRING, asn1_prepend_raw(), ASN1_SEQUENCE, asn1_wrap(), asn1_builder::data, asn1_cursor::data, DBGC, DBGC_HDA, digest_final(), digest_init(), digest_update(), free, icert_nul, icert_rsa, icert_sha256_rsa, icert_tbs_prefix, icert_validity, asn1_builder::len, asn1_cursor::len, NULL, pubkey_sign(), raw, rc, rsa_algorithm, sha256_algorithm, SHA256_CTX_SIZE, SHA256_DIGEST_SIZE, and strerror().

Referenced by icert_certs().

icert_certs()

int icert_certs ( struct icert * icert, struct asn1_cursor * key )

static

Construct certificates.

Parameters

icert	Certificate set
pubkey	Device public key

Return values

rc	Return status code

Definition at line 448 of file iphone.c.

                                                                        {
        struct digest_algorithm *digest = icert_root.digest;
        struct asn1_builder public = { NULL, 0 };
        struct asn1_builder *private;
        int rc;
 
        /* Free any existing key and certificates */
        icert_free ( icert );
 
        /* Allocate "private" key */
        icert->key = zalloc ( sizeof ( *icert->key ) );
        if ( ! icert->key ) {
                rc = -ENOMEM;
                goto error;
        }
        privkey_init ( icert->key );
        private = &icert->key->builder;
 
        /* Construct our "private" key */
        if ( ( rc = ( asn1_prepend_raw ( private, icert_private,
                                         sizeof ( icert_private ) ),
                      asn1_prepend_raw ( private, icert_public,
                                         sizeof ( icert_public ) ),
                      asn1_prepend ( private, ASN1_INTEGER, icert_nul,
                                     sizeof ( icert_nul ) ),
                      asn1_wrap ( private, ASN1_SEQUENCE ) ) ) != 0 ) {
                DBGC ( icert, "ICERT %p could not build private key: %s\n",
                       icert, strerror ( rc ) );
                goto error;
        }
 
        /* Construct our own public key */
        if ( ( rc = ( asn1_prepend_raw ( &public, icert_public,
                                         sizeof ( icert_public ) ),
                      asn1_wrap ( &public, ASN1_SEQUENCE ) ) ) != 0 ) {
                DBGC ( icert, "ICERT %p could not build public key: %s\n",
                       icert, strerror ( rc ) );
                goto error;
        }
 
        /* Construct root certificate */
        if ( ( rc = icert_cert ( icert, &icert_name_root, &icert_name_root,
                                 asn1_built ( private ), asn1_built ( &public ),
                                 &icert_root_exts, &icert->root ) ) != 0 )
                goto error;
 
        /* Construct host certificate */
        if ( ( rc = icert_cert ( icert, &icert_name_ipxe, &icert_name_root,
                                 asn1_built ( private ), asn1_built ( &public ),
                                 &icert_leaf_exts, &icert->host ) ) != 0 )
                goto error;
 
        /* Construct device certificate */
        if ( ( rc = icert_cert ( icert, &icert_name_iphone, &icert_name_root,
                                 asn1_built ( private ), key,
                                 &icert_leaf_exts, &icert->device ) ) != 0 )
                goto error;
 
        /* Construct root of trust */
        assert ( digest->digestsize == sizeof ( icert_root_fingerprint ) );
        x509_fingerprint ( icert->root, digest, icert_root_fingerprint );
 
        /* Free constructed keys */
        free ( public.data );
        return 0;
 
 error:
        icert_free ( icert );
        free ( public.data );
        return rc;
}

References asn1_built(), ASN1_INTEGER, asn1_prepend(), asn1_prepend_raw(), ASN1_SEQUENCE, asn1_wrap(), assert, private_key::builder, data, DBGC, icert::device, digest_algorithm::digestsize, ENOMEM, error, free, icert::host, icert_cert(), icert_free(), icert_leaf_exts, icert_name_iphone, icert_name_ipxe, icert_name_root, icert_nul, icert_private, icert_public, icert_root, icert_root_exts, icert_root_fingerprint, icert::key, key, NULL, privkey_init(), rc, icert::root, strerror(), x509_fingerprint(), and zalloc().

Referenced by ipair_rx_pubkey().

icert_encode()

int icert_encode ( struct icert * icert, struct x509_certificate * cert, char ** encenc )

static

Construct doubly base64-encoded certificate.

Parameters

icert	Pairing certificates
cert	X.509 certificate
encenc	Doubly base64-encoded certificate to construct

Return values

rc	Return status code

On success, the caller is responsible for eventually calling free() on the allocated doubly encoded encoded certificate.

Definition at line 531 of file iphone.c.

                                          {
        size_t encencoded_len;
        size_t encoded_len;
        size_t pem_len;
        char *pem;
        int rc;
 
        /* Sanity check */
        assert ( cert != NULL );
 
        /* Create PEM */
        encoded_len = ( base64_encoded_len ( cert->raw.len ) + 1 /* NUL */ );
        pem_len = ( ( sizeof ( icert_begin ) - 1 /* NUL */ ) +
                    ( encoded_len - 1 /* NUL */ ) +
                    ( sizeof ( icert_end ) - 1 /* NUL */ ) +
                    1 /* NUL */ );
        pem = malloc ( pem_len );
        if ( ! pem ) {
                rc = -ENOMEM;
                goto err_alloc_pem;
        }
        strcpy ( pem, icert_begin );
        base64_encode ( cert->raw.data, cert->raw.len,
                        ( pem + sizeof ( icert_begin ) - 1 /* NUL */ ),
                        encoded_len );
        strcpy ( ( pem +
                   ( sizeof ( icert_begin ) - 1 /* NUL */ ) +
                   ( encoded_len - 1 /* NUL */ ) ), icert_end );
        DBGC2 ( icert, "ICERT %p \"%s\" certificate:\n%s",
                icert, x509_name ( cert ), pem );
 
        /* Base64-encode the PEM (sic) */
        encencoded_len = ( base64_encoded_len ( pem_len - 1 /* NUL */ )
                           + 1 /* NUL */ );
        *encenc = malloc ( encencoded_len );
        if ( ! *encenc ) {
                rc = -ENOMEM;
                goto err_alloc_encenc;
        }
        base64_encode ( pem, ( pem_len - 1 /* NUL */ ), *encenc,
                        encencoded_len );
 
        /* Success */
        rc = 0;
 
 err_alloc_encenc:
        free ( pem );
 err_alloc_pem:
        return rc;
}

References assert, base64_encode(), base64_encoded_len(), asn1_cursor::data, DBGC2, ENOMEM, free, icert_begin, icert_end, asn1_cursor::len, malloc(), NULL, x509_certificate::raw, rc, strcpy(), and x509_name().

Referenced by ipair_tx_pair().

imux_tx()

int imux_tx ( struct imux * imux, struct io_buffer * iobuf )

static

Transmit message.

Parameters

imux	USB multiplexer
iobuf	I/O buffer

Return values

rc	Return status code

Definition at line 601 of file iphone.c.

                                                                  {
        struct imux_header *hdr = iobuf->data;
        size_t len = iob_len ( iobuf );
        int rc;
 
        /* Populate header */
        assert ( len >= sizeof ( *hdr ) );
        hdr->len = htonl ( len );
        hdr->in_seq = htons ( imux->in_seq );
        hdr->out_seq = htons ( imux->out_seq );
        DBGCP ( imux, "IMUX %p transmitting:\n", imux );
        DBGCP_HDA ( imux, 0, hdr, len );
 
        /* Transmit message */
        if ( ( rc = usb_stream ( &imux->usbnet.out, iobuf, 1 ) ) != 0 )
                goto err;
 
        /* Increment sequence number */
        imux->out_seq++;
 
        return 0;
 
 err:
        free_iob ( iobuf );
        return rc;
}

References assert, io_buffer::data, DBGCP, DBGCP_HDA, free_iob(), hdr, htonl, htons, imux::in_seq, iob_len(), len, usbnet_device::out, imux::out_seq, rc, usb_stream(), and imux::usbnet.

Referenced by imux_tx_tcp(), and imux_tx_version().

imux_tx_version()

int imux_tx_version ( struct imux * imux )

static

Transmit version message.

Parameters

imux	USB multiplexer

Return values

rc	Return status code

Definition at line 634 of file iphone.c.

                                                 {
        struct io_buffer *iobuf;
        struct imux_header_version *vers;
        int rc;
 
        /* Allocate I/O buffer */
        iobuf = alloc_iob ( sizeof ( *vers ) );
        if ( ! iobuf )
                return -ENOMEM;
        vers = iob_put ( iobuf, sizeof ( *vers ) );
 
        /* Construct version message */
        memset ( vers, 0, sizeof ( *vers ) );
        vers->hdr.protocol = htonl ( IMUX_VERSION );
 
        /* Transmit message */
        if ( ( rc = imux_tx ( imux, iob_disown ( iobuf ) ) ) != 0 )
                return rc;
 
        return 0;
}

References alloc_iob(), ENOMEM, imux_header_version::hdr, htonl, imux_tx(), IMUX_VERSION, iob_disown, iob_put, memset(), imux_header::protocol, and rc.

Referenced by imux_probe().

imux_tx_tcp()

int imux_tx_tcp ( struct imux * imux, struct io_buffer * iobuf )

static

Transmit pseudo-TCP message.

Parameters

imux	USB multiplexer
iobuf	I/O buffer

Return values

rc	Return status code

Definition at line 663 of file iphone.c.

                                                                      {
        struct imux_header_tcp *tcp = iobuf->data;
        size_t len = iob_len ( iobuf );
        int rc;
 
        /* Populate TCP header */
        assert ( len >= sizeof ( *tcp ) );
        tcp->hdr.protocol = htonl ( IMUX_TCP );
        tcp->tcp.src = htons ( imux->port );
        tcp->tcp.dest = htons ( IMUX_PORT_LOCKDOWND );
        tcp->tcp.seq = htonl ( imux->tcp_seq );
        tcp->tcp.ack = htonl ( imux->tcp_ack );
        tcp->tcp.hlen = ( ( sizeof ( tcp->tcp ) / 4 ) << 4 );
        tcp->tcp.win = htons ( IMUX_WINDOW );
 
        /* Transmit message */
        if ( ( rc = imux_tx ( imux, iob_disown ( iobuf ) ) ) != 0 )
                return rc;
 
        /* Update TCP sequence */
        imux->tcp_seq += ( len - sizeof ( *tcp ) );
 
        return 0;
}

References tcp_header::ack, assert, io_buffer::data, tcp_header::dest, tcp_header::hlen, htonl, htons, IMUX_PORT_LOCKDOWND, IMUX_TCP, imux_tx(), IMUX_WINDOW, iob_disown, iob_len(), len, imux::port, rc, tcp_header::seq, tcp_header::src, imux_header_tcp::tcp, imux::tcp_ack, imux::tcp_seq, and tcp_header::win.

Referenced by imux_deliver(), and imux_tx_syn().

imux_tx_syn()

int imux_tx_syn ( struct imux * imux )

static

Transmit pseudo-TCP SYN.

Parameters

imux	USB multiplexer

Return values

rc	Return status code

Definition at line 694 of file iphone.c.

                                             {
        struct io_buffer *iobuf;
        struct imux_header_tcp *syn;
        int rc;
 
        /* Allocate I/O buffer */
        iobuf = alloc_iob ( sizeof ( *syn ) );
        if ( ! iobuf )
                return -ENOMEM;
        syn = iob_put ( iobuf, sizeof ( *syn ) );
 
        /* Construct TCP SYN message */
        memset ( syn, 0, sizeof ( *syn ) );
        syn->tcp.flags = TCP_SYN;
 
        /* Transmit message */
        if ( ( rc = imux_tx_tcp ( imux, iob_disown ( iobuf ) ) ) != 0 )
                return rc;
 
        /* Increment TCP sequence to compensate for SYN */
        imux->tcp_seq++;
 
        return 0;
}

References alloc_iob(), ENOMEM, tcp_header::flags, imux_tx_tcp(), iob_disown, iob_put, memset(), rc, imux_header_tcp::tcp, imux::tcp_seq, and TCP_SYN.

Referenced by imux_close(), and imux_rx_version().

imux_start_pair()

int imux_start_pair ( struct imux * imux )

static

Open pairing client.

Parameters

imux	USB multiplexer

Return values

rc	Return status code

Definition at line 725 of file iphone.c.

                                                 {
        int rc;
 
        /* Disconnect any existing pairing client */
        intf_restart ( &imux->tcp, -EPIPE );
 
        /* Create pairing client */
        if ( ( rc = ipair_create ( &imux->tcp, imux->flags ) ) != 0 )
                return rc;
 
        return 0;
}

References EPIPE, imux::flags, intf_restart(), ipair_create(), rc, and imux::tcp.

Referenced by imux_rx_syn().

imux_rx_version()

void imux_rx_version ( struct imux * imux )

static

Receive version message.

Parameters

imux	USB multiplexer

Definition at line 743 of file iphone.c.

                                                  {
 
        /* Reset output sequence */
        imux->out_seq = 0;
 
        /* Send TCP SYN */
        imux->action = imux_tx_syn;
}

References imux::action, imux_tx_syn(), and imux::out_seq.

Referenced by imux_in_complete().

imux_rx_log()

void imux_rx_log ( struct imux * imux, struct imux_header * hdr, size_t len )

static

Receive log message.

Parameters

imux	USB multiplexer
hdr	Message header
len	Length of message

Definition at line 759 of file iphone.c.

                                       {
        struct imux_header_log *log =
                container_of ( hdr, struct imux_header_log, hdr );
        unsigned int level;
        size_t msg_len;
        char *tmp;
 
        /* Sanity check */
        if ( len < sizeof ( *log ) ) {
                DBGC ( imux, "IMUX %p malformed log message:\n", imux );
                DBGC_HDA ( imux, 0, log, len );
                return;
        }
 
        /* First byte is the log level, followed by a printable
         * message with no NUL terminator.  Extract the log level,
         * then shuffle the message down within the buffer and append
         * a NUL terminator.
         */
        msg_len = ( len - sizeof ( *hdr ) );
        level = log->level;
        tmp = ( ( void * ) &log->level );
        memmove ( tmp, &log->msg, msg_len );
        tmp[msg_len] = '\0';
 
        /* Print log message */
        DBGC ( imux, "IMUX %p <%d>: %s\n", imux, level, tmp );
}

References container_of, DBGC, DBGC_HDA, hdr, len, imux_header_log::level, memmove(), imux_header_log::msg, and tmp.

Referenced by imux_in_complete().

imux_rx_syn()

void imux_rx_syn ( struct imux * imux )

static

Receive pseudo-TCP SYN+ACK.

Parameters

imux	USB multiplexer

Definition at line 794 of file iphone.c.

                                              {
 
        /* Increment TCP acknowledgement to compensate for SYN */
        imux->tcp_ack++;
 
        /* Start pairing client */
        imux->action = imux_start_pair;
}

References imux::action, imux_start_pair(), and imux::tcp_ack.

Referenced by imux_rx_tcp().

imux_rx_tcp()

void imux_rx_tcp ( struct imux * imux, struct io_buffer * iobuf )

static

Receive pseudo-TCP message.

Parameters

imux	USB multiplexer
iobuf	I/O buffer

Definition at line 809 of file iphone.c.

                                                                       {
        struct imux_header_tcp *tcp = iobuf->data;
        size_t len = iob_len ( iobuf );
        int rc;
 
        /* Sanity check */
        if ( len < sizeof ( *tcp ) ) {
                DBGC ( imux, "IMUX %p malformed TCP message:\n", imux );
                DBGC_HDA ( imux, 0, tcp, len );
                goto error;
        }
 
        /* Ignore unexpected packets */
        if ( tcp->tcp.dest != htons ( imux->port ) ) {
                DBGC ( imux, "IMUX %p ignoring unexpected TCP port %d:\n",
                       imux, ntohs ( tcp->tcp.dest ) );
                DBGC_HDA ( imux, 0, tcp, len );
                goto error;
        }
 
        /* Ignore resets */
        if ( tcp->tcp.flags & TCP_RST ) {
                DBGC ( imux, "IMUX %p ignoring TCP RST\n", imux );
                DBGC2_HDA ( imux, 0, tcp, len );
                goto error;
        }
 
        /* Record ACK number */
        imux->tcp_ack = ( ntohl ( tcp->tcp.seq ) + len - sizeof ( *tcp ) );
 
        /* Handle received message */
        if ( tcp->tcp.flags & TCP_SYN ) {
 
                /* Received SYN+ACK */
                imux_rx_syn ( imux );
 
        } else {
 
                /* Strip header */
                iob_pull ( iobuf, sizeof ( *tcp ) );
 
                /* Deliver via socket */
                if ( ( rc = xfer_deliver_iob ( &imux->tcp,
                                               iob_disown ( iobuf ) ) ) != 0 )
                        goto error;
        }
 
 error:
        free_iob ( iobuf );
}

References io_buffer::data, DBGC, DBGC2_HDA, DBGC_HDA, tcp_header::dest, error, tcp_header::flags, free_iob(), htons, imux_rx_syn(), iob_disown, iob_len(), iob_pull, len, ntohl, ntohs, imux::port, rc, tcp_header::seq, imux::tcp, imux_header_tcp::tcp, imux::tcp_ack, TCP_RST, TCP_SYN, and xfer_deliver_iob().

Referenced by imux_in_complete().

imux_in_complete()

void imux_in_complete ( struct usb_endpoint * ep, struct io_buffer * iobuf, int rc )

static

Complete bulk IN transfer.

Parameters

ep	USB endpoint
iobuf	I/O buffer
rc	Completion status code

Definition at line 867 of file iphone.c.

                                                                 {
        struct imux *imux = container_of ( ep, struct imux, usbnet.in );
        struct imux_header *hdr = iobuf->data;
        size_t len = iob_len ( iobuf );
 
        /* Ignore packets cancelled when the endpoint closes */
        if ( ! ep->open )
                goto drop;
 
        /* Report USB errors */
        if ( rc != 0 ) {
                DBGC ( imux, "IMUX %p bulk IN failed: %s\n",
                       imux, strerror ( rc ) );
                goto drop;
        }
 
        /* Sanity check */
        if ( len < sizeof ( *hdr ) ) {
                DBGC ( imux, "IMUX %p malformed message:\n", imux );
                DBGC_HDA ( imux, 0, hdr, len );
                goto drop;
        }
 
        /* Record input sequence */
        imux->in_seq = ntohs ( hdr->in_seq );
 
        /* Handle according to protocol */
        DBGCP ( imux, "IMUX %p received:\n", imux );
        DBGCP_HDA ( imux, 0, hdr, len );
        switch ( hdr->protocol ) {
        case htonl ( IMUX_VERSION ):
                imux_rx_version ( imux );
                break;
        case htonl ( IMUX_LOG ):
                imux_rx_log ( imux, hdr, len );
                break;
        case htonl ( IMUX_TCP ):
                imux_rx_tcp ( imux, iob_disown ( iobuf ) );
                break;
        default:
                DBGC ( imux, "IMUX %p unknown message type %d:\n",
                       imux, ntohl ( hdr->protocol ) );
                DBGC_HDA ( imux, 0, hdr, len );
                break;
        }
 
 drop:
        free_iob ( iobuf );
}

References container_of, io_buffer::data, DBGC, DBGC_HDA, DBGCP, DBGCP_HDA, free_iob(), hdr, htonl, IMUX_LOG, imux_rx_log(), imux_rx_tcp(), imux_rx_version(), IMUX_TCP, IMUX_VERSION, usbnet_device::in, imux::in_seq, iob_disown, iob_len(), len, ntohl, ntohs, usb_endpoint::open, rc, strerror(), and imux::usbnet.

imux_out_complete()

void imux_out_complete ( struct usb_endpoint * ep, struct io_buffer * iobuf, int rc )

static

Complete bulk OUT transfer.

Parameters

ep	USB endpoint
iobuf	I/O buffer
rc	Completion status code

Definition at line 930 of file iphone.c.

                                                                  {
        struct imux *imux = container_of ( ep, struct imux, usbnet.out );
 
        /* Report USB errors */
        if ( rc != 0 ) {
                DBGC ( imux, "IMUX %p bulk OUT failed: %s\n",
                       imux, strerror ( rc ) );
                goto error;
        }
 
 error:
        free_iob ( iobuf );
}

References container_of, DBGC, error, free_iob(), usbnet_device::out, rc, strerror(), and imux::usbnet.

imux_shutdown()

void imux_shutdown ( struct imux * imux )

static

Shut down USB multiplexer.

Parameters

imux	USB multiplexer

Definition at line 955 of file iphone.c.

                                                {
 
        /* Shut down interfaces */
        intf_shutdown ( &imux->tcp, -ECANCELED );
 
        /* Close USB network device, if open */
        if ( process_running ( &imux->process ) ) {
                process_del ( &imux->process );
                usbnet_close ( &imux->usbnet );
        }
}

References ECANCELED, intf_shutdown(), imux::process, process_del(), process_running(), imux::tcp, imux::usbnet, and usbnet_close().

Referenced by imux_close(), imux_probe(), and imux_remove().

imux_close()

void imux_close ( struct imux * imux, int rc )

static

Close USB multiplexer.

Parameters

imux	USB multiplexer
rc	Reason for close

Definition at line 973 of file iphone.c.

                                                     {
        struct iphone *iphone;
 
        /* Restart interfaces */
        intf_restart ( &imux->tcp, rc );
 
        /* Record pairing status */
        imux->rc = rc;
 
        /* Trigger link check on any associated iPhones */
        list_for_each_entry ( iphone, &iphones, list ) {
                if ( iphone->usb == imux->usb )
                        start_timer_nodelay ( &iphone->timer );
        }
 
        /* Retry pairing on any error */
        if ( rc != 0 ) {
 
                /* Increment port number */
                imux->port++;
 
                /* Request pairing on any retry attempt */
                imux->flags = IPAIR_REQUEST;
 
                /* Send new pseudo-TCP SYN */
                imux->action = imux_tx_syn;
 
                DBGC ( imux, "IMUX %p retrying pairing: %s\n",
                       imux, strerror ( rc ) );
                return;
        }
 
        /* Shut down multiplexer on pairing success */
        imux_shutdown ( imux );
}

References imux::action, DBGC, imux::flags, imux_shutdown(), imux_tx_syn(), intf_restart(), IPAIR_REQUEST, iphone::list, list_for_each_entry, imux::port, imux::rc, rc, start_timer_nodelay(), strerror(), imux::tcp, iphone::timer, imux::usb, and iphone::usb.

Referenced by imux_step().

imux_alloc_iob()

struct io_buffer * imux_alloc_iob ( struct imux *imux __unused, size_t len )

static

Allocate I/O buffer for pseudo-TCP socket.

Parameters

imux	USB multiplexer
len	I/O buffer payload length

Return values

iobuf

I/O buffer

Definition at line 1016 of file iphone.c.

                                                        {
        struct imux_header_tcp *tcp;
        struct io_buffer *iobuf;
 
        /* Allocate I/O buffer */
        iobuf = alloc_iob ( sizeof ( *tcp ) + len );
        if ( ! iobuf )
                return NULL;
 
        /* Reserve space for pseudo-TCP message header */
        iob_reserve ( iobuf, sizeof ( *tcp ) );
 
        return iobuf;
}

References __unused, alloc_iob(), iob_reserve, len, NULL, and imux_header_tcp::tcp.

imux_deliver()

int imux_deliver ( struct imux * imux, struct io_buffer * iobuf, struct xfer_metadata *meta __unused )

static

Transmit packet via pseudo-TCP socket.

Parameters

imux	USB multiplexer
iobuf	I/O buffer
meta	Data transfer metadata

Return values

rc	Return status code

Definition at line 1040 of file iphone.c.

                                                                {
        struct imux_header_tcp *tcp;
 
        /* Prepend pseudo-TCP header */
        tcp = iob_push ( iobuf, sizeof ( *tcp ) );
        memset ( tcp, 0, sizeof ( *tcp ) );
        tcp->tcp.flags = TCP_ACK;
 
        /* Transmit pseudo-TCP packet */
        return imux_tx_tcp ( imux, iob_disown ( iobuf ) );
}

References __unused, tcp_header::flags, imux_tx_tcp(), iob_disown, iob_push, memset(), meta, imux_header_tcp::tcp, and TCP_ACK.

imux_step()

void imux_step ( struct imux * imux )

static

Multiplexer process.

Parameters

imux	USB multiplexer

Definition at line 1069 of file iphone.c.

                                            {
        int rc;
 
        /* Poll USB bus */
        usb_poll ( imux->bus );
 
        /* Do nothing more if multiplexer has been closed */
        if ( ! process_running ( &imux->process ) )
                return;
 
        /* Refill endpoints */
        if ( ( rc = usbnet_refill ( &imux->usbnet ) ) != 0 ) {
                /* Wait for next poll */
                return;
        }
 
        /* Perform pending action, if any */
        if ( imux->action ) {
                if ( ( rc = imux->action ( imux ) ) != 0 )
                        imux_close ( imux, rc );
                imux->action = NULL;
        }
}

References imux::action, imux::bus, imux_close(), NULL, imux::process, process_running(), rc, usb_poll(), imux::usbnet, and usbnet_refill().

imux_probe()

int imux_probe ( struct usb_function * func, struct usb_configuration_descriptor * config )

static

Probe device.

Parameters

func	USB function
config	Configuration descriptor

Return values

rc	Return status code

Definition at line 1104 of file iphone.c.

                                                                      {
        struct usb_device *usb = func->usb;
        struct imux *imux;
        int rc;
 
        /* Allocate and initialise structure */
        imux = zalloc ( sizeof ( *imux ) );
        if ( ! imux ) {
                rc = -ENOMEM;
                goto err_alloc;
        }
        ref_init ( &imux->refcnt, NULL );
        imux->usb = usb;
        imux->bus = usb->port->hub->bus;
        usbnet_init ( &imux->usbnet, func, NULL, &imux_in_operations,
                      &imux_out_operations );
        usb_refill_init ( &imux->usbnet.in, 0, IMUX_IN_MTU, IMUX_IN_MAX_FILL );
        process_init ( &imux->process, &imux_process_desc, &imux->refcnt );
        imux->action = imux_tx_version;
        imux->port = IMUX_PORT_LOCAL;
        intf_init ( &imux->tcp, &imux_tcp_desc, &imux->refcnt );
        imux->rc = -EINPROGRESS_PAIRING;
 
        /* Describe USB network device */
        if ( ( rc = usbnet_describe ( &imux->usbnet, config ) ) != 0 ) {
                DBGC ( imux, "IMUX %p could not describe: %s\n",
                       imux, strerror ( rc ) );
                goto err_describe;
        }
 
        /* Open USB network device */
        if ( ( rc = usbnet_open ( &imux->usbnet ) ) != 0 ) {
                DBGC ( imux, "IMUX %p could not open: %s\n",
                       imux, strerror ( rc ) );
                goto err_open;
        }
 
        /* Start polling process */
        process_add ( &imux->process );
 
        /* Add to list of multiplexers */
        list_add ( &imux->list, &imuxes );
 
        usb_func_set_drvdata ( func, imux );
        return 0;
 
        list_del ( &imux->list );
        imux_shutdown ( imux );
 err_open:
 err_describe:
        ref_put ( &imux->refcnt );
 err_alloc:
        return rc;
}

References imux::action, imux::bus, usb_hub::bus, DBGC, EINPROGRESS_PAIRING, ENOMEM, usb_port::hub, IMUX_IN_MAX_FILL, IMUX_IN_MTU, imux_in_operations, imux_out_operations, IMUX_PORT_LOCAL, imux_process_desc, imux_shutdown(), imux_tcp_desc, imux_tx_version(), usbnet_device::in, intf_init(), imux::list, list_add, list_del, NULL, imux::port, usb_device::port, imux::process, process_add(), process_init(), imux::rc, rc, ref_init, ref_put, imux::refcnt, strerror(), imux::tcp, imux::usb, usb_function::usb, usb_func_set_drvdata(), usb_refill_init(), imux::usbnet, usbnet_describe(), usbnet_init(), usbnet_open(), and zalloc().

imux_remove()

void imux_remove ( struct usb_function * func )

static

Remove device.

Parameters

func	USB function

Definition at line 1165 of file iphone.c.

                                                      {
        struct imux *imux = usb_func_get_drvdata ( func );
 
        list_del ( &imux->list );
        imux_shutdown ( imux );
        ref_put ( &imux->refcnt );
}

References imux_shutdown(), imux::list, list_del, ref_put, imux::refcnt, and usb_func_get_drvdata().

ipair_tx_pubkey()

int ipair_tx_pubkey ( struct ipair * ipair )

static

Transmit DevicePublicKey message.

Parameters

ipair

Pairing client

Return values

rc	Return status code

Definition at line 1408 of file iphone.c.

                                                   {
        int rc;
 
        /* Transmit message */
        if ( ( rc = ipair_tx ( ipair,
                               "%s"
                               "<string>GetValue</string>\n"
                               "<key>Key</key>\n"
                               "<string>DevicePublicKey</string>\n"
                               "%s",
                               ipair_prefix, ipair_suffix ) ) != 0 )
                return rc;
 
        return 0;
}

References ipair_prefix, ipair_suffix, ipair_tx(), and rc.

Referenced by ipair_create().

ipair_rx_pubkey()

int ipair_rx_pubkey ( struct ipair * ipair, char * msg )

static

Receive DevicePublicKey message.

Parameters

ipair	Pairing client
msg	XML message

Return values

rc	Return status code

Definition at line 1431 of file iphone.c.

                                                              {
        struct asn1_cursor *key;
        char *data;
        char *end;
        char *decoded;
        size_t max_len;
        int len;
        int next;
        int rc;
 
        /* Locate "Value" value */
        if ( ( rc = ipair_key ( ipair, msg, "Value", "data", &data,
                                &end ) ) != 0 ) {
                DBGC ( ipair, "IPAIR %p unexpected public key message:\n%s\n",
                       ipair, msg );
                goto err_tag;
        }
        *end = '\0';
 
        /* Decode outer layer of Base64 */
        max_len = base64_decoded_max_len ( data );
        decoded = malloc ( max_len );
        if ( ! decoded ) {
                rc = -ENOMEM;
                goto err_alloc;
        }
        len = base64_decode ( data, decoded, max_len );
        if ( len < 0 ) {
                rc = len;
                DBGC ( ipair, "IPAIR %p invalid outer public key:\n%s\n",
                       ipair, data );
                goto err_decode;
        }
 
        /* Decode inner layer of Base64 */
        next = pem_asn1 ( decoded, len, 0, &key );
        if ( next < 0 ) {
                rc = next;
                DBGC ( ipair, "IPAIR %p invalid inner public key:\n%s\n",
                       ipair, decoded );
                goto err_asn1;
        }
        DBGC ( ipair, "IPAIR %p received public key\n", ipair );
        DBGC2_HDA ( ipair, 0, key->data, key->len );
 
        /* Construct certificates */
        if ( ( rc = icert_certs ( &ipair->icert, key ) ) != 0 )
                goto err_certs;
 
        /* Send session request or pair request as applicable */
        if ( ipair->flags & IPAIR_REQUEST ) {
                ipair->tx = ipair_tx_pair;
                ipair->rx = ipair_rx_pair;
        } else {
                ipair->tx = ipair_tx_session;
                ipair->rx = ipair_rx_session;
        }
        start_timer_nodelay ( &ipair->timer );
 
        /* Free key */
        free ( key );
 
        /* Free intermediate Base64 */
        free ( decoded );
 
        return 0;
 
 err_certs:
        free ( key );
 err_asn1:
 err_decode:
        free ( decoded );
 err_alloc:
 err_tag:
        return rc;
}

References base64_decode(), base64_decoded_max_len(), data, DBGC, DBGC2_HDA, end, ENOMEM, ipair::flags, free, ipair::icert, icert_certs(), ipair_key(), IPAIR_REQUEST, ipair_rx_pair(), ipair_rx_session(), ipair_tx_pair(), ipair_tx_session(), key, len, malloc(), msg(), next, pem_asn1(), rc, ipair::rx, start_timer_nodelay(), ipair::timer, and ipair::tx.

Referenced by ipair_create().

ipair_tx_pair()

int ipair_tx_pair ( struct ipair * ipair )

static

Transmit Pair message.

Parameters

ipair

Pairing client

Return values

rc	Return status code

Definition at line 1514 of file iphone.c.

                                                 {
        char *root;
        char *host;
        char *device;
        int rc;
 
        /* Construct doubly encoded certificates */
        if ( ( rc = icert_encode ( &ipair->icert, ipair->icert.root,
                                   &root ) ) != 0 )
                goto err_root;
        if ( ( rc = icert_encode ( &ipair->icert, ipair->icert.host,
                                   &host ) ) != 0 )
                goto err_host;
        if ( ( rc = icert_encode ( &ipair->icert, ipair->icert.device,
                                   &device ) ) != 0 )
                goto err_device;
 
        /* Transmit message */
        if ( ( rc = ipair_tx ( ipair,
                               "%s"
                               "<string>Pair</string>\n"
                               "<key>PairRecord</key>\n"
                               "<dict>\n"
                               "<key>RootCertificate</key>\n"
                               "<data>%s</data>\n"
                               "<key>HostCertificate</key>\n"
                               "<data>%s</data>\n"
                               "<key>DeviceCertificate</key>\n"
                               "<data>%s</data>\n"
                               "<key>SystemBUID</key>\n"
                               "<string>%s</string>\n"
                               "<key>HostID</key>\n"
                               "<string>%s</string>\n"
                               "</dict>\n"
                               "<key>ProtocolVersion</key>\n"
                               "<string>2</string>\n"
                               "<key>PairingOptions</key>\n"
                               "<dict>\n"
                               "<key>ExtendedPairingErrors</key>\n"
                               "<true/>\n"
                               "</dict>\n"
                               "%s",
                               ipair_prefix, root, host, device,
                               ipair_system_buid, ipair_host_id,
                               ipair_suffix
                               ) ) != 0 )
                goto err_tx;
 
 err_tx:
        free ( device );
 err_device:
        free ( host );
 err_host:
        free ( root );
 err_root:
        return rc;
}

References icert::device, free, icert::host, ipair::icert, icert_encode(), ipair_host_id, ipair_prefix, ipair_suffix, ipair_system_buid, ipair_tx(), rc, icert::root, and root.

Referenced by ipair_rx_pair_error(), ipair_rx_pubkey(), and ipair_rx_session_error().

ipair_rx_pair()

int ipair_rx_pair ( struct ipair * ipair, char * msg )

static

Receive Pair message.

Parameters

ipair	Pairing client
msg	XML message

Return values

rc	Return status code

Definition at line 1603 of file iphone.c.

                                                            {
        char *error;
        char *escrow;
        char *end;
        int rc;
 
        /* Check for pairing errors */
        if ( ( rc = ipair_key ( ipair, msg, "Error", "string", &error,
                                &end ) ) == 0 ) {
                *end = '\0';
                return ipair_rx_pair_error ( ipair, error );
        }
 
        /* Get EscrowBag */
        if ( ( rc = ipair_key ( ipair, msg, "EscrowBag", "data", &escrow,
                                &end ) ) != 0 ) {
                DBGC ( ipair, "IPAIR %p unexpected pairing response:\n%s\n",
                       ipair, msg );
                return rc;
        }
        DBGC ( ipair, "IPAIR %p pairing successful\n", ipair );
 
        /* Send session request */
        ipair->tx = ipair_tx_session;
        ipair->rx = ipair_rx_session;
        start_timer_nodelay ( &ipair->timer );
 
        return 0;
}

References DBGC, end, error, ipair_key(), ipair_rx_pair_error(), ipair_rx_session(), ipair_tx_session(), msg(), rc, ipair::rx, start_timer_nodelay(), ipair::timer, and ipair::tx.

Referenced by ipair_rx_pair_error(), ipair_rx_pubkey(), and ipair_rx_session_error().

ipair_tx_session()

int ipair_tx_session ( struct ipair * ipair )

static

Transmit StartSession message.

Parameters

ipair

Pairing client

Return values

rc	Return status code

Definition at line 1639 of file iphone.c.

                                                    {
        int rc;
 
        /* Transmit message */
        if ( ( rc = ipair_tx ( ipair,
                               "%s"
                               "<string>StartSession</string>\n"
                               "<key>SystemBUID</key>\n"
                               "<string>%s</string>\n"
                               "<key>HostID</key>\n"
                               "<string>%s</string>\n"
                               "%s",
                               ipair_prefix, ipair_system_buid,
                               ipair_host_id, ipair_suffix
                               ) ) != 0 )
                return rc;
 
        return 0;
}

References ipair_host_id, ipair_prefix, ipair_suffix, ipair_system_buid, ipair_tx(), and rc.

Referenced by ipair_rx_pair(), and ipair_rx_pubkey().

ipair_rx_session()

int ipair_rx_session ( struct ipair * ipair, char * msg )

static

Receive StartSession message.

Parameters

ipair	Pairing client
msg	XML message

Return values

rc	Return status code

Definition at line 1690 of file iphone.c.

                                                               {
        char *error;
        char *session;
        char *end;
        int rc;
 
        /* Check for session errors */
        if ( ( rc = ipair_key ( ipair, msg, "Error", "string", &error,
                                &end ) ) == 0 ) {
                *end = '\0';
                return ipair_rx_session_error ( ipair, error );
        }
 
        /* Check for session ID */
        if ( ( rc = ipair_key ( ipair, msg, "SessionID", "string", &session,
                                &end ) ) != 0 ) {
                DBGC ( ipair, "IPAIR %p unexpected session response:\n%s\n",
                       ipair, msg );
                return rc;
        }
        *end = '\0';
        DBGC ( ipair, "IPAIR %p starting session \"%s\"\n", ipair, session );
 
        /* Start TLS */
        if ( ( rc = add_tls ( &ipair->xfer, "iPhone", &icert_root,
                              ipair->icert.key ) ) != 0 ) {
                DBGC ( ipair, "IPAIR %p could not start TLS: %s\n",
                       ipair, strerror ( rc ) );
                return rc;
        }
 
        /* Record that TLS has been started */
        ipair->flags |= IPAIR_TLS;
 
        return 0;
}

References add_tls(), DBGC, end, error, ipair::flags, ipair::icert, icert_root, ipair_key(), ipair_rx_session_error(), IPAIR_TLS, icert::key, msg(), rc, strerror(), and ipair::xfer.

Referenced by ipair_rx_pair(), and ipair_rx_pubkey().

ipair_free()

void ipair_free ( struct refcnt * refcnt )

static

Free pairing client.

Parameters

refcnt

Reference counter

Definition at line 1229 of file iphone.c.

                                                 {
        struct ipair *ipair = container_of ( refcnt, struct ipair, refcnt );
 
        icert_free ( &ipair->icert );
        free ( ipair );
}

References container_of, free, ipair::icert, and icert_free().

Referenced by ipair_create().

ipair_close()

void ipair_close ( struct ipair * ipair, int rc )

static

Shut down pairing client.

Parameters

ipair	Pairing client
rc	Reason for close

Definition at line 1242 of file iphone.c.

                                                        {
 
        /* Shut down interfaces */
        intf_shutdown ( &ipair->xfer, rc );
 
        /* Stop timer */
        stop_timer ( &ipair->timer );
}

References intf_shutdown(), rc, stop_timer(), ipair::timer, and ipair::xfer.

Referenced by ipair_deliver(), ipair_expired(), and ipair_window_changed().

ipair_tx()

int ipair_tx ( struct ipair * ipair, const char * fmt, ... )

static

Transmit XML message.

Parameters

ipair	Pairing client
fmt	Format string
...	Arguments

Return values

rc	Return status code

Definition at line 1260 of file iphone.c.

                                                       {
        struct io_buffer *iobuf;
        struct ipair_header *hdr;
        va_list args;
        size_t len;
        char *msg;
        int rc;
 
        /* Calculate length of formatted string */
        va_start ( args, fmt );
        len = ( vsnprintf ( NULL, 0, fmt, args ) + 1 /* NUL */ );
        va_end ( args );
 
        /* Allocate I/O buffer */
        iobuf = xfer_alloc_iob ( &ipair->xfer, ( sizeof ( *hdr ) + len ) );
        if ( ! iobuf )
                return -ENOMEM;
        hdr = iob_put ( iobuf, sizeof ( *hdr ) );
 
        /* Construct XML message */
        memset ( hdr, 0, sizeof ( *hdr ) );
        hdr->len = htonl ( len );
        msg = iob_put ( iobuf, len );
        va_start ( args, fmt );
        vsnprintf ( msg, len, fmt, args );
        va_end ( args );
        DBGC2 ( ipair, "IPAIR %p transmitting:\n%s\n", ipair, msg );
 
        /* Transmit message */
        if ( ( rc = xfer_deliver_iob ( &ipair->xfer,
                                       iob_disown ( iobuf ) ) ) != 0 )
                return rc;
 
        return 0;
}

References DBGC2, ENOMEM, fmt, hdr, htonl, iob_disown, iob_put, ipair_tx(), len, memset(), msg(), NULL, rc, va_end, va_start, vsnprintf(), ipair::xfer, xfer_alloc_iob(), and xfer_deliver_iob().

Referenced by ipair_tx(), ipair_tx_pair(), ipair_tx_pubkey(), and ipair_tx_session().

ipair_rx()

int ipair_rx ( struct ipair * ipair, char * msg, size_t len )

static

Receive XML message payload.

Parameters

ipair	Pairing client
msg	Message payload
len	Length of message

Return values

rc	Return status code

Definition at line 1304 of file iphone.c.

                                                                   {
        int ( * rx ) ( struct ipair *ipair, char *msg );
        int rc;
 
        /* Ignore empty messages */
        if ( ! len )
                return 0;
 
        /* Sanity check */
        if ( ( msg[ len - 1 ] != '\0' ) && ( msg[ len - 1 ] != '\n' ) ) {
                DBGC ( ipair, "IPAIR %p malformed XML:\n", ipair );
                DBGC_HDA ( ipair, 0, msg, len );
                return -EPROTO;
        }
 
        /* Add NUL terminator (potentially overwriting final newline) */
        msg[ len - 1 ] = '\0';
        DBGC2 ( ipair, "IPAIR %p received:\n%s\n\n", ipair, msg );
 
        /* Handle according to current state */
        rx = ipair->rx;
        if ( ! rx ) {
                DBGC ( ipair, "IPAIR %p unexpected XML:\n%s\n", ipair, msg );
                return -EPROTO;
        }
        ipair->rx = NULL;
        if ( ( rc = rx ( ipair, msg ) ) != 0 )
                return rc;
 
        return 0;
}

References DBGC, DBGC2, DBGC_HDA, EPROTO, len, msg(), NULL, rc, ipair::rx, and rx.

Referenced by ipair_deliver().

ipair_tag()

int ipair_tag ( struct ipair * ipair, const char * msg, const char * tag, char ** start, char ** end )

static

Locate XML tag.

Parameters

ipair	Pairing client
msg	XML message
tag	Tag name

Return values

start	Start of tag content
end	End of tag content
rc	Return status code

Definition at line 1346 of file iphone.c.

                                                  {
        char buf[ 2 /* "</" */ + strlen ( tag ) + 1 /* ">" */ + 1 /* NUL */ ];
 
        /* Locate opening tag */
        sprintf ( buf, "<%s>", tag );
        *start = strstr ( msg, buf );
        if ( ! *start )
                return -ENOENT;
        *start += strlen ( buf );
 
        /* Locate closing tag */
        sprintf ( buf, "</%s>", tag );
        *end = strstr ( *start, buf );
        if ( ! *end ) {
                DBGC ( ipair, "IPAIR %p missing closing tag %s in:\n%s\n",
                       ipair, buf, msg );
                return -ENOENT;
        }
 
        return 0;
}

References DBGC, end, ENOENT, msg(), sprintf, start, strlen(), strstr(), and tag.

Referenced by ipair_key().

ipair_key()

int ipair_key ( struct ipair * ipair, const char * msg, const char * key, const char * type, char ** start, char ** end )

static

Locate XML property list dictionary value.

Parameters

ipair	Pairing client
msg	XML message
key	Key name
type	Key type

Return values

start	Start of value content
end	End of value content
rc	Return status code

Definition at line 1380 of file iphone.c.

                                                                    {
        int rc;
 
        /* Iterate over keys */
        while ( 1 ) {
 
                /* Locate key */
                if ( ( rc = ipair_tag ( ipair, msg, "key", start,
                                        end ) ) != 0 )
                        return rc;
                msg = *end;
 
                /* Check key name */
                if ( memcmp ( *start, key, ( *end - *start ) ) != 0 )
                        continue;
 
                /* Locate value */
                return ipair_tag ( ipair, msg, type, start, end );
        }
}

References end, ipair_tag(), key, memcmp(), msg(), rc, start, and type.

Referenced by ipair_rx_pair(), ipair_rx_pubkey(), and ipair_rx_session().

ipair_rx_pair_error()

int ipair_rx_pair_error ( struct ipair * ipair, char * error )

static

Receive Pair message error.

Parameters

ipair	Pairing client
error	Pairing error

Return values

rc	Return status code

Definition at line 1579 of file iphone.c.

                                                                    {
 
        /* Check for actual errors */
        if ( strcmp ( error, "PairingDialogResponsePending" ) != 0 ) {
                DBGC ( ipair, "IPAIR %p pairing error \"%s\"\n", ipair, error );
                return -EPERM;
        }
 
        /* Retransmit pairing request */
        ipair->tx = ipair_tx_pair;
        ipair->rx = ipair_rx_pair;
        start_timer_fixed ( &ipair->timer, IPAIR_RETRY_DELAY );
 
        DBGC ( ipair, "IPAIR %p waiting for pairing dialog\n", ipair );
        return 0;
}

References DBGC, EPERM, error, IPAIR_RETRY_DELAY, ipair_rx_pair(), ipair_tx_pair(), ipair::rx, start_timer_fixed(), strcmp(), ipair::timer, and ipair::tx.

Referenced by ipair_rx_pair().

ipair_rx_session_error()

int ipair_rx_session_error ( struct ipair * ipair, char * error )

static

Receive StartSession message error.

Parameters

ipair	Pairing client
error	Pairing error

Return values

rc	Return status code

Definition at line 1666 of file iphone.c.

                                                                       {
 
        /* Check for actual errors */
        if ( strcmp ( error, "InvalidHostID" ) != 0 ) {
                DBGC ( ipair, "IPAIR %p session error \"%s\"\n", ipair, error );
                return -EPERM;
        }
 
        /* Transmit pairing request */
        ipair->tx = ipair_tx_pair;
        ipair->rx = ipair_rx_pair;
        start_timer_nodelay ( &ipair->timer );
 
        DBGC ( ipair, "IPAIR %p unknown host: requesting pairing\n", ipair );
        return 0;
}

References DBGC, EPERM, error, ipair_rx_pair(), ipair_tx_pair(), ipair::rx, start_timer_nodelay(), strcmp(), ipair::timer, and ipair::tx.

Referenced by ipair_rx_session().

ipair_window_changed()

void ipair_window_changed ( struct ipair * ipair )

static

Handle window change notification.

Parameters

ipair

Pairing client

Definition at line 1732 of file iphone.c.

                                                         {
 
        /* Report pairing as complete once TLS session has been established */
        if ( ( ipair->flags & IPAIR_TLS ) && xfer_window ( &ipair->xfer ) ) {
 
                /* Sanity checks */
                assert ( x509_is_valid ( ipair->icert.root, &icert_root ) );
                assert ( x509_is_valid ( ipair->icert.device, &icert_root ) );
                assert ( ! x509_is_valid ( ipair->icert.root, NULL ) );
                assert ( ! x509_is_valid ( ipair->icert.host, NULL ) );
                assert ( ! x509_is_valid ( ipair->icert.device, NULL ) );
 
                /* Report pairing as complete */
                DBGC ( ipair, "IPAIR %p established TLS session\n", ipair );
                ipair_close ( ipair, 0 );
                return;
        }
}

References assert, DBGC, icert::device, ipair::flags, icert::host, ipair::icert, icert_root, ipair_close(), IPAIR_TLS, NULL, icert::root, x509_is_valid(), ipair::xfer, and xfer_window().

ipair_deliver()

int ipair_deliver ( struct ipair * ipair, struct io_buffer * iobuf, struct xfer_metadata *meta __unused )

static

Handle received data.

Parameters

ipair	Pairing client
iobuf	I/O buffer
meta	Data transfer metadata

Return values

rc	Return status code

Definition at line 1759 of file iphone.c.

                                                                 {
        struct ipair_header *hdr;
        int rc;
 
        /* Strip header (which may appear in a separate packet) */
        if ( ( ! ( ipair->flags & IPAIR_RX_LEN ) ) &&
             ( iob_len ( iobuf ) >= sizeof ( *hdr ) ) ) {
                iob_pull ( iobuf, sizeof ( *hdr ) );
                ipair->flags |= IPAIR_RX_LEN;
        }
 
        /* Clear received header flag if we have a message */
        if ( iob_len ( iobuf ) )
                ipair->flags &= ~IPAIR_RX_LEN;
 
        /* Receive message */
        if ( ( rc = ipair_rx ( ipair, iobuf->data, iob_len ( iobuf ) ) ) != 0 )
                goto error;
 
        /* Free I/O buffer */
        free_iob ( iobuf );
 
        return 0;
 
 error:
        ipair_close ( ipair, rc );
        free_iob ( iobuf );
        return rc;
}

References __unused, io_buffer::data, error, ipair::flags, free_iob(), hdr, iob_len(), iob_pull, ipair_close(), ipair_rx(), IPAIR_RX_LEN, meta, and rc.

ipair_expired()

void ipair_expired ( struct retry_timer * timer, int over __unused )

static

Pairing transmission timer.

Parameters

timer	Retransmission timer
over	Failure indicator

Definition at line 1796 of file iphone.c.

                                                                           {
        struct ipair *ipair = container_of ( timer, struct ipair, timer );
        int ( * tx ) ( struct ipair *ipair );
        int rc;
 
        /* Sanity check */
        tx = ipair->tx;
        assert ( tx != NULL );
 
        /* Clear pending transmission */
        ipair->tx = NULL;
 
        /* Transmit data, if applicable */
        if ( ( rc = tx ( ipair ) ) != 0 )
                ipair_close ( ipair, rc );
}

References __unused, assert, container_of, ipair_close(), NULL, rc, ipair::tx, and tx.

Referenced by ipair_create().

iphone_in_complete()

void iphone_in_complete ( struct usb_endpoint * ep, struct io_buffer * iobuf, int rc )

static

Complete bulk IN transfer.

Parameters

ep	USB endpoint
iobuf	I/O buffer
rc	Completion status code

Definition at line 1875 of file iphone.c.

                                                                   {
        struct iphone *iphone = container_of ( ep, struct iphone, usbnet.in );
        struct net_device *netdev = iphone->netdev;
 
        /* Profile receive completions */
        profile_start ( &iphone_in_profiler );
 
        /* Ignore packets cancelled when the endpoint closes */
        if ( ! ep->open )
                goto ignore;
 
        /* Record USB errors against the network device */
        if ( rc != 0 ) {
                DBGC ( iphone, "IPHONE %p bulk IN failed: %s\n",
                       iphone, strerror ( rc ) );
                goto error;
        }
 
        /* Strip padding */
        if ( iob_len ( iobuf ) < IPHONE_IN_PAD ) {
                DBGC ( iphone, "IPHONE %p malformed bulk IN:\n", iphone );
                DBGC_HDA ( iphone, 0, iobuf->data, iob_len ( iobuf ) );
                rc = -EINVAL;
                goto error;
        }
        iob_pull ( iobuf, IPHONE_IN_PAD );
 
        /* Hand off to network stack */
        netdev_rx ( netdev, iob_disown ( iobuf ) );
 
        profile_stop ( &iphone_in_profiler );
        return;
 
 error:
        netdev_rx_err ( netdev, iob_disown ( iobuf ), rc );
 ignore:
        free_iob ( iobuf );
}

References container_of, io_buffer::data, DBGC, DBGC_HDA, EINVAL, error, free_iob(), usbnet_device::in, iob_disown, iob_len(), iob_pull, IPHONE_IN_PAD, iphone::netdev, netdev, netdev_rx(), netdev_rx_err(), usb_endpoint::open, profile_start(), profile_stop(), rc, strerror(), and iphone::usbnet.

iphone_out_transmit()

int iphone_out_transmit ( struct iphone * iphone, struct io_buffer * iobuf )

static

Transmit packet.

Parameters

iphone	iPhone device
iobuf	I/O buffer

Return values

rc	Return status code

Definition at line 1927 of file iphone.c.

                                                           {
        int rc;
 
        /* Profile transmissions */
        profile_start ( &iphone_out_profiler );
 
        /* Enqueue I/O buffer */
        if ( ( rc = usb_stream ( &iphone->usbnet.out, iobuf, 1 ) ) != 0 )
                return rc;
 
        profile_stop ( &iphone_out_profiler );
        return 0;
}

References usbnet_device::out, profile_start(), profile_stop(), rc, usb_stream(), and iphone::usbnet.

Referenced by iphone_transmit().

iphone_out_complete()

void iphone_out_complete ( struct usb_endpoint * ep, struct io_buffer * iobuf, int rc )

static

Complete bulk OUT transfer.

Parameters

ep	USB endpoint
iobuf	I/O buffer
rc	Completion status code

Definition at line 1949 of file iphone.c.

                                                                    {
        struct iphone *iphone = container_of ( ep, struct iphone, usbnet.out );
        struct net_device *netdev = iphone->netdev;
 
        /* Report TX completion */
        netdev_tx_complete_err ( netdev, iobuf, rc );
}

References container_of, iphone::netdev, netdev, netdev_tx_complete_err(), usbnet_device::out, rc, and iphone::usbnet.

iphone_check_pair()

int iphone_check_pair ( struct iphone * iphone )

static

Check pairing status.

Parameters

iphone

iPhone device

Return values

rc	Return status code

Definition at line 1969 of file iphone.c.

                                                       {
        struct imux *imux;
 
        /* Find corresponding USB multiplexer */
        list_for_each_entry ( imux, &imuxes, list ) {
                if ( imux->usb == iphone->usb )
                        return imux->rc;
        }
 
        return -EPIPE_NO_MUX;
}

References EPIPE_NO_MUX, imux::list, list_for_each_entry, imux::rc, imux::usb, and iphone::usb.

Referenced by iphone_check_link().

iphone_check_link()

void iphone_check_link ( struct net_device * netdev )

static

Check link status.

Parameters

netdev

Network device

Definition at line 1986 of file iphone.c.

                                                            {
        struct iphone *iphone = netdev->priv;
        struct usb_device *usb = iphone->usb;
        uint8_t status;
        int rc;
 
        /* Check pairing status */
        if ( ( rc = iphone_check_pair ( iphone ) ) != 0 )
                goto err_pair;
 
        /* Get link status */
        if ( ( rc = usb_control ( usb, IPHONE_GET_LINK, 0, 0, &status,
                                  sizeof ( status ) ) ) != 0 ) {
                DBGC ( iphone, "IPHONE %p could not get link status: %s\n",
                       iphone, strerror ( rc ) );
                goto err_control;
        }
 
        /* Check link status */
        if ( status != IPHONE_LINK_UP ) {
                rc = -ENOTCONN_STATUS ( status );
                goto err_status;
        }
 
        /* Success */
        rc = 0;
 
 err_status:
 err_control:
 err_pair:
        /* Report link status.  Since we have to check the link
         * periodically (due to an absence of an interrupt endpoint),
         * do this only if the link status has actually changed.
         */
        if ( rc != netdev->link_rc ) {
                if ( rc == 0 ) {
                        DBGC ( iphone, "IPHONE %p link up\n", iphone );
                } else {
                        DBGC ( iphone, "IPHONE %p link down: %s\n",
                               iphone, strerror ( rc ) );
                }
                netdev_link_err ( netdev, rc );
        }
}

References DBGC, ENOTCONN_STATUS, iphone_check_pair(), IPHONE_GET_LINK, IPHONE_LINK_UP, netdev, netdev_link_err(), rc, status, strerror(), iphone::usb, and usb_control().

Referenced by iphone_expired(), and iphone_probe().

iphone_expired()

void iphone_expired ( struct retry_timer * timer, int over __unused )

static

Periodically update link status.

Parameters

timer	Link status timer
over	Failure indicator

Definition at line 2037 of file iphone.c.

                                                                            {
        struct iphone *iphone = container_of ( timer, struct iphone, timer );
        struct net_device *netdev = iphone->netdev;
 
        /* Check link status */
        iphone_check_link ( netdev );
 
        /* Restart timer, if device is open */
        if ( netdev_is_open ( netdev ) )
                start_timer_fixed ( timer, IPHONE_LINK_CHECK_INTERVAL );
}

References __unused, container_of, iphone_check_link(), IPHONE_LINK_CHECK_INTERVAL, iphone::netdev, netdev, netdev_is_open(), and start_timer_fixed().

Referenced by iphone_probe().

iphone_open()

int iphone_open ( struct net_device * netdev )

static

Open network device.

Parameters

netdev

Network device

Return values

rc	Return status code

Definition at line 2055 of file iphone.c.

                                                     {
        struct iphone *iphone = netdev->priv;
        int rc;
 
        /* Open USB network device */
        if ( ( rc = usbnet_open ( &iphone->usbnet ) ) != 0 ) {
                DBGC ( iphone, "IPHONE %p could not open: %s\n",
                       iphone, strerror ( rc ) );
                goto err_open;
        }
 
        /* Start the link status check timer */
        start_timer_nodelay ( &iphone->timer );
 
        return 0;
 
        usbnet_close ( &iphone->usbnet );
 err_open:
        return rc;
}

References DBGC, netdev, rc, start_timer_nodelay(), strerror(), iphone::timer, iphone::usbnet, usbnet_close(), and usbnet_open().

iphone_close()

void iphone_close ( struct net_device * netdev )

static

Close network device.

Parameters

netdev

Network device

Definition at line 2081 of file iphone.c.

                                                       {
        struct iphone *iphone = netdev->priv;
 
        /* Stop the link status check timer */
        stop_timer ( &iphone->timer );
 
        /* Close USB network device */
        usbnet_close ( &iphone->usbnet );
}

References netdev, stop_timer(), iphone::timer, iphone::usbnet, and usbnet_close().

iphone_transmit()

int iphone_transmit ( struct net_device * netdev, struct io_buffer * iobuf )

static

Transmit packet.

Parameters

netdev	Network device
iobuf	I/O buffer

Return values

rc	Return status code

Definition at line 2098 of file iphone.c.

                                                       {
        struct iphone *iphone = netdev->priv;
        int rc;
 
        /* Transmit packet */
        if ( ( rc = iphone_out_transmit ( iphone, iobuf ) ) != 0 )
                return rc;
 
        return 0;
}

References iphone_out_transmit(), netdev, and rc.

iphone_poll()

void iphone_poll ( struct net_device * netdev )

static

Poll for completed and received packets.

Parameters

netdev

Network device

Definition at line 2115 of file iphone.c.

                                                      {
        struct iphone *iphone = netdev->priv;
        int rc;
 
        /* Poll USB bus */
        usb_poll ( iphone->bus );
 
        /* Refill endpoints */
        if ( ( rc = usbnet_refill ( &iphone->usbnet ) ) != 0 )
                netdev_rx_err ( netdev, NULL, rc );
}

References iphone::bus, netdev, netdev_rx_err(), NULL, rc, usb_poll(), iphone::usbnet, and usbnet_refill().

iphone_probe()

int iphone_probe ( struct usb_function * func, struct usb_configuration_descriptor * config )

static

Probe device.

Parameters

func	USB function
config	Configuration descriptor

Return values

rc	Return status code

Definition at line 2142 of file iphone.c.

                                                                        {
        struct usb_device *usb = func->usb;
        struct net_device *netdev;
        struct iphone *iphone;
        int rc;
 
        /* Allocate and initialise structure */
        netdev = alloc_etherdev ( sizeof ( *iphone ) );
        if ( ! netdev ) {
                rc = -ENOMEM;
                goto err_alloc;
        }
        netdev_init ( netdev, &iphone_operations );
        netdev->dev = &func->dev;
        iphone = netdev->priv;
        memset ( iphone, 0, sizeof ( *iphone ) );
        iphone->usb = usb;
        iphone->bus = usb->port->hub->bus;
        iphone->netdev = netdev;
        usbnet_init ( &iphone->usbnet, func, NULL, &iphone_in_operations,
                      &iphone_out_operations );
        usb_refill_init ( &iphone->usbnet.in, 0, IPHONE_IN_MTU,
                          IPHONE_IN_MAX_FILL );
        timer_init ( &iphone->timer, iphone_expired, &netdev->refcnt );
        DBGC ( iphone, "IPHONE %p on %s\n", iphone, func->name );
 
        /* Describe USB network device */
        if ( ( rc = usbnet_describe ( &iphone->usbnet, config ) ) != 0 ) {
                DBGC ( iphone, "IPHONE %p could not describe: %s\n",
                       iphone, strerror ( rc ) );
                goto err_describe;
        }
 
        /* Fetch MAC address */
        if ( ( rc = usb_control ( usb, IPHONE_GET_MAC, 0, 0, netdev->hw_addr,
                                  ETH_ALEN ) ) != 0 ) {
                DBGC ( iphone, "IPHONE %p could not fetch MAC address: %s\n",
                       iphone, strerror ( rc ) );
                goto err_fetch_mac;
        }
 
        /* Register network device */
        if ( ( rc = register_netdev ( netdev ) ) != 0 )
                goto err_register;
 
        /* Set initial link status */
        iphone_check_link ( netdev );
 
        /* Add to list of iPhone network devices */
        list_add ( &iphone->list, &iphones );
 
        usb_func_set_drvdata ( func, iphone );
        return 0;
 
        list_del ( &iphone->list );
        unregister_netdev ( netdev );
 err_register:
 err_fetch_mac:
 err_describe:
        netdev_nullify ( netdev );
        netdev_put ( netdev );
 err_alloc:
        return rc;
}

References alloc_etherdev(), iphone::bus, usb_hub::bus, DBGC, usb_function::dev, ENOMEM, ETH_ALEN, usb_port::hub, usbnet_device::in, iphone_check_link(), iphone_expired(), IPHONE_GET_MAC, IPHONE_IN_MAX_FILL, IPHONE_IN_MTU, iphone_in_operations, iphone_operations, iphone_out_operations, iphone::list, list_add, list_del, memset(), usb_function::name, iphone::netdev, netdev, netdev_init(), netdev_nullify(), netdev_put(), NULL, usb_device::port, rc, register_netdev(), strerror(), iphone::timer, unregister_netdev(), iphone::usb, usb_function::usb, usb_control(), usb_func_set_drvdata(), usb_refill_init(), iphone::usbnet, usbnet_describe(), and usbnet_init().

iphone_remove()

void iphone_remove ( struct usb_function * func )

static

Remove device.

Parameters

func	USB function

Definition at line 2213 of file iphone.c.

                                                        {
        struct iphone *iphone = usb_func_get_drvdata ( func );
        struct net_device *netdev = iphone->netdev;
 
        list_del ( &iphone->list );
        unregister_netdev ( netdev );
        netdev_nullify ( netdev );
        netdev_put ( netdev );
}

References iphone::list, list_del, iphone::netdev, netdev, netdev_nullify(), netdev_put(), unregister_netdev(), and usb_func_get_drvdata().

REQUIRING_SYMBOL()

REQUIRING_SYMBOL

(

iphone_driver

)

REQUIRE_OBJECT()

REQUIRE_OBJECT

(

rsa_sha256

)

Variable Documentation

__profiler

struct profiler iphone_out_profiler __profiler

static

Initial value:

=
        { .name = "iphone.in" }

Bulk IN completion profiler.

Bulk OUT profiler.

Definition at line 71 of file iphone.c.

        { .name = "iphone.in" };

icert_root_fingerprint

uint8_t icert_root_fingerprint[SHA256_DIGEST_SIZE]

static

iPhone root certificate fingerprint

Definition at line 92 of file iphone.c.

Referenced by icert_certs().

icert_root

struct x509_root icert_root

static

Initial value:

= {
        .refcnt = REF_INIT ( ref_no_free ),
        .digest = &sha256_algorithm,
        .count = 1,
        .fingerprints = icert_root_fingerprint,
}

Root of trust for iPhone certificates.

Definition at line 95 of file iphone.c.

                                     {
        .refcnt = REF_INIT ( ref_no_free ),
        .digest = &sha256_algorithm,
        .count = 1,
        .fingerprints = icert_root_fingerprint,
};

Referenced by icert_certs(), ipair_rx_session(), and ipair_window_changed().

icert_nul

const uint8_t icert_nul[] = { 0x00 }

static

Single zero byte used in constructed certificates.

Definition at line 103 of file iphone.c.

{ 0x00 };

Referenced by icert_cert(), and icert_certs().

icert_rsa

const uint8_t icert_rsa[]

static

Initial value:

= {
        
        ASN1_SHORT ( ASN1_SEQUENCE,
                     ASN1_SHORT ( ASN1_OID, ASN1_OID_RSAENCRYPTION ),
                     ASN1_NULL, 0x00 )
}

"RSA algorithm" identifier used in constructed certificates

Definition at line 106 of file iphone.c.

                                   {
        /* algorithm */
        ASN1_SHORT ( ASN1_SEQUENCE,
                     ASN1_SHORT ( ASN1_OID, ASN1_OID_RSAENCRYPTION ),
                     ASN1_NULL, 0x00 )
};

Referenced by icert_cert().

icert_sha256_rsa

const uint8_t icert_sha256_rsa[]

static

Initial value:

= {
        ASN1_SHORT ( ASN1_SEQUENCE,
                     ASN1_SHORT ( ASN1_OID, ASN1_OID_SHA256WITHRSAENCRYPTION ),
                     ASN1_NULL, 0x00 ),
}

"SHA-256 with RSA algorithm" identifier used in constructed certificates

Definition at line 114 of file iphone.c.

                                          {
        ASN1_SHORT ( ASN1_SEQUENCE,
                     ASN1_SHORT ( ASN1_OID, ASN1_OID_SHA256WITHRSAENCRYPTION ),
                     ASN1_NULL, 0x00 ),
};

Referenced by icert_cert().

icert_root_exts_data

const uint8_t icert_root_exts_data[]

static

Initial value:

= {
        
        ASN1_SHORT ( ASN1_EXPLICIT_TAG ( 3 ), ASN1_SHORT ( ASN1_SEQUENCE,
        
        ASN1_SHORT ( ASN1_SEQUENCE,
                     
                     ASN1_SHORT ( ASN1_OID, ASN1_OID_BASICCONSTRAINTS ),
                     
                     ASN1_SHORT ( ASN1_BOOLEAN, 0xff ),
                     
                     ASN1_SHORT ( ASN1_OCTET_STRING,
                                  ASN1_SHORT ( ASN1_SEQUENCE,
                                               ASN1_SHORT ( ASN1_BOOLEAN,
                                                            0xff ) ) ) ) ) )
}

Extensions used in constructed root certificate.

Definition at line 121 of file iphone.c.

                                              {
        /* extensions */
        ASN1_SHORT ( ASN1_EXPLICIT_TAG ( 3 ), ASN1_SHORT ( ASN1_SEQUENCE,
        /* basicConstraints */
        ASN1_SHORT ( ASN1_SEQUENCE,
                     /* extnID */
                     ASN1_SHORT ( ASN1_OID, ASN1_OID_BASICCONSTRAINTS ),
                     /* critical */
                     ASN1_SHORT ( ASN1_BOOLEAN, 0xff ),
                     /* extnValue */
                     ASN1_SHORT ( ASN1_OCTET_STRING,
                                  ASN1_SHORT ( ASN1_SEQUENCE,
                                               ASN1_SHORT ( ASN1_BOOLEAN,
                                                            0xff ) ) ) ) ) )
};

icert_root_exts

struct asn1_cursor icert_root_exts

static

Initial value:

=
        ASN1_CURSOR ( icert_root_exts_data )

Extensions used in constructed root certificate.

Definition at line 138 of file iphone.c.

Referenced by icert_certs().

icert_leaf_exts_data

const uint8_t icert_leaf_exts_data[]

static

Initial value:

= {
        
        ASN1_SHORT ( ASN1_EXPLICIT_TAG ( 3 ), ASN1_SHORT ( ASN1_SEQUENCE,
        
        ASN1_SHORT ( ASN1_SEQUENCE,
                     
                     ASN1_SHORT ( ASN1_OID, ASN1_OID_BASICCONSTRAINTS ),
                     
                     ASN1_SHORT ( ASN1_BOOLEAN, 0xff ),
                     
                     ASN1_SHORT ( ASN1_OCTET_STRING,
                                  ASN1_SHORT ( ASN1_SEQUENCE,
                                               ASN1_SHORT ( ASN1_BOOLEAN,
                                                            0x00 ) ) ) ),
        
        ASN1_SHORT ( ASN1_SEQUENCE,
                     
                     ASN1_SHORT ( ASN1_OID, ASN1_OID_KEYUSAGE ),
                     
                     ASN1_SHORT ( ASN1_BOOLEAN, 0xff ),
                     
                     ASN1_SHORT ( ASN1_OCTET_STRING,
                                  ASN1_SHORT ( ASN1_BIT_STRING, 0x07,
                                               ( X509_DIGITAL_SIGNATURE |
                                                 X509_KEY_ENCIPHERMENT ),
                                               0x00 ) ) ) ) )
}

Extensions used in constructed leaf certificates.

Definition at line 142 of file iphone.c.

                                              {
        /* extensions */
        ASN1_SHORT ( ASN1_EXPLICIT_TAG ( 3 ), ASN1_SHORT ( ASN1_SEQUENCE,
        /* basicConstraints */
        ASN1_SHORT ( ASN1_SEQUENCE,
                     /* extnID */
                     ASN1_SHORT ( ASN1_OID, ASN1_OID_BASICCONSTRAINTS ),
                     /* critical */
                     ASN1_SHORT ( ASN1_BOOLEAN, 0xff ),
                     /* extnValue */
                     ASN1_SHORT ( ASN1_OCTET_STRING,
                                  ASN1_SHORT ( ASN1_SEQUENCE,
                                               ASN1_SHORT ( ASN1_BOOLEAN,
                                                            0x00 ) ) ) ),
        /* keyUsage */
        ASN1_SHORT ( ASN1_SEQUENCE,
                     /* extnID */
                     ASN1_SHORT ( ASN1_OID, ASN1_OID_KEYUSAGE ),
                     /* critical */
                     ASN1_SHORT ( ASN1_BOOLEAN, 0xff ),
                     /* extnValue */
                     ASN1_SHORT ( ASN1_OCTET_STRING,
                                  ASN1_SHORT ( ASN1_BIT_STRING, 0x07,
                                               ( X509_DIGITAL_SIGNATURE |
                                                 X509_KEY_ENCIPHERMENT ),
                                               0x00 ) ) ) ) )
};

icert_leaf_exts

struct asn1_cursor icert_leaf_exts

static

Initial value:

=
        ASN1_CURSOR ( icert_leaf_exts_data )

Extensions used in constructed leaf certificates.

Definition at line 171 of file iphone.c.

Referenced by icert_certs().

icert_tbs_prefix

const uint8_t icert_tbs_prefix[]

static

Initial value:

= {
        
        ASN1_SHORT ( ASN1_EXPLICIT_TAG ( 0 ), ASN1_SHORT ( ASN1_INTEGER, 2 ) ),
        
        ASN1_SHORT ( ASN1_INTEGER, 0 ),
        
        ASN1_SHORT ( ASN1_SEQUENCE,
                     ASN1_SHORT ( ASN1_OID, ASN1_OID_SHA256WITHRSAENCRYPTION ),
                     ASN1_NULL, 0x00 )
}

"TBSCertificate" prefix in constructed certificates

Definition at line 175 of file iphone.c.

                                          {
        /* version */
        ASN1_SHORT ( ASN1_EXPLICIT_TAG ( 0 ), ASN1_SHORT ( ASN1_INTEGER, 2 ) ),
        /* serialNumber */
        ASN1_SHORT ( ASN1_INTEGER, 0 ),
        /* signature */
        ASN1_SHORT ( ASN1_SEQUENCE,
                     ASN1_SHORT ( ASN1_OID, ASN1_OID_SHA256WITHRSAENCRYPTION ),
                     ASN1_NULL, 0x00 )
};

Referenced by icert_cert().

icert_validity

const uint8_t icert_validity[]

static

Initial value:

= {
        
        ASN1_SHORT ( ASN1_SEQUENCE,
                     
                     ASN1_SHORT ( ASN1_GENERALIZED_TIME,
                                  '1', '9', '7', '8', '1', '2', '1', '0',
                                  '2', '2', '0', '0', '0', '0', 'Z' ),
                     
                     ASN1_SHORT ( ASN1_GENERALIZED_TIME,
                                  '2', '9', '9', '9', '0', '1', '0', '1',
                                  '0', '0', '0', '0', '0', '0', 'Z' ) )
}

Validity period in constructed certificates.

Definition at line 187 of file iphone.c.

                                        {
        /* validity */
        ASN1_SHORT ( ASN1_SEQUENCE,
                     /* notBefore */
                     ASN1_SHORT ( ASN1_GENERALIZED_TIME,
                                  '1', '9', '7', '8', '1', '2', '1', '0',
                                  '2', '2', '0', '0', '0', '0', 'Z' ),
                     /* notAfter */
                     ASN1_SHORT ( ASN1_GENERALIZED_TIME,
                                  '2', '9', '9', '9', '0', '1', '0', '1',
                                  '0', '0', '0', '0', '0', '0', 'Z' ) )
};

Referenced by icert_cert().

icert_name_root_data

const uint8_t icert_name_root_data[]

static

Initial value:

= {
        ASN1_SHORT ( ASN1_SEQUENCE, ASN1_SHORT ( ASN1_SET,
        ASN1_SHORT ( ASN1_SEQUENCE,
                     ASN1_SHORT ( ASN1_OID, ASN1_OID_COMMON_NAME ),
                     ASN1_SHORT ( ASN1_UTF8_STRING, 'R', 'o', 'o', 't' ) ) ) )
}

"Root" subject name

Definition at line 201 of file iphone.c.

                                              {
        ASN1_SHORT ( ASN1_SEQUENCE, ASN1_SHORT ( ASN1_SET,
        ASN1_SHORT ( ASN1_SEQUENCE,
                     ASN1_SHORT ( ASN1_OID, ASN1_OID_COMMON_NAME ),
                     ASN1_SHORT ( ASN1_UTF8_STRING, 'R', 'o', 'o', 't' ) ) ) )
};

icert_name_root

struct asn1_cursor icert_name_root

static

Initial value:

=
        ASN1_CURSOR ( icert_name_root_data )

"Root" subject name

Definition at line 209 of file iphone.c.

Referenced by icert_certs().

icert_name_ipxe_data

const uint8_t icert_name_ipxe_data[]

static

Initial value:

= {
        ASN1_SHORT ( ASN1_SEQUENCE, ASN1_SHORT ( ASN1_SET,
        ASN1_SHORT ( ASN1_SEQUENCE,
                     ASN1_SHORT ( ASN1_OID, ASN1_OID_COMMON_NAME ),
                     ASN1_SHORT ( ASN1_UTF8_STRING, 'i', 'P', 'X', 'E' ) ) ) )
}

"iPXE" subject name

Definition at line 213 of file iphone.c.

                                              {
        ASN1_SHORT ( ASN1_SEQUENCE, ASN1_SHORT ( ASN1_SET,
        ASN1_SHORT ( ASN1_SEQUENCE,
                     ASN1_SHORT ( ASN1_OID, ASN1_OID_COMMON_NAME ),
                     ASN1_SHORT ( ASN1_UTF8_STRING, 'i', 'P', 'X', 'E' ) ) ) )
};

icert_name_ipxe

struct asn1_cursor icert_name_ipxe

static

Initial value:

=
        ASN1_CURSOR ( icert_name_ipxe_data )

"iPXE" subject name

Definition at line 221 of file iphone.c.

Referenced by icert_certs().

icert_name_iphone_data

const uint8_t icert_name_iphone_data[]

static

Initial value:

= {
        ASN1_SHORT ( ASN1_SEQUENCE, ASN1_SHORT ( ASN1_SET,
        ASN1_SHORT ( ASN1_SEQUENCE,
                     ASN1_SHORT ( ASN1_OID, ASN1_OID_COMMON_NAME ),
                     ASN1_SHORT ( ASN1_UTF8_STRING,
                                  'i', 'P', 'h', 'o', 'n', 'e' ) ) ) )
}

"iPhone" subject name

Definition at line 225 of file iphone.c.

                                                {
        ASN1_SHORT ( ASN1_SEQUENCE, ASN1_SHORT ( ASN1_SET,
        ASN1_SHORT ( ASN1_SEQUENCE,
                     ASN1_SHORT ( ASN1_OID, ASN1_OID_COMMON_NAME ),
                     ASN1_SHORT ( ASN1_UTF8_STRING,
                                  'i', 'P', 'h', 'o', 'n', 'e' ) ) ) )
};

icert_name_iphone

struct asn1_cursor icert_name_iphone

static

Initial value:

=
        ASN1_CURSOR ( icert_name_iphone_data )

"iPhone" subject name

Definition at line 234 of file iphone.c.

Referenced by icert_certs().

__unused

const uint8_t icert_private_b [] __unused

static

Initial value:

= {
        0x02, 0x81, 0x81, 0x00, 0xc9, 0xc0, 0xdd, 0xa6, 0xd5, 0xf9, 0x05, 0x3e,
        0x1d, 0xcb, 0x67, 0x08, 0xa8, 0x50, 0x27, 0x63, 0x95, 0x87, 0x42, 0x7e,
        0xfb, 0xff, 0x55, 0x55, 0xb8, 0xc0, 0x6f, 0x13, 0xcb, 0xf7, 0xc5, 0x1b,
        0xda, 0x44, 0x3c, 0xbc, 0x1a, 0xe1, 0x15, 0x1e, 0xab, 0x56, 0x74, 0x02,
        0x8b, 0xb3, 0xcd, 0x42, 0x56, 0xcd, 0x9c, 0xc3, 0x15, 0xe2, 0x33, 0x97,
        0x6d, 0x77, 0xdd, 0x20, 0x3a, 0x74, 0xb1, 0x4c, 0xee, 0xeb, 0xe8, 0xaa,
        0x20, 0x71, 0x5a, 0xa2, 0x5b, 0xf8, 0x1a, 0xcb, 0xd2, 0x7b, 0x96, 0xb6,
        0x42, 0xb4, 0x7c, 0x7a, 0x13, 0xec, 0x55, 0xd3, 0x36, 0x8b, 0xe3, 0x17,
        0xc5, 0xc4, 0xcc, 0xe0, 0x27, 0x8c, 0xed, 0xa1, 0x4c, 0x8a, 0x50, 0x4a,
        0x1c, 0xc4, 0x58, 0xf6, 0xcd, 0xcc, 0xc3, 0x5f, 0xe6, 0x3c, 0xff, 0x97,
        0x51, 0xed, 0xf5, 0xaa, 0x89, 0xcc, 0x3f, 0x63, 0x67, 0x46, 0x9f, 0xbf,
        0x02, 0x03, 0x01, 0x00, 0x01
}

Public key(s) used for pairing.

"Private" key(s) used for pairing

Yes, this publicly visible "private" key completely obviates any nominal security provided by the pairing process. Looked at another way, this modifies the iPhone to behave like every other USB tethering device: if the cable is physically connected and tethering is enabled then the device will Just Work.

Unlike Android, the iPhone seems to have no meaningful permissions model: any device that is trusted to use the phone for tethering seems to also be trusted to use the iPhone for any other purpose (e.g. accessing files, reading messages, etc). Apple should probably fix this at some point, e.g. via defining extended key usages in the root and host certificates.

Definition at line 238 of file iphone.c.

                                                 {
        0x02, 0x81, 0x81, 0x00, 0xc9, 0xc0, 0xdd, 0xa6, 0xd5, 0xf9, 0x05, 0x3e,
        0x1d, 0xcb, 0x67, 0x08, 0xa8, 0x50, 0x27, 0x63, 0x95, 0x87, 0x42, 0x7e,
        0xfb, 0xff, 0x55, 0x55, 0xb8, 0xc0, 0x6f, 0x13, 0xcb, 0xf7, 0xc5, 0x1b,
        0xda, 0x44, 0x3c, 0xbc, 0x1a, 0xe1, 0x15, 0x1e, 0xab, 0x56, 0x74, 0x02,
        0x8b, 0xb3, 0xcd, 0x42, 0x56, 0xcd, 0x9c, 0xc3, 0x15, 0xe2, 0x33, 0x97,
        0x6d, 0x77, 0xdd, 0x20, 0x3a, 0x74, 0xb1, 0x4c, 0xee, 0xeb, 0xe8, 0xaa,
        0x20, 0x71, 0x5a, 0xa2, 0x5b, 0xf8, 0x1a, 0xcb, 0xd2, 0x7b, 0x96, 0xb6,
        0x42, 0xb4, 0x7c, 0x7a, 0x13, 0xec, 0x55, 0xd3, 0x36, 0x8b, 0xe3, 0x17,
        0xc5, 0xc4, 0xcc, 0xe0, 0x27, 0x8c, 0xed, 0xa1, 0x4c, 0x8a, 0x50, 0x4a,
        0x1c, 0xc4, 0x58, 0xf6, 0xcd, 0xcc, 0xc3, 0x5f, 0xe6, 0x3c, 0xff, 0x97,
        0x51, 0xed, 0xf5, 0xaa, 0x89, 0xcc, 0x3f, 0x63, 0x67, 0x46, 0x9f, 0xbf,
        0x02, 0x03, 0x01, 0x00, 0x01
};

icert_begin

const char icert_begin[] = "-----BEGIN CERTIFICATE-----\n"

static

PEM certificate prefix.

Definition at line 321 of file iphone.c.

Referenced by icert_encode().

icert_end

const char icert_end[] = "\n-----END CERTIFICATE-----\n"

static

PEM certificate suffix.

Definition at line 324 of file iphone.c.

Referenced by icert_encode().

imux_in_operations

struct usb_endpoint_driver_operations imux_in_operations

static

Initial value:

= {
        .complete = imux_in_complete,
}

Bulk IN endpoint operations.

Definition at line 919 of file iphone.c.

                                                                  {
        .complete = imux_in_complete,
};

Referenced by imux_probe().

imux_out_operations

struct usb_endpoint_driver_operations imux_out_operations

static

Initial value:

= {
        .complete = imux_out_complete,
}

Bulk OUT endpoint operations.

Definition at line 946 of file iphone.c.

                                                                   {
        .complete = imux_out_complete,
};

Referenced by imux_probe().

imux_tcp_operations

struct interface_operation imux_tcp_operations[]

static

Initial value:

= {
        INTF_OP ( xfer_deliver, struct imux *, imux_deliver ),
        INTF_OP ( xfer_alloc_iob, struct imux *, imux_alloc_iob ),
        INTF_OP ( intf_close, struct imux *, imux_close ),
}

Pseudo-TCP socket interface operations.

Definition at line 1054 of file iphone.c.

                                                          {
        INTF_OP ( xfer_deliver, struct imux *, imux_deliver ),
        INTF_OP ( xfer_alloc_iob, struct imux *, imux_alloc_iob ),
        INTF_OP ( intf_close, struct imux *, imux_close ),
};

imux_tcp_desc

struct interface_descriptor imux_tcp_desc

static

Initial value:

=
        INTF_DESC ( struct imux, tcp, imux_tcp_operations )

Pseudo-TCP socket interface descriptor.

Definition at line 1061 of file iphone.c.

Referenced by imux_probe().

imux_process_desc

struct process_descriptor imux_process_desc

static

Initial value:

=
        PROC_DESC ( struct imux, process, imux_step )

Multiplexer process descriptor.

Definition at line 1094 of file iphone.c.

Referenced by imux_probe().

imux_ids

struct usb_device_id imux_ids[]

static

Initial value:

= {
        USB_ID ( 0x05ac, 0xffff, "imux", "iPhone (multiplexer)", 0 ),
}

USB multiplexer device IDs.

Definition at line 1174 of file iphone.c.

                                         {
        USB_ID ( 0x05ac, 0xffff, "imux", "iPhone (multiplexer)", 0 ),
};

__usb_driver

struct usb_driver iphone_driver __usb_driver

Initial value:

= {
        .ids = imux_ids,
        .id_count = ( sizeof ( imux_ids ) / sizeof ( imux_ids[0] ) ),
        .class = USB_CLASS_ID ( 0xff, 0xfe, 0x02 ),
        .score = USB_SCORE_NORMAL,
        .probe = imux_probe,
        .remove = imux_remove,
}

USB multiplexer driver.

iPhone driver

Definition at line 1179 of file iphone.c.

                                             {
        .ids = imux_ids,
        .id_count = ( sizeof ( imux_ids ) / sizeof ( imux_ids[0] ) ),
        .class = USB_CLASS_ID ( 0xff, 0xfe, 0x02 ),
        .score = USB_SCORE_NORMAL,
        .probe = imux_probe,
        .remove = imux_remove,
};

ipair_prefix

const char ipair_prefix[]

static

Initial value:

=
        "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
        "<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" "
        "\"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"
        "<plist version=\"1.0\">\n"
        "<dict>\n"
        "<key>Label</key>\n"
        "<string>iPXE</string>\n"
        "<key>Request</key>\n"

Common prefix for all pairing messages.

Definition at line 1196 of file iphone.c.

Referenced by ipair_tx_pair(), ipair_tx_pubkey(), and ipair_tx_session().

ipair_suffix

const char ipair_suffix[]

static

Initial value:

=
        "</dict>\n"
        "</plist>\n"

Common suffix for all pairing messages.

Definition at line 1207 of file iphone.c.

Referenced by ipair_tx_pair(), ipair_tx_pubkey(), and ipair_tx_session().

ipair_system_buid

const char ipair_system_buid[] = "E4DB92D2-248A-469A-AC34-92045D07E695"

static

Arbitrary system BUID used for pairing.

Definition at line 1212 of file iphone.c.

Referenced by ipair_tx_pair(), and ipair_tx_session().

ipair_host_id

const char ipair_host_id[] = "93CEBC27-8457-4804-9108-F42549DF6143"

static

Arbitrary host ID used for pairing.

Definition at line 1215 of file iphone.c.

Referenced by ipair_tx_pair(), and ipair_tx_session().

ipair_xfer_operations

struct interface_operation ipair_xfer_operations[]

static

Initial value:

= {
        INTF_OP ( xfer_deliver, struct ipair *, ipair_deliver ),
        INTF_OP ( xfer_window_changed, struct ipair *, ipair_window_changed ),
        INTF_OP ( intf_close, struct ipair *, ipair_close ),
}

Pairing client interface operations.

Definition at line 1814 of file iphone.c.

                                                            {
        INTF_OP ( xfer_deliver, struct ipair *, ipair_deliver ),
        INTF_OP ( xfer_window_changed, struct ipair *, ipair_window_changed ),
        INTF_OP ( intf_close, struct ipair *, ipair_close ),
};

ipair_xfer_desc

struct interface_descriptor ipair_xfer_desc

static

Initial value:

=
        INTF_DESC ( struct ipair, xfer, ipair_xfer_operations )

Pairing client interface descriptor.

Definition at line 1821 of file iphone.c.

Referenced by ipair_create().

iphone_in_operations

struct usb_endpoint_driver_operations iphone_in_operations

static

Initial value:

= {
        .complete = iphone_in_complete,
}

Bulk IN endpoint operations.

Definition at line 1916 of file iphone.c.

                                                                    {
        .complete = iphone_in_complete,
};

Referenced by iphone_probe().

iphone_out_operations

struct usb_endpoint_driver_operations iphone_out_operations

static

Initial value:

= {
        .complete = iphone_out_complete,
}

Bulk OUT endpoint operations.

Definition at line 1959 of file iphone.c.

                                                                     {
        .complete = iphone_out_complete,
};

Referenced by iphone_probe().

iphone_operations

struct net_device_operations iphone_operations

static

Initial value:

= {
        .open           = iphone_open,
        .close          = iphone_close,
        .transmit       = iphone_transmit,
        .poll           = iphone_poll,
}

iPhone network device operations

Definition at line 2128 of file iphone.c.

                                                        {
        .open           = iphone_open,
        .close          = iphone_close,
        .transmit       = iphone_transmit,
        .poll           = iphone_poll,
};

Referenced by iphone_probe().

iphone_ids

struct usb_device_id iphone_ids[]

static

Initial value:

= {
        USB_ROM ( 0x05ac, 0xffff, "iphone", "iPhone", 0 ),
}

iPhone device IDs

Definition at line 2224 of file iphone.c.

                                           {
        USB_ROM ( 0x05ac, 0xffff, "iphone", "iPhone", 0 ),
};