A Readme, Makefile updates and cosmetic changes.

9 files changed, 157 insertions, 112 deletions

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..26cda67
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,6 @@
+*~
+*.o
+.*.swp
+iproxy
+testclient
+usbmuxd
diff --git a/Makefile b/Makefile
index 04a36b3..2036ddc 100644
--- a/Makefile
+++ b/Makefile
@@ -1,26 +1,31 @@
-TARGET=usbmuxd
-CFLAGS=-Wall
-LDFLAGS=-lpthread -lusb -lrt
+TARGETS=usbmuxd iproxy testclient
+CFLAGS=-Wall -g
+LIBS=-lpthread -lusb -lrt
+LDFLAGS=
 
-objects = sock_stuff.o usbmuxd.o iphone.o
+all:	$(TARGETS)
 
-all:	$(TARGET)
+main.o: main.c usbmuxd.h sock_stuff.h iphone.h
+iphone.o: iproxy.c iphone.h usbmuxd.h sock_stuff.h
+sock_stuff.o: sock_stuff.c sock_stuff.h
+testclient.o: testclient.c sock_stuff.h
 
-%.o:    %.c %.h
+%.o:    %.c
 	$(CC) -o $@ $(CFLAGS) -c $< 
 
-$(TARGET): $(objects)
-	$(CC) -o $@ $(LDFLAGS) $^
+usbmuxd: main.o sock_stuff.o iphone.o
+	$(CC) -o $@ $(LDFLAGS) $^ $(LIBS)
+
+testclient: testclient.o sock_stuff.o
+	$(CC) -o $@ $(LDFLAGS) $^ $(LIBS)
+
+iproxy: iproxy.o sock_stuff.o
+	$(CC) -o $@ $(LDFLAGS) $^ $(LIBS)
 
 clean:
-	rm -f *.o $(TARGET)
+	rm -f *.o $(TARGETS)
 
 realclean: clean
 	rm -f *~
 
-testclient: testclient.c sock_stuff.o
-	$(CC) $(LDFLAGS) -o testclient $(CFLAGS) $< sock_stuff.o
-
-iproxy: iproxy.c sock_stuff.o
-	$(CC) -lpthread -o iproxy $(CFLAGS) $< sock_stuff.o
-
+.PHONY: all clean realclean
diff --git a/Readme.txt b/Readme.txt
new file mode 100644
index 0000000..deece52
--- /dev/null
+++ b/Readme.txt
@@ -0,0 +1,34 @@
+Build
+=====
+
+  make
+
+Use
+===
+
+  sudo ./usbmuxd &
+  ./iproxy 2222 22 &
+  ssh -p 2222 root@localhost
+
+Muwahahaha.  Hopefully you get the normal SSH login prompt.
+
+  Unfortunately, as of 2009-02-24 this only survives for a single
+  connection.  You will have to restart the 'iproxy' part.
+
+SSH
+===
+
+If your iphone is rooted, but isn't running SSH, you will need to
+mount it with 'ifuse --afc2' (to access the root directory of the
+device).
+
+And then edit:
+
+  /Library/LaunchDaemons/com.openssh.sshd.plist
+
+to _remove_ the lines:
+
+  <key>Diabled</key>
+  <true/>
+
+Reboot the device and then sshd should be running.
diff --git a/iproxy.c b/iproxy.c
index a58365a..775b819 100644
--- a/iproxy.c
+++ b/iproxy.c
@@ -34,8 +34,6 @@
 #include "usbmuxd.h"
 #include "sock_stuff.h"
 
-#define SOCKET_FILE "/var/run/usbmuxd"
-
 static uint16_t listen_port = 0;
 static uint16_t device_port = 0;
 
@@ -50,7 +48,7 @@ struct client_data {
 
 int usbmuxd_get_result(int sfd, uint32_t tag, uint32_t *result)
 {
-    struct usbmux_result res;
+    struct usbmuxd_result res;
     int recv_len;
     int i;
     uint32_t rrr[5];
@@ -71,7 +69,7 @@ int usbmuxd_get_result(int sfd, uint32_t tag, uint32_t *result)
 	if ((recv_len == sizeof(res))
 	    && (res.header.length == recv_len)
 	    && (res.header.reserved == 0)
-	    && (res.header.type == usbmux_result)
+	    && (res.header.type == USBMUXD_RESULT)
 	   ) {
 	    *result = res.result;
 	    if (res.header.tag == tag) {
@@ -185,8 +183,8 @@ void *acceptor_thread(void *arg)
     int connected;
     uint32_t pktlen;
     unsigned char *buf;
-    struct usbmux_header hello;
-    struct usbmux_dev_info device_info;
+    struct usbmuxd_hello hello;
+    struct usbmuxd_device_info device_info;
     pthread_t ctos;
 
     if (!arg) {
@@ -196,26 +194,26 @@ void *acceptor_thread(void *arg)
 
     cdata = (struct client_data*)arg;
 
-    cdata->sfd = connect_unix_socket(SOCKET_FILE);
+    cdata->sfd = connect_unix_socket(USBMUXD_SOCKET_FILE);
     if (cdata->sfd < 0) {
 	printf("error opening socket, terminating.\n");
 	return NULL;
     }
 
     // send hello
-    hello.length = sizeof(struct usbmux_header);
-    hello.reserved = 0;
-    hello.type = usbmux_hello;
-    hello.tag = 2;
+    hello.header.length = sizeof(struct usbmuxd_hello);
+    hello.header.reserved = 0;
+    hello.header.type = USBMUXD_HELLO;
+    hello.header.tag = 2;
 
     hello_done = 0;
     connected = 0;
 
     fprintf(stdout, "sending Hello packet\n");
-    if (send(cdata->sfd, &hello, hello.length, 0) == hello.length) {
+    if (send(cdata->sfd, &hello, hello.header.length, 0) == hello.header.length) {
 	uint32_t res = -1;
 	// get response
-	if (usbmuxd_get_result(cdata->sfd, hello.tag, &res) && (res==0)) {
+	if (usbmuxd_get_result(cdata->sfd, hello.header.tag, &res) && (res==0)) {
 	    fprintf(stdout, "Got Hello Response!\n");
 	    hello_done = 1;
 	} else {
@@ -241,7 +239,7 @@ void *acceptor_thread(void *arg)
 		    }
 		    fprintf(stdout, "Received device data\n");
 		    //log_debug_buffer(stdout, (char*)buf, pktlen);
-		    memcpy(&device_info, buf + sizeof(struct usbmux_header), sizeof(device_info));
+		    memcpy(&device_info, buf + sizeof(struct usbmuxd_header), sizeof(device_info));
 		    free(buf);
 		} else {
 		    // we _should_ have all of them now.
@@ -252,17 +250,17 @@ void *acceptor_thread(void *arg)
 	}
 
 	if (device_info.device_id > 0) {
-	    struct usbmux_connect_request c_req;
+	    struct usbmuxd_connect_request c_req;
 
 	    fprintf(stdout, "Requesting connecion to device %d port %d\n", device_info.device_id, device_port);
 
 	    // try to connect to last device found
 	    c_req.header.length = sizeof(c_req);
 	    c_req.header.reserved = 0;
-	    c_req.header.type = usbmux_connect;
+	    c_req.header.type = USBMUXD_CONNECT;
 	    c_req.header.tag = 3;
 	    c_req.device_id = device_info.device_id;
-	    c_req.port = htons(device_port);
+	    c_req.tcp_dport = htons(device_port);
 	    c_req.reserved = 0;
 
 	    if (send_buf(cdata->sfd, &c_req, sizeof(c_req)) < 0) {
@@ -346,26 +344,26 @@ int main(int argc, char **argv)
     }
 
 /*
-    sfd = connect_unix_socket(SOCKET_FILE);
+    sfd = connect_unix_socket(USBMUXD_SOCKET_FILE);
     if (sfd < 0) {
 	printf("error opening socket, terminating.\n");
 	return -1;
     }
 
     // send hello
-    hello.length = sizeof(struct usbmux_header);
-    hello.reserved = 0;
-    hello.type = usbmux_hello;
-    hello.tag = 2;
+    hello.header.length = sizeof(hello);
+    hello.header.reserved = 0;
+    hello.header.type = USBMUXD_HELLO;
+    hello.header.tag = 2;
 
     hello_done = 0;
     connected = 0;
 
     fprintf(stdout, "sending Hello packet\n");
-    if (send(sfd, &hello, hello.length, 0) == hello.length) {
+    if (send(sfd, &hello, hello.header.length, 0) == hello.header.length) {
 	uint32_t res = -1;
 	// get response
-	if (usbmuxd_get_result(sfd, hello.tag, &res) && (res==0)) {
+	if (usbmuxd_get_result(sfd, hello.header.tag, &res) && (res==0)) {
 	    fprintf(stdout, "Got Hello Response!\n");
 	    hello_done = 1;
 	} else {
@@ -390,7 +388,7 @@ int main(int argc, char **argv)
 		    }
 		    fprintf(stdout, "Received device data\n");
 		    //log_debug_buffer(stdout, (char*)buf, pktlen);
-		    memcpy(&device_info, buf + sizeof(struct usbmux_header), sizeof(device_info));
+		    memcpy(&device_info, buf + sizeof(struct usbmuxd_header), sizeof(device_info));
 		    free(buf);
 		} else {
 		    // we _should_ have all of them now.
@@ -401,17 +399,17 @@ int main(int argc, char **argv)
 	}
 
 	if (device_info.device_id > 0) {
-	    struct usbmux_connect_request c_req;
+	    struct usbmuxd_connect_request c_req;
 
 	    fprintf(stdout, "Requesting connecion to device %d port %d\n", device_info.device_id, device_port);
 
 	    // try to connect to last device found
 	    c_req.header.length = sizeof(c_req);
 	    c_req.header.reserved = 0;
-	    c_req.header.type = usbmux_connect;
+	    c_req.header.type = USBMUXD_CONNECT;
 	    c_req.header.tag = 3;
 	    c_req.device_id = device_info.device_id;
-	    c_req.port = htons(device_port);
+	    c_req.tcp_dport = htons(device_port);
 	    c_req.reserved = 0;
 
 	    if (send_buf(sfd, &c_req, sizeof(c_req)) < 0) {
diff --git a/usbmuxd.c b/main.c
index 0f4339c..bf062b7 100644
--- a/usbmuxd.c
+++ b/main.c
@@ -39,8 +39,6 @@
 
 #include "iphone.h"
 
-#define SOCKET_FILE "/var/run/usbmuxd"
-
 #define DEFAULT_TIMEOUT 4000
 #define DEFAULT_CHILDREN_CAPACITY 10
 
@@ -163,11 +161,11 @@ static int usbmuxd_get_request(int fd, void *data, size_t len)
  */
 static int usbmuxd_send_result(int fd, uint32_t tag, uint32_t result_code)
 {
-    struct usbmux_result res;
+    struct usbmuxd_result res;
 
     res.header.length = sizeof(res);
     res.header.reserved = 0;
-    res.header.type = usbmux_result;
+    res.header.type = USBMUXD_RESULT;
     res.header.tag = tag;
     res.result = result_code;
 
@@ -209,7 +207,7 @@ static void *usbmuxd_client_reader_thread(void *arg)
     fprintf(stdout, "%s[%d:%d]: started\n", __func__, cdata->duinfo->device_id, cdata->duinfo->use_count);
 
     while (!quit_flag && !cdata->reader_quit) {
-	result = check_fd(cdata->socket, fdwrite, DEFAULT_TIMEOUT);
+	result = check_fd(cdata->socket, FD_WRITE, DEFAULT_TIMEOUT);
 	if (result <= 0) {
 	    if (result < 0) {
 		fprintf(stderr, "%s: select error: %s\n", __func__, strerror(errno));
@@ -269,7 +267,7 @@ static int usbmuxd_handleConnectResult(struct client_data *cdata)
 	return -EINVAL;
     }
 
-    result = check_fd(cdata->socket, fdwrite, DEFAULT_TIMEOUT);
+    result = check_fd(cdata->socket, FD_WRITE, DEFAULT_TIMEOUT);
     if (result <= 0) {
 	if (result < 0) {
 	    fprintf(stderr, "%s: select error: %s\n", __func__, strerror(errno));
@@ -349,7 +347,7 @@ static void *usbmuxd_client_handler_thread(void *arg)
     }
 
     while (!quit_flag && !cdata->reader_dead) {
-	result = check_fd(cdata->socket, fdread, DEFAULT_TIMEOUT);
+	result = check_fd(cdata->socket, FD_READ, DEFAULT_TIMEOUT);
 	if (result <= 0) {
 	    if (result < 0) {
 		fprintf(stderr, "%s: Error: checkfd: %s\n", __func__, strerror(errno));
@@ -415,9 +413,9 @@ leave:
 static void *usbmuxd_client_init_thread(void *arg)
 {
     struct client_data *cdata;
-    struct usbmux_header hello;
-    struct usbmux_dev_info_request dev_info_req;
-    struct usbmux_connect_request c_req;
+    struct usbmuxd_hello hello;
+    struct usbmuxd_device_info_request dev_info_req;
+    struct usbmuxd_connect_request c_req;
 
     struct usb_bus *bus;
     struct usb_device *dev;
@@ -447,15 +445,15 @@ static void *usbmuxd_client_init_thread(void *arg)
 	goto leave;
     }
 
-    if ((recv_len == 16) && (hello.length == 16)
-	&& (hello.reserved == 0) && (hello.type == usbmux_hello)) {
+    if ((recv_len == sizeof(hello)) && (hello.header.length == sizeof(hello))
+	&& (hello.header.reserved == 0) && (hello.header.type == USBMUXD_HELLO)) {
     	// send success response
-	usbmuxd_send_result(cdata->socket, hello.tag, 0);
+	usbmuxd_send_result(cdata->socket, hello.header.tag, 0);
     } else {
 	// send error response and exit
         fprintf(stderr, "%s: Invalid Hello packet received.\n", __func__);
 	// TODO is this required?!
-	usbmuxd_send_result(cdata->socket, hello.tag, EINVAL);
+	usbmuxd_send_result(cdata->socket, hello.header.tag, EINVAL);
 	goto leave;
     }
 
@@ -476,15 +474,15 @@ static void *usbmuxd_client_init_thread(void *arg)
 		// construct packet
 		memset(&dev_info_req, 0, sizeof(dev_info_req));
 		dev_info_req.header.length = sizeof(dev_info_req);
-		dev_info_req.header.type = usbmux_device_info;
-		dev_info_req.dev_info.device_id = dev->devnum;
-		dev_info_req.dev_info.product_id = dev->descriptor.idProduct;
+		dev_info_req.header.type = USBMUXD_DEVICE_INFO;
+		dev_info_req.device_info.device_id = dev->devnum;
+		dev_info_req.device_info.product_id = dev->descriptor.idProduct;
 		if (dev->descriptor.iSerialNumber) {
 		    usb_dev_handle *udev;
 		    //pthread_mutex_lock(&usbmux_mutex);
 		    udev = usb_open(dev);
 		    if (udev) {
-			usb_get_string_simple(udev, dev->descriptor.iSerialNumber, dev_info_req.dev_info.serial_number, sizeof(dev_info_req.dev_info.serial_number)+1);
+			usb_get_string_simple(udev, dev->descriptor.iSerialNumber, dev_info_req.device_info.serial_number, sizeof(dev_info_req.device_info.serial_number)+1);
 			usb_close(udev);
 		    }
 		    //pthread_mutex_unlock(&usbmux_mutex);
@@ -515,12 +513,12 @@ static void *usbmuxd_client_init_thread(void *arg)
 	goto leave;
     }
 
-    if (c_req.header.type != usbmux_connect) {
+    if (c_req.header.type != USBMUXD_CONNECT) {
 	fprintf(stderr, "%s: Unexpected packet of type %d received.\n", __func__, c_req.header.type);
 	goto leave;
     }
 
-    fprintf(stdout, "%s: Setting up connection to usb device #%d on port %d\n", __func__, c_req.device_id, ntohs(c_req.port));
+    fprintf(stdout, "%s: Setting up connection to usb device #%d on port %d\n", __func__, c_req.device_id, ntohs(c_req.tcp_dport));
 
     // find the device, and open usb connection
     phone = NULL;
@@ -569,7 +567,7 @@ static void *usbmuxd_client_init_thread(void *arg)
 
     // setup connection to iPhone/iPod
 //    pthread_mutex_lock(&usbmux_mutex);
-    res = iphone_mux_new_client(cur_dev->phone, 0, ntohs(c_req.port), &(cdata->muxclient));
+    res = iphone_mux_new_client(cur_dev->phone, 0, ntohs(c_req.tcp_dport), &(cdata->muxclient));
 //    pthread_mutex_unlock(&usbmux_mutex);
 
     if (res != 0) {
@@ -707,7 +705,7 @@ static void *usbmuxd_accept_thread(void *arg)
     while (!quit_flag) {	
 	// Check the file descriptor before accepting a connection.
 	// If no connection attempt is made, just repeat...
-	result = check_fd(fsock, fdread, 1000);
+	result = check_fd(fsock, FD_READ, 1000);
 	if (result <= 0) {
 	    if (result == 0) {
 		// cleanup
@@ -814,13 +812,13 @@ int main(int argc, char **argv)
 
     // TODO: Parameter checking.
 
-    fsock = create_unix_socket(SOCKET_FILE);
+    fsock = create_unix_socket(USBMUXD_SOCKET_FILE);
     if (fsock < 0) {
 	fprintf(stderr, "Could not create socket, exiting\n");
 	return -1;
     }
 
-    chmod(SOCKET_FILE, 0666);
+    chmod(USBMUXD_SOCKET_FILE, 0666);
 
     if (!foreground) {
 	if (daemonize() < 0) {
@@ -848,7 +846,7 @@ int main(int argc, char **argv)
     	close(fsock);
     }
 
-    unlink(SOCKET_FILE);
+    unlink(USBMUXD_SOCKET_FILE);
 
     return 0;
 }
diff --git a/sock_stuff.c b/sock_stuff.c
index 1a23bc1..3d11a27 100644
--- a/sock_stuff.c
+++ b/sock_stuff.c
@@ -208,13 +208,13 @@ int check_fd(int fd, fd_mode fdm, unsigned int timeout)
     do {
 	eagain = 0;
 	switch(fdm) {
-	    case fdread:
+	    case FD_READ:
 		sret = select(fd+1,&fds,NULL,NULL,&to);
                 break;
-            case fdwrite:
+            case FD_WRITE:
                 sret = select(fd+1,NULL,&fds,NULL,&to);
                 break;
-            case fdexcept:
+            case FD_EXCEPT:
                 sret = select(fd+1,NULL,NULL,&fds,&to);
                 break;
 	}
@@ -255,7 +255,7 @@ int recv_buf_timeout(int fd, void *data, size_t length, int flags, unsigned int
     int result;
 
     // check if data is available
-    res = check_fd(fd, fdread, timeout);
+    res = check_fd(fd, FD_READ, timeout);
     if (res <= 0) {
 	return res;
     }
diff --git a/sock_stuff.h b/sock_stuff.h
index 01082d1..9965f4e 100644
--- a/sock_stuff.h
+++ b/sock_stuff.h
@@ -5,9 +5,9 @@
 
 enum fd_mode
 {
-    fdread,
-    fdwrite,
-    fdexcept
+    FD_READ,
+    FD_WRITE,
+    FD_EXCEPT
 };
 typedef enum fd_mode fd_mode;
 
diff --git a/testclient.c b/testclient.c
index fafbf23..679b6d0 100644
--- a/testclient.c
+++ b/testclient.c
@@ -10,11 +10,9 @@
 #include "usbmuxd.h"
 #include "sock_stuff.h"
 
-#define SOCKET_FILE "/var/run/usbmuxd"
-
 int usbmuxd_get_result(int sfd, uint32_t tag, uint32_t *result)
 {
-    struct usbmux_result res;
+    struct usbmuxd_result res;
     int recv_len;
 
     if (!result) {
@@ -28,7 +26,7 @@ int usbmuxd_get_result(int sfd, uint32_t tag, uint32_t *result)
 	if ((recv_len == sizeof(res))
 	    && (res.header.length == recv_len)
 	    && (res.header.reserved == 0)
-	    && (res.header.type == usbmux_result)
+	    && (res.header.type == USBMUXD_RESULT)
 	   ) {
 	    *result = res.result;
 	    if (res.header.tag == tag) {
@@ -50,29 +48,29 @@ int main(int argc, char **argv)
     int connected;
     uint32_t pktlen;
     unsigned char *buf;
-    struct usbmux_header hello;
-    struct usbmux_dev_info device_info;
+    struct usbmuxd_hello hello;
+    struct usbmuxd_device_info device_info;
 
-    sfd = connect_unix_socket(SOCKET_FILE);
+    sfd = connect_unix_socket(USBMUXD_SOCKET_FILE);
     if (sfd < 0) {
 	printf("error opening socket, terminating.\n");
 	return -1;
     }
 
     // send hello
-    hello.length = sizeof(struct usbmux_header);
-    hello.reserved = 0;
-    hello.type = usbmux_hello;
-    hello.tag = 2;
+    hello.header.length = sizeof(struct usbmuxd_hello);
+    hello.header.reserved = 0;
+    hello.header.type = USBMUXD_HELLO;
+    hello.header.tag = 2;
 
     hello_done = 0;
     connected = 0;
 
     fprintf(stdout, "sending Hello packet\n");
-    if (send(sfd, &hello, hello.length, 0) == hello.length) {
+    if (send(sfd, &hello, hello.header.length, 0) == hello.header.length) {
 	uint32_t res = -1;
 	// get response
-	if (usbmuxd_get_result(sfd, hello.tag, &res) && (res==0)) {
+	if (usbmuxd_get_result(sfd, hello.header.tag, &res) && (res==0)) {
 	    fprintf(stdout, "Got Hello Response!\n");
 	    hello_done = 1;
 	} else {
@@ -97,7 +95,7 @@ int main(int argc, char **argv)
 		    }
 		    fprintf(stdout, "got device data:\n");
 		    //log_debug_buffer(stdout, (char*)buf, pktlen);
-		    memcpy(&device_info, buf + sizeof(struct usbmux_header), sizeof(device_info));
+		    memcpy(&device_info, buf + sizeof(struct usbmuxd_header), sizeof(device_info));
 		    free(buf);
 		} else {
 		    // we _should_ have all of them now.
@@ -108,15 +106,15 @@ int main(int argc, char **argv)
 	}
 
 	if (device_info.device_id > 0) {
-	    struct usbmux_connect_request c_req;
+	    struct usbmuxd_connect_request c_req;
 
 	    // try to connect to last device found
 	    c_req.header.length = sizeof(c_req);
 	    c_req.header.reserved = 0;
-	    c_req.header.type = usbmux_connect;
+	    c_req.header.type = USBMUXD_CONNECT;
 	    c_req.header.tag = 3;
 	    c_req.device_id = device_info.device_id;
-	    c_req.port = htons(22);
+	    c_req.tcp_dport = htons(22);
 	    c_req.reserved = 0;
 
 	    if (send_buf(sfd, &c_req, sizeof(c_req)) < 0) {
diff --git a/usbmuxd.h b/usbmuxd.h
index fcbee52..d749baf 100644
--- a/usbmuxd.h
+++ b/usbmuxd.h
@@ -3,42 +3,48 @@
 
 #include <stdint.h>
 
-struct usbmux_header {
+#define USBMUXD_SOCKET_FILE "/var/run/usbmuxd"
+
+struct usbmuxd_header {
 	uint32_t length;    // length of message, including header
 	uint32_t reserved;  // always zero
 	uint32_t type;      // message type
 	uint32_t tag;       // responses to this query will echo back this tag
-};
+} __attribute__((__packed__));
 
-struct usbmux_result {
-	struct usbmux_header header;
+struct usbmuxd_result {
+	struct usbmuxd_header header;
 	uint32_t result;
-};
+} __attribute__((__packed__));
 
-struct	usbmux_connect_request {
-	struct usbmux_header header;
+struct	usbmuxd_connect_request {
+	struct usbmuxd_header header;
 	uint32_t device_id;
-	uint16_t port;	     // TCP port number
+	uint16_t tcp_dport;   // TCP port number
 	uint16_t reserved;   // set to zero
-};
+} __attribute__((__packed__));
 
-struct usbmux_dev_info {
+struct usbmuxd_device_info {
 	uint32_t device_id;
 	uint16_t product_id;
 	char serial_number[40];
-};
+} __attribute__((__packed__));
 
-struct usbmux_dev_info_request {
-	struct usbmux_header header;
-	struct usbmux_dev_info dev_info;
-	unsigned char padding[222];
-};
+struct usbmuxd_device_info_request {
+	struct usbmuxd_header header;
+	struct usbmuxd_device_info device_info;
+	char padding[222];
+} __attribute__((__packed__));
+
+struct usbmuxd_hello {
+	struct usbmuxd_header header;
+} __attribute__((__packed__));
 
 enum {
-	usbmux_result  = 1,
-	usbmux_connect = 2,
-	usbmux_hello   = 3,
-	usbmux_device_info = 4,
+	USBMUXD_RESULT  = 1,
+	USBMUXD_CONNECT = 2,
+	USBMUXD_HELLO   = 3,
+	USBMUXD_DEVICE_INFO = 4,
 };
 
 #endif