summaryrefslogtreecommitdiffstats
path: root/usbmuxd
diff options
context:
space:
mode:
Diffstat (limited to 'usbmuxd')
-rw-r--r--usbmuxd/CMakeLists.txt32
-rw-r--r--usbmuxd/client.c430
-rw-r--r--usbmuxd/client.h46
-rw-r--r--usbmuxd/device.c751
-rw-r--r--usbmuxd/device.h52
-rw-r--r--usbmuxd/log.c94
-rw-r--r--usbmuxd/log.h43
-rw-r--r--usbmuxd/main.c548
-rw-r--r--usbmuxd/usb-linux.c542
-rw-r--r--usbmuxd/usb.h66
10 files changed, 0 insertions, 2604 deletions
diff --git a/usbmuxd/CMakeLists.txt b/usbmuxd/CMakeLists.txt
deleted file mode 100644
index f95727c..0000000
--- a/usbmuxd/CMakeLists.txt
+++ /dev/null
@@ -1,32 +0,0 @@
-find_package(USB REQUIRED)
-include_directories(${USB_INCLUDE_DIRS})
-set(LIBS ${LIBS} ${USB_LIBRARIES})
-
-include_directories (${CMAKE_SOURCE_DIR}/common)
-include_directories (${CMAKE_SOURCE_DIR}/usbmuxd)
-include_directories (${CMAKE_SOURCE_DIR}/libusbmuxd)
-
-include(CheckConstantExists)
-set(CMAKE_REQUIRED_INCLUDES ${USB_INCLUDE_DIRS})
-check_constant_exists(LIBUSB_TRANSFER_ZERO_PACKET libusb.h HAVE_LIBUSB_ZLP)
-
-if(NOT HAVE_LIBUSB_ZLP)
- message("
-================================================================================
-==================================== WARNING ===================================
-================================================================================
-Your libusb is missing proper Zero Length Packet support! If you are using a
-recent libusb Git, things may or may not work. If you are using libusb 1.0.2 or
-earlier, things will definitely not work properly.
-
-Please apply the patch in the contrib/ directory to your libusb 1.0 tree.
-================================================================================
-")
- add_definitions(-DEXPLICIT_ZLP_TRANSACTION)
-endif(NOT HAVE_LIBUSB_ZLP)
-
-add_definitions(-Wall -O2 -g -DUSBMUXD_DAEMON)
-add_executable(usbmuxd main.c usb-linux.c log.c ../common/utils.c device.c client.c)
-target_link_libraries(usbmuxd ${LIBS})
-
-install(TARGETS usbmuxd RUNTIME DESTINATION sbin)
diff --git a/usbmuxd/client.c b/usbmuxd/client.c
deleted file mode 100644
index 0e47e84..0000000
--- a/usbmuxd/client.c
+++ /dev/null
@@ -1,430 +0,0 @@
-/*
- usbmuxd - iPhone/iPod Touch USB multiplex server daemon
-
-Copyright (C) 2009 Hector Martin "marcan" <hector@marcansoft.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 2 or version 3.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-
-*/
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include <stdlib.h>
-#include <errno.h>
-#include <unistd.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <sys/un.h>
-#include <arpa/inet.h>
-
-#include "log.h"
-#include "usb.h"
-#include "client.h"
-#include "device.h"
-
-#define CMD_BUF_SIZE 256
-#define REPLY_BUF_SIZE 1024
-
-enum client_state {
- CLIENT_COMMAND, // waiting for command
- CLIENT_LISTEN, // listening for devices
- CLIENT_CONNECTING1, // issued connection request
- CLIENT_CONNECTING2, // connection established, but waiting for response message to get sent
- CLIENT_CONNECTED, // connected
- CLIENT_DEAD
-};
-
-struct mux_client {
- int fd;
- unsigned char *ob_buf;
- int ob_size;
- int ob_capacity;
- unsigned char *ib_buf;
- int ib_size;
- int ib_capacity;
- short events, devents;
- uint32_t connect_tag;
- int connect_device;
- enum client_state state;
-};
-
-static struct collection client_list;
-
-int client_read(struct mux_client *client, void *buffer, int len)
-{
- usbmuxd_log(LL_SPEW, "client_read fd %d buf %p len %d", client->fd, buffer, len);
- if(client->state != CLIENT_CONNECTED) {
- usbmuxd_log(LL_ERROR, "Attempted to read from client %d not in CONNECTED state", client->fd);
- return -1;
- }
- return recv(client->fd, buffer, len, 0);
-}
-
-int client_write(struct mux_client *client, void *buffer, int len)
-{
- usbmuxd_log(LL_SPEW, "client_write fd %d buf %p len %d", client->fd, buffer, len);
- if(client->state != CLIENT_CONNECTED) {
- usbmuxd_log(LL_ERROR, "Attempted to write to client %d not in CONNECTED state", client->fd);
- return -1;
- }
- return send(client->fd, buffer, len, 0);
-}
-
-int client_set_events(struct mux_client *client, short events)
-{
- if((client->state != CLIENT_CONNECTED) && (client->state != CLIENT_CONNECTING2)) {
- usbmuxd_log(LL_ERROR, "client_set_events to client %d not in CONNECTED state", client->fd);
- return -1;
- }
- client->devents = events;
- if(client->state == CLIENT_CONNECTED)
- client->events = events;
- return 0;
-}
-
-int client_accept(int listenfd)
-{
- struct sockaddr_un addr;
- int cfd;
- socklen_t len = sizeof(struct sockaddr_un);
- cfd = accept(listenfd, (struct sockaddr *)&addr, &len);
- if (cfd < 0) {
- usbmuxd_log(LL_ERROR, "accept() failed (%s)", strerror(errno));
- return cfd;
- }
-
- struct mux_client *client;
- client = malloc(sizeof(struct mux_client));
- memset(client, 0, sizeof(struct mux_client));
-
- client->fd = cfd;
- client->ob_buf = malloc(REPLY_BUF_SIZE);
- client->ob_size = 0;
- client->ob_capacity = REPLY_BUF_SIZE;
- client->ib_buf = malloc(CMD_BUF_SIZE);
- client->ib_size = 0;
- client->ib_capacity = CMD_BUF_SIZE;
- client->state = CLIENT_COMMAND;
- client->events = POLLIN;
-
- collection_add(&client_list, client);
-
- usbmuxd_log(LL_INFO, "New client on fd %d", client->fd);
- return client->fd;
-}
-
-void client_close(struct mux_client *client)
-{
- usbmuxd_log(LL_INFO, "Disconnecting client fd %d", client->fd);
- if(client->state == CLIENT_CONNECTING1 || client->state == CLIENT_CONNECTING2) {
- usbmuxd_log(LL_INFO, "Client died mid-connect, aborting device %d connection", client->connect_device);
- client->state = CLIENT_DEAD;
- device_abort_connect(client->connect_device, client);
- }
- close(client->fd);
- if(client->ob_buf)
- free(client->ob_buf);
- if(client->ib_buf)
- free(client->ib_buf);
- collection_remove(&client_list, client);
- free(client);
-}
-
-void client_get_fds(struct fdlist *list)
-{
- FOREACH(struct mux_client *client, &client_list) {
- fdlist_add(list, FD_CLIENT, client->fd, client->events);
- } ENDFOREACH
-}
-
-static int send_pkt(struct mux_client *client, uint32_t tag, enum usbmuxd_msgtype msg, void *payload, int payload_length)
-{
- struct usbmuxd_header hdr;
- hdr.version = USBMUXD_PROTOCOL_VERSION;
- hdr.length = sizeof(hdr) + payload_length;
- hdr.message = msg;
- hdr.tag = tag;
- usbmuxd_log(LL_DEBUG, "send_pkt fd %d tag %d msg %d payload_length %d", client->fd, tag, msg, payload_length);
- if((client->ob_capacity - client->ob_size) < hdr.length) {
- usbmuxd_log(LL_ERROR, "Client %d output buffer full (%d bytes) while sending message %d (%d bytes)", client->fd, client->ob_capacity, hdr.message, hdr.length);
- client_close(client);
- return -1;
- }
- memcpy(client->ob_buf + client->ob_size, &hdr, sizeof(hdr));
- if(payload && payload_length)
- memcpy(client->ob_buf + client->ob_size + sizeof(hdr), payload, payload_length);
- client->ob_size += hdr.length;
- client->events |= POLLOUT;
- return hdr.length;
-}
-
-static int send_result(struct mux_client *client, uint32_t tag, uint32_t result)
-{
- return send_pkt(client, tag, MESSAGE_RESULT, &result, sizeof(uint32_t));
-}
-
-int client_notify_connect(struct mux_client *client, enum usbmuxd_result result)
-{
- usbmuxd_log(LL_SPEW, "client_notify_connect fd %d result %d", client->fd, result);
- if(client->state == CLIENT_DEAD)
- return -1;
- if(client->state != CLIENT_CONNECTING1) {
- usbmuxd_log(LL_ERROR, "client_notify_connect when client %d is not in CONNECTING1 state", client->fd);
- return -1;
- }
- if(send_result(client, client->connect_tag, result) < 0)
- return -1;
- if(result == RESULT_OK) {
- client->state = CLIENT_CONNECTING2;
- client->events = POLLOUT; // wait for the result packet to go through
- // no longer need this
- free(client->ib_buf);
- client->ib_buf = NULL;
- } else {
- client->state = CLIENT_COMMAND;
- }
- return 0;
-}
-
-static int notify_device(struct mux_client *client, struct device_info *dev)
-{
- struct usbmuxd_device_record dmsg;
- memset(&dmsg, 0, sizeof(dmsg));
- dmsg.device_id = dev->id;
- strncpy(dmsg.serial_number, dev->serial, 256);
- dmsg.serial_number[255] = 0;
- dmsg.location = dev->location;
- dmsg.product_id = dev->pid;
- return send_pkt(client, 0, MESSAGE_DEVICE_ADD, &dmsg, sizeof(dmsg));
-}
-
-static int start_listen(struct mux_client *client)
-{
- struct device_info *devs;
- struct device_info *dev;
- int count, i;
-
- client->state = CLIENT_LISTEN;
- count = device_get_count();
- if(!count)
- return 0;
- devs = malloc(sizeof(struct device_info) * count);
- count = device_get_list(devs);
-
- // going to need a larger buffer for many devices
- int needed_buffer = count * (sizeof(struct usbmuxd_device_record) + sizeof(struct usbmuxd_header)) + REPLY_BUF_SIZE;
- if(client->ob_capacity < needed_buffer) {
- usbmuxd_log(LL_DEBUG, "Enlarging client %d reply buffer %d -> %d to make space for device notifications", client->fd, client->ob_capacity, needed_buffer);
- client->ob_buf = realloc(client->ob_buf, needed_buffer);
- client->ob_capacity = needed_buffer;
- }
- dev = devs;
- for(i=0; i<count; i++) {
- if(notify_device(client, dev++) < 0) {
- free(devs);
- return -1;
- }
- }
- free(devs);
- return count;
-}
-
-static int client_command(struct mux_client *client, struct usbmuxd_header *hdr, const char *payload)
-{
- int res;
- usbmuxd_log(LL_DEBUG, "Client command in fd %d len %d ver %d msg %d tag %d", client->fd, hdr->length, hdr->version, hdr->message, hdr->tag);
-
- if(client->state != CLIENT_COMMAND) {
- usbmuxd_log(LL_ERROR, "Client %d command received in the wrong state", client->fd);
- if(send_result(client, hdr->tag, RESULT_BADCOMMAND) < 0)
- return -1;
- client_close(client);
- return -1;
- }
-
- struct usbmuxd_connect_request *ch;
- switch(hdr->message) {
- case MESSAGE_LISTEN:
- if(send_result(client, hdr->tag, 0) < 0)
- return -1;
- usbmuxd_log(LL_DEBUG, "Client %d now LISTENING", client->fd);
- return start_listen(client);
- case MESSAGE_CONNECT:
- ch = (void*)payload;
- usbmuxd_log(LL_DEBUG, "Client %d connection request to device %d port %d", client->fd, ch->device_id, ntohs(ch->port));
- res = device_start_connect(ch->device_id, ntohs(ch->port), client);
- if(res < 0) {
- if(send_result(client, hdr->tag, -res) < 0)
- return -1;
- } else {
- client->connect_tag = hdr->tag;
- client->connect_device = ch->device_id;
- client->state = CLIENT_CONNECTING1;
- }
- return 0;
- default:
- usbmuxd_log(LL_ERROR, "Client %d invalid command %d", client->fd, hdr->message);
- if(send_result(client, hdr->tag, RESULT_BADCOMMAND) < 0)
- return -1;
- return 0;
- }
- return -1;
-}
-
-static void process_send(struct mux_client *client)
-{
- int res;
- if(!client->ob_size) {
- usbmuxd_log(LL_WARNING, "Client %d OUT process but nothing to send?", client->fd);
- client->events &= ~POLLOUT;
- return;
- }
- res = send(client->fd, client->ob_buf, client->ob_size, 0);
- if(res <= 0) {
- usbmuxd_log(LL_ERROR, "Send to client fd %d failed: %d %s", client->fd, res, strerror(errno));
- client_close(client);
- return;
- }
- if(res == client->ob_size) {
- client->ob_size = 0;
- client->events &= ~POLLOUT;
- if(client->state == CLIENT_CONNECTING2) {
- usbmuxd_log(LL_DEBUG, "Client %d switching to CONNECTED state", client->fd);
- client->state = CLIENT_CONNECTED;
- client->events = client->devents;
- // no longer need this
- free(client->ob_buf);
- client->ob_buf = NULL;
- }
- } else {
- client->ob_size -= res;
- memmove(client->ob_buf, client->ob_buf + res, client->ob_size);
- }
-}
-static void process_recv(struct mux_client *client)
-{
- int res;
- int did_read = 0;
- if(client->ib_size < sizeof(struct usbmuxd_header)) {
- res = recv(client->fd, client->ib_buf + client->ib_size, sizeof(struct usbmuxd_header) - client->ib_size, 0);
- if(res <= 0) {
- if(res < 0)
- usbmuxd_log(LL_ERROR, "Receive from client fd %d failed: %s", client->fd, strerror(errno));
- else
- usbmuxd_log(LL_INFO, "Client %d connection closed", client->fd);
- client_close(client);
- return;
- }
- client->ib_size += res;
- if(client->ib_size < sizeof(struct usbmuxd_header))
- return;
- did_read = 1;
- }
- struct usbmuxd_header *hdr = (void*)client->ib_buf;
- if(hdr->version != USBMUXD_PROTOCOL_VERSION) {
- usbmuxd_log(LL_INFO, "Client %d version mismatch: expected %d, got %d", client->fd, USBMUXD_PROTOCOL_VERSION, hdr->version);
- client_close(client);
- }
- if(hdr->length > client->ib_capacity) {
- usbmuxd_log(LL_INFO, "Client %d message is too long (%d bytes)", client->fd, hdr->length);
- client_close(client);
- }
- if(hdr->length < sizeof(struct usbmuxd_header)) {
- usbmuxd_log(LL_ERROR, "Client %d message is too short (%d bytes)", client->fd, hdr->length);
- client_close(client);
- }
- if(client->ib_size < hdr->length) {
- if(did_read)
- return; //maybe we would block, so defer to next loop
- res = recv(client->fd, client->ib_buf + client->ib_size, hdr->length - client->ib_size, 0);
- if(res < 0) {
- usbmuxd_log(LL_ERROR, "Receive from client fd %d failed: %s", client->fd, strerror(errno));
- client_close(client);
- return;
- } else if(res == 0) {
- usbmuxd_log(LL_INFO, "Client %d connection closed", client->fd);
- client_close(client);
- return;
- }
- client->ib_size += res;
- if(client->ib_size < hdr->length)
- return;
- }
- client_command(client, hdr, (char *)(hdr+1));
- client->ib_size = 0;
-}
-
-void client_process(int fd, short events)
-{
- struct mux_client *client = NULL;
- FOREACH(struct mux_client *lc, &client_list) {
- if(lc->fd == fd) {
- client = lc;
- break;
- }
- } ENDFOREACH
-
- if(!client) {
- usbmuxd_log(LL_ERROR, "client_process: fd %d not found in client list", fd);
- return;
- }
-
- if(client->state == CLIENT_CONNECTED) {
- usbmuxd_log(LL_SPEW, "client_process in CONNECTED state");
- device_client_process(client->connect_device, client, events);
- } else {
- if(events & POLLIN) {
- process_recv(client);
- } else if(events & POLLOUT) { //not both in case client died as part of process_recv
- process_send(client);
- }
- }
-
-}
-
-void client_device_add(struct device_info *dev)
-{
- usbmuxd_log(LL_DEBUG, "client_device_add: id %d, location 0x%x, serial %s", dev->id, dev->location, dev->serial);
- FOREACH(struct mux_client *client, &client_list) {
- if(client->state == CLIENT_LISTEN)
- notify_device(client, dev);
- } ENDFOREACH
-}
-void client_device_remove(int device_id)
-{
- uint32_t id = device_id;
- usbmuxd_log(LL_DEBUG, "client_device_remove: id %d", device_id);
- FOREACH(struct mux_client *client, &client_list) {
- if(client->state == CLIENT_LISTEN)
- send_pkt(client, 0, MESSAGE_DEVICE_REMOVE, &id, sizeof(uint32_t));
- } ENDFOREACH
-}
-
-
-void client_init(void)
-{
- usbmuxd_log(LL_DEBUG, "client_init");
- collection_init(&client_list);
-}
-
-void client_shutdown(void)
-{
- usbmuxd_log(LL_DEBUG, "client_shutdown");
- FOREACH(struct mux_client *client, &client_list) {
- client_close(client);
- } ENDFOREACH
- collection_free(&client_list);
-}
diff --git a/usbmuxd/client.h b/usbmuxd/client.h
deleted file mode 100644
index 4fc1ab4..0000000
--- a/usbmuxd/client.h
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- usbmuxd - iPhone/iPod Touch USB multiplex server daemon
-
-Copyright (C) 2009 Hector Martin "marcan" <hector@marcansoft.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 2 or version 3.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-
-*/
-
-#ifndef __CLIENT_H__
-#define __CLIENT_H__
-
-#include <stdint.h>
-#include "usbmuxd-proto.h"
-
-struct device_info;
-struct mux_client;
-
-int client_read(struct mux_client *client, void *buffer, int len);
-int client_write(struct mux_client *client, void *buffer, int len);
-int client_set_events(struct mux_client *client, short events);
-void client_close(struct mux_client *client);
-int client_notify_connect(struct mux_client *client, enum usbmuxd_result result);
-
-void client_device_add(struct device_info *dev);
-void client_device_remove(int device_id);
-
-int client_accept(int fd);
-void client_get_fds(struct fdlist *list);
-void client_process(int fd, short events);
-
-void client_init(void);
-void client_shutdown(void);
-
-#endif
diff --git a/usbmuxd/device.c b/usbmuxd/device.c
deleted file mode 100644
index 3a5883c..0000000
--- a/usbmuxd/device.c
+++ /dev/null
@@ -1,751 +0,0 @@
-/*
- usbmuxd - iPhone/iPod Touch USB multiplex server daemon
-
-Copyright (C) 2009 Hector Martin "marcan" <hector@marcansoft.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 2 or version 3.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-
-*/
-
-#define _BSD_SOURCE
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include <sys/time.h>
-#include <netinet/in.h>
-#include <netinet/tcp.h>
-#include <stdlib.h>
-#include <string.h>
-#include <stdint.h>
-#include <inttypes.h>
-#include "device.h"
-#include "client.h"
-#include "usb.h"
-#include "log.h"
-
-int next_device_id;
-
-#define DEV_PKTBUF_SIZE 65536
-
-#define CONN_INBUF_SIZE 262144
-#define CONN_OUTBUF_SIZE 65536
-
-#define ACK_TIMEOUT 30
-
-enum mux_protocol {
- MUX_PROTO_VERSION = 0,
- MUX_PROTO_TCP = IPPROTO_TCP,
-};
-
-enum mux_dev_state {
- MUXDEV_INIT, // sent version packet
- MUXDEV_ACTIVE, // received version packet, active
- MUXDEV_DEAD // dead
-};
-
-enum mux_conn_state {
- CONN_CONNECTING, // SYN
- CONN_CONNECTED, // SYN/SYNACK/ACK -> active
- CONN_REFUSED, // RST received during SYN
- CONN_DYING, // RST received
- CONN_DEAD // being freed; used to prevent infinite recursion between client<->device freeing
-};
-
-struct mux_header
-{
- uint32_t protocol;
- uint32_t length;
-};
-
-struct version_header
-{
- uint32_t major;
- uint32_t minor;
- uint32_t padding;
-};
-
-struct mux_device;
-
-#define CONN_ACK_PENDING 1
-
-struct mux_connection
-{
- struct mux_device *dev;
- struct mux_client *client;
- enum mux_conn_state state;
- uint16_t sport, dport;
- uint32_t tx_seq, tx_ack, tx_acked, tx_win;
- uint32_t rx_seq, rx_recvd, rx_ack, rx_win;
- int max_payload;
- int sendable;
- int flags;
- unsigned char *ib_buf;
- int ib_size;
- int ib_capacity;
- unsigned char *ob_buf;
- int ob_capacity;
- short events;
- uint64_t last_ack_time;
-};
-
-struct mux_device
-{
- struct usb_device *usbdev;
- int id;
- enum mux_dev_state state;
- struct collection connections;
- uint16_t next_sport;
- unsigned char *pktbuf;
- int pktlen;
-};
-
-static struct collection device_list;
-
-uint64_t mstime64(void)
-{
- struct timeval tv;
- gettimeofday(&tv, NULL);
- return tv.tv_sec * 1000 + tv.tv_usec / 1000;
-}
-
-static int get_next_device_id(void)
-{
- while(1) {
- int ok = 1;
- FOREACH(struct mux_device *dev, &device_list) {
- if(dev->id == next_device_id) {
- next_device_id++;
- ok = 0;
- break;
- }
- } ENDFOREACH
- if(ok)
- return next_device_id++;
- }
-}
-
-static int send_packet(struct mux_device *dev, enum mux_protocol proto, void *header, const void *data, int length)
-{
- unsigned char *buffer;
- int hdrlen;
- int res;
-
- switch(proto) {
- case MUX_PROTO_VERSION:
- hdrlen = sizeof(struct version_header);
- break;
- case MUX_PROTO_TCP:
- hdrlen = sizeof(struct tcphdr);
- break;
- default:
- usbmuxd_log(LL_ERROR, "Invalid protocol %d for outgoing packet (dev %d hdr %p data %p len %d)", proto, dev->id, header, data, length);
- return -1;
- }
- usbmuxd_log(LL_SPEW, "send_packet(%d, 0x%x, %p, %p, %d)", dev->id, proto, header, data, length);
-
- int total = sizeof(struct mux_header) + hdrlen + length;
-
- if(total > USB_MTU) {
- usbmuxd_log(LL_ERROR, "Tried to send packet larger than USB MTU (hdr %d data %d total %d) to device %d", hdrlen, length, total, dev->id);
- return -1;
- }
-
- buffer = malloc(total);
- struct mux_header *mhdr = (struct mux_header *)buffer;
- mhdr->protocol = htonl(proto);
- mhdr->length = htonl(total);;
- memcpy(buffer + sizeof(struct mux_header), header, hdrlen);
- if(data && length)
- memcpy(buffer + sizeof(struct mux_header) + hdrlen, data, length);
-
- if((res = usb_send(dev->usbdev, buffer, total)) < 0) {
- usbmuxd_log(LL_ERROR, "usb_send failed while sending packet (len %d) to device %d: %d", total, dev->id, res);
- free(buffer);
- return res;
- }
- return total;
-}
-
-static uint16_t find_sport(struct mux_device *dev)
-{
- if(collection_count(&dev->connections) >= 65535)
- return 0; //insanity
-
- while(1) {
- int ok = 1;
- FOREACH(struct mux_connection *conn, &dev->connections) {
- if(dev->next_sport == conn->sport) {
- dev->next_sport++;
- ok = 0;
- break;
- }
- } ENDFOREACH
- if(ok)
- return dev->next_sport++;
- }
-}
-
-static int send_anon_rst(struct mux_device *dev, uint16_t sport, uint16_t dport, uint32_t ack)
-{
- struct tcphdr th;
- memset(&th, 0, sizeof(th));
- th.th_sport = htons(sport);
- th.th_dport = htons(dport);
- th.th_ack = htonl(ack);
- th.th_flags = TH_RST;
- th.th_off = sizeof(th) / 4;
-
- usbmuxd_log(LL_DEBUG, "[OUT] dev=%d sport=%d dport=%d flags=0x%x", dev->id, sport, dport, th.th_flags);
-
- int res = send_packet(dev, MUX_PROTO_TCP, &th, NULL, 0);
- return res;
-}
-
-static int send_tcp(struct mux_connection *conn, uint8_t flags, const unsigned char *data, int length)
-{
- struct tcphdr th;
- memset(&th, 0, sizeof(th));
- th.th_sport = htons(conn->sport);
- th.th_dport = htons(conn->dport);
- th.th_seq = htonl(conn->tx_seq);
- th.th_ack = htonl(conn->tx_ack);
- th.th_flags = flags;
- th.th_off = sizeof(th) / 4;
- th.th_win = htons(conn->tx_win >> 8);
-
- usbmuxd_log(LL_DEBUG, "[OUT] dev=%d sport=%d dport=%d seq=%d ack=%d flags=0x%x window=%d[%d] len=%d",
- conn->dev->id, conn->sport, conn->dport, conn->tx_seq, conn->tx_ack, flags, conn->tx_win, conn->tx_win >> 8, length);
-
- int res = send_packet(conn->dev, MUX_PROTO_TCP, &th, data, length);
- if(res >= 0) {
- conn->tx_acked = conn->tx_ack;
- conn->last_ack_time = mstime64();
- conn->flags &= ~CONN_ACK_PENDING;
- }
- return res;
-}
-
-static void connection_teardown(struct mux_connection *conn)
-{
- int res;
- if(conn->state == CONN_DEAD)
- return;
- usbmuxd_log(LL_DEBUG, "connection_teardown dev %d sport %d dport %d", conn->dev->id, conn->sport, conn->dport);
- if(conn->dev->state != MUXDEV_DEAD && conn->state != CONN_DYING && conn->state != CONN_REFUSED) {
- res = send_tcp(conn, TH_RST, NULL, 0);
- if(res < 0)
- usbmuxd_log(LL_ERROR, "Error sending TCP RST to device %d (%d->%d)", conn->dev->id, conn->sport, conn->dport);
- }
- if(conn->client) {
- if(conn->state == CONN_REFUSED || conn->state == CONN_CONNECTING) {
- client_notify_connect(conn->client, RESULT_CONNREFUSED);
- } else {
- conn->state = CONN_DEAD;
- client_close(conn->client);
- }
- }
- if(conn->ib_buf)
- free(conn->ib_buf);
- if(conn->ob_buf)
- free(conn->ob_buf);
- collection_remove(&conn->dev->connections, conn);
- free(conn);
-}
-
-int device_start_connect(int device_id, uint16_t dport, struct mux_client *client)
-{
- struct mux_device *dev = NULL;
- FOREACH(struct mux_device *cdev, &device_list) {
- if(cdev->id == device_id) {
- dev = cdev;
- break;
- }
- } ENDFOREACH
- if(!dev) {
- usbmuxd_log(LL_WARNING, "Attempted to connect to nonexistent device %d", device_id);
- return -RESULT_BADDEV;
- }
-
- uint16_t sport = find_sport(dev);
- if(!sport) {
- usbmuxd_log(LL_WARNING, "Unable to allocate port for device %d", device_id);
- return -RESULT_BADDEV;
- }
-
- struct mux_connection *conn;
- conn = malloc(sizeof(struct mux_connection));
- memset(conn, 0, sizeof(struct mux_connection));
-
- conn->dev = dev;
- conn->client = client;
- conn->state = CONN_CONNECTING;
- conn->sport = sport;
- conn->dport = dport;
- conn->tx_seq = 0;
- conn->tx_ack = 0;
- conn->tx_acked = 0;
- conn->tx_win = 131072;
- conn->rx_recvd = 0;
- conn->flags = 0;
- conn->max_payload = USB_MTU - sizeof(struct mux_header) - sizeof(struct tcphdr);
-
- conn->ob_buf = malloc(CONN_OUTBUF_SIZE);
- conn->ob_capacity = CONN_OUTBUF_SIZE;
- conn->ib_buf = malloc(CONN_INBUF_SIZE);
- conn->ib_capacity = CONN_INBUF_SIZE;
- conn->ib_size = 0;
-
- int res;
-
- res = send_tcp(conn, TH_SYN, NULL, 0);
- if(res < 0) {
- usbmuxd_log(LL_ERROR, "Error sending TCP SYN to device %d (%d->%d)", dev->id, sport, dport);
- free(conn);
- return -RESULT_CONNREFUSED; //bleh
- }
- collection_add(&dev->connections, conn);
- return 0;
-}
-
-static void update_connection(struct mux_connection *conn)
-{
- conn->sendable = conn->rx_win - (conn->tx_seq - conn->rx_ack);
-
- if(conn->sendable > conn->ob_capacity)
- conn->sendable = conn->ob_capacity;
- if(conn->sendable > conn->max_payload)
- conn->sendable = conn->max_payload;
-
- if(conn->sendable > 0)
- conn->events |= POLLIN;
- else
- conn->events &= ~POLLIN;
-
- if(conn->ib_size)
- conn->events |= POLLOUT;
- else
- conn->events &= ~POLLOUT;
-
- if(conn->tx_acked != conn->tx_ack)
- conn->flags |= CONN_ACK_PENDING;
- else
- conn->flags &= ~CONN_ACK_PENDING;
-
- usbmuxd_log(LL_SPEW, "update_connection: sendable %d, events %d, flags %d", conn->sendable, conn->events, conn->flags);
- client_set_events(conn->client, conn->events);
-}
-
-void device_client_process(int device_id, struct mux_client *client, short events)
-{
- struct mux_connection *conn = NULL;
- FOREACH(struct mux_device *dev, &device_list) {
- if(dev->id == device_id) {
- FOREACH(struct mux_connection *lconn, &dev->connections) {
- if(lconn->client == client) {
- conn = lconn;
- break;
- }
- } ENDFOREACH
- break;
- }
- } ENDFOREACH
-
- if(!conn) {
- usbmuxd_log(LL_WARNING, "Could not find connection for device %d client %p", device_id, client);
- return;
- }
- usbmuxd_log(LL_SPEW, "device_client_process (%d)", events);
-
- int res;
- int size;
- if(events & POLLOUT) {
- size = client_write(conn->client, conn->ib_buf, conn->ib_size);
- if(size <= 0) {
- usbmuxd_log(LL_DEBUG, "error writing to client (%d)", size);
- connection_teardown(conn);
- return;
- }
- conn->tx_ack += size;
- if(size == conn->ib_size) {
- conn->ib_size = 0;
- } else {
- conn->ib_size -= size;
- memmove(conn->ib_buf, conn->ib_buf + size, conn->ib_size);
- }
- }
- if(events & POLLIN) {
- size = client_read(conn->client, conn->ob_buf, conn->sendable);
- if(size <= 0) {
- usbmuxd_log(LL_DEBUG, "error reading from client (%d)", size);
- connection_teardown(conn);
- return;
- }
- res = send_tcp(conn, TH_ACK, conn->ob_buf, size);
- if(res < 0) {
- connection_teardown(conn);
- return;
- }
- conn->tx_seq += size;
- }
-
- update_connection(conn);
-}
-
-static void connection_device_input(struct mux_connection *conn, unsigned char *payload, int payload_length)
-{
- if((conn->ib_size + payload_length) > conn->ib_capacity) {
- usbmuxd_log(LL_ERROR, "Input buffer overflow on device %d connection %d->%d (space=%d, payload=%d)", conn->dev->id, conn->sport, conn->dport, conn->ib_capacity-conn->ib_size, payload_length);
- connection_teardown(conn);
- return;
- }
- memcpy(conn->ib_buf + conn->ib_size, payload, payload_length);
- conn->ib_size += payload_length;
- conn->rx_recvd += payload_length;
- update_connection(conn);
-}
-
-void device_abort_connect(int device_id, struct mux_client *client)
-{
- FOREACH(struct mux_device *dev, &device_list) {
- if(dev->id == device_id) {
- FOREACH(struct mux_connection *conn, &dev->connections) {
- if(conn->client == client) {
- connection_teardown(conn);
- return;
- }
- } ENDFOREACH
- usbmuxd_log(LL_WARNING, "Attempted to abort for nonexistent connection for device %d", device_id);
- return;
- }
- } ENDFOREACH
- usbmuxd_log(LL_WARNING, "Attempted to abort connection for nonexistent device %d", device_id);
-}
-
-static void device_version_input(struct mux_device *dev, struct version_header *vh)
-{
- if(dev->state != MUXDEV_INIT) {
- usbmuxd_log(LL_WARNING, "Version packet from already initialized device %d", dev->id);
- return;
- }
- vh->major = ntohl(vh->major);
- vh->minor = ntohl(vh->minor);
- if(vh->major != 1 || vh->minor != 0) {
- usbmuxd_log(LL_ERROR, "Device %d has unknown version %d.%d\n", dev->id, vh->major, vh->minor);
- collection_remove(&device_list, dev);
- free(dev);
- return;
- }
- usbmuxd_log(LL_NOTICE, "Connected to v%d.%d device %d on location 0x%x with serial number %s", vh->major, vh->minor, dev->id, usb_get_location(dev->usbdev), usb_get_serial(dev->usbdev));
- dev->state = MUXDEV_ACTIVE;
- collection_init(&dev->connections);
- struct device_info info;
- info.id = dev->id;
- info.location = usb_get_location(dev->usbdev);
- info.serial = usb_get_serial(dev->usbdev);
- info.pid = usb_get_pid(dev->usbdev);
- client_device_add(&info);
-}
-
-static void device_tcp_input(struct mux_device *dev, struct tcphdr *th, unsigned char *payload, int payload_length)
-{
- usbmuxd_log(LL_DEBUG, "[IN] dev=%d sport=%d dport=%d seq=%d ack=%d flags=0x%x window=%d[%d] len=%d",
- dev->id, ntohs(th->th_sport), ntohs(th->th_dport), ntohl(th->th_seq), ntohl(th->th_ack), th->th_flags, ntohs(th->th_win) << 8, ntohs(th->th_win), payload_length);
-
- uint16_t sport = ntohs(th->th_dport);
- uint16_t dport = ntohs(th->th_sport);
- struct mux_connection *conn = NULL;
- FOREACH(struct mux_connection *lconn, &dev->connections) {
- if(lconn->sport == sport && lconn->dport == dport) {
- conn = lconn;
- break;
- }
- } ENDFOREACH
-
- if(!conn) {
- usbmuxd_log(LL_WARNING, "No connection for device %d incoming packet %d->%d", dev->id, dport, sport);
- if(!(th->th_flags & TH_RST)) {
- if(send_anon_rst(dev, sport, dport, ntohl(th->th_seq)) < 0)
- usbmuxd_log(LL_ERROR, "Error sending TCP RST to device %d (%d->%d)", conn->dev->id, sport, dport);
- }
- return;
- }
-
- conn->rx_seq = ntohl(th->th_seq);
- conn->rx_ack = ntohl(th->th_ack);
- conn->rx_win = ntohs(th->th_win) << 8;
-
- if(th->th_flags & TH_RST) {
- char *buf = malloc(payload_length+1);
- memcpy(buf, payload, payload_length);
- if(payload_length && (buf[payload_length-1] == '\n'))
- buf[payload_length-1] = 0;
- buf[payload_length] = 0;
- usbmuxd_log(LL_DEBUG, "RST reason: %s", buf);
- free(buf);
- }
-
- if(conn->state == CONN_CONNECTING) {
- if(th->th_flags != (TH_SYN|TH_ACK)) {
- if(th->th_flags & TH_RST)
- conn->state = CONN_REFUSED;
- usbmuxd_log(LL_INFO, "Connection refused by device %d (%d->%d)", dev->id, sport, dport);
- connection_teardown(conn); //this also sends the notification to the client
- } else {
- conn->tx_seq++;
- conn->tx_ack++;
- conn->rx_recvd = conn->rx_seq;
- if(send_tcp(conn, TH_ACK, NULL, 0) < 0) {
- usbmuxd_log(LL_ERROR, "Error sending TCP ACK to device %d (%d->%d)", dev->id, sport, dport);
- connection_teardown(conn);
- return;
- }
- conn->state = CONN_CONNECTED;
- if(client_notify_connect(conn->client, RESULT_OK) < 0) {
- conn->client = NULL;
- connection_teardown(conn);
- }
- update_connection(conn);
- }
- } else if(conn->state == CONN_CONNECTED) {
- if(th->th_flags != TH_ACK) {
- usbmuxd_log(LL_INFO, "Connection reset by device %d (%d->%d)", dev->id, sport, dport);
- if(th->th_flags & TH_RST)
- conn->state = CONN_DYING;
- connection_teardown(conn);
- } else {
- connection_device_input(conn, payload, payload_length);
- }
- }
-}
-
-void device_data_input(struct usb_device *usbdev, unsigned char *buffer, int length)
-{
- struct mux_device *dev = NULL;
- FOREACH(struct mux_device *tdev, &device_list) {
- if(tdev->usbdev == usbdev) {
- dev = tdev;
- break;
- }
- } ENDFOREACH
- if(!dev) {
- usbmuxd_log(LL_WARNING, "Cannot find device entry for RX input from USB device %p on location 0x%x", usbdev, usb_get_location(usbdev));
- return;
- }
-
- if(!length)
- return;
-
- usbmuxd_log(LL_SPEW, "Mux data input for device %p: %p len %d", dev, buffer, length);
-
- // handle broken up transfers
- if(dev->pktlen) {
- memcpy(dev->pktbuf + dev->pktlen, buffer, length);
- struct mux_header *mhdr = (struct mux_header *)dev->pktbuf;
- if((length < USB_MRU) || (ntohl(mhdr->length) == length)) {
- buffer = dev->pktbuf;
- length += dev->pktlen;
- dev->pktlen = 0;
- usbmuxd_log(LL_SPEW, "Gathered mux data from buffer (total size: %d)", length);
- } else {
- dev->pktlen += length;
- usbmuxd_log(LL_SPEW, "Appended mux data to buffer (total size: %d)", dev->pktlen);
- return;
- }
- } else {
- struct mux_header *mhdr = (struct mux_header *)buffer;
- if((length == USB_MRU) && (length < ntohl(mhdr->length))) {
- memcpy(dev->pktbuf, buffer, length);
- dev->pktlen = length;
- usbmuxd_log(LL_SPEW, "Copied mux data to buffer (size: %d)", dev->pktlen);
- return;
- }
- }
-
- struct mux_header *mhdr = (struct mux_header *)buffer;
-
- if(ntohl(mhdr->length) != length) {
- usbmuxd_log(LL_ERROR, "Incoming packet size mismatch (dev %d, expected %d, got %d)", dev->id, ntohl(mhdr->length), length);
- return;
- }
-
- struct tcphdr *th;
- unsigned char *payload;
- int payload_length;
-
- switch(ntohl(mhdr->protocol)) {
- case MUX_PROTO_VERSION:
- device_version_input(dev, (struct version_header *)(mhdr+1));
- break;
- case MUX_PROTO_TCP:
- th = (struct tcphdr *)(mhdr+1);
- payload = (unsigned char *)(th+1);
- payload_length = length - sizeof(struct tcphdr) - sizeof(struct mux_header);
- device_tcp_input(dev, (struct tcphdr *)(mhdr+1), payload, payload_length);
- break;
- default:
- usbmuxd_log(LL_ERROR, "Incoming packet for device %d has unknown protocol 0x%x)", dev->id, ntohl(mhdr->protocol));
- break;
- }
-
-}
-
-int device_add(struct usb_device *usbdev)
-{
- int res;
- int id = get_next_device_id();
- struct mux_device *dev;
- usbmuxd_log(LL_NOTICE, "Connecting to new device on location 0x%x as ID %d", usb_get_location(usbdev), id);
- dev = malloc(sizeof(struct mux_device));
- dev->id = id;
- dev->usbdev = usbdev;
- dev->state = MUXDEV_INIT;
- dev->next_sport = 1;
- dev->pktbuf = malloc(DEV_PKTBUF_SIZE);
- dev->pktlen = 0;
- struct version_header vh;
- vh.major = htonl(1);
- vh.minor = htonl(0);
- vh.padding = 0;
- if((res = send_packet(dev, MUX_PROTO_VERSION, &vh, NULL, 0)) < 0) {
- usbmuxd_log(LL_ERROR, "Error sending version request packet to device %d\n", id);
- free(dev);
- return res;
- }
- collection_add(&device_list, dev);
- return 0;
-}
-
-void device_remove(struct usb_device *usbdev)
-{
- FOREACH(struct mux_device *dev, &device_list) {
- if(dev->usbdev == usbdev) {
- usbmuxd_log(LL_NOTICE, "Removed device %d on location 0x%x", dev->id, usb_get_location(usbdev));
- if(dev->state == MUXDEV_ACTIVE) {
- dev->state = MUXDEV_DEAD;
- FOREACH(struct mux_connection *conn, &dev->connections) {
- connection_teardown(conn);
- } ENDFOREACH
- client_device_remove(dev->id);
- collection_free(&dev->connections);
- }
- collection_remove(&device_list, dev);
- free(dev->pktbuf);
- free(dev);
- return;
- }
- } ENDFOREACH
- usbmuxd_log(LL_WARNING, "Cannot find device entry while removing USB device %p on location 0x%x", usbdev, usb_get_location(usbdev));
-}
-
-int device_get_count(void)
-{
- int count = 0;
- FOREACH(struct mux_device *dev, &device_list) {
- if(dev->state == MUXDEV_ACTIVE)
- count++;
- } ENDFOREACH
- return count;
-}
-
-int device_get_list(struct device_info *p)
-{
- int count = 0;
- FOREACH(struct mux_device *dev, &device_list) {
- if(dev->state == MUXDEV_ACTIVE) {
- p->id = dev->id;
- p->serial = usb_get_serial(dev->usbdev);
- p->location = usb_get_location(dev->usbdev);
- p->pid = usb_get_pid(dev->usbdev);
- count++;
- p++;
- }
- } ENDFOREACH
- return count;
-}
-
-int device_get_timeout(void)
-{
- uint64_t oldest = (uint64_t)-1;
- FOREACH(struct mux_device *dev, &device_list) {
- if(dev->state == MUXDEV_ACTIVE) {
- FOREACH(struct mux_connection *conn, &dev->connections) {
- if((conn->state == CONN_CONNECTED) && (conn->flags & CONN_ACK_PENDING) && conn->last_ack_time < oldest)
- oldest = conn->last_ack_time;
- } ENDFOREACH
- }
- } ENDFOREACH
- uint64_t ct = mstime64();
- if(oldest == -1)
- return 100000; //meh
- if((ct - oldest) > ACK_TIMEOUT)
- return 0;
- return ACK_TIMEOUT - (ct - oldest);
-}
-
-void device_check_timeouts(void)
-{
- uint64_t ct = mstime64();
- FOREACH(struct mux_device *dev, &device_list) {
- if(dev->state == MUXDEV_ACTIVE) {
- FOREACH(struct mux_connection *conn, &dev->connections) {
- if((conn->state == CONN_CONNECTED) &&
- (conn->flags & CONN_ACK_PENDING) &&
- (ct - conn->last_ack_time) > ACK_TIMEOUT) {
- usbmuxd_log(LL_DEBUG, "Sending ACK due to expired timeout (%" PRIu64 " -> %" PRIu64 ")", conn->last_ack_time, ct);
- if(send_tcp(conn, TH_ACK, NULL, 0) < 0) {
- usbmuxd_log(LL_ERROR, "Error sending TCP ACK to device %d (%d->%d)", dev->id, conn->sport, conn->dport);
- connection_teardown(conn);
- }
- }
- } ENDFOREACH
- }
- } ENDFOREACH
-}
-
-void device_init(void)
-{
- usbmuxd_log(LL_DEBUG, "device_init");
- collection_init(&device_list);
- next_device_id = 1;
-}
-
-void device_kill_connections(void)
-{
- usbmuxd_log(LL_DEBUG, "device_kill_connections");
- FOREACH(struct mux_device *dev, &device_list) {
- if(dev->state != MUXDEV_INIT) {
- FOREACH(struct mux_connection *conn, &dev->connections) {
- connection_teardown(conn);
- } ENDFOREACH
- }
- } ENDFOREACH
- // give USB a while to send the final connection RSTs and the like
- usb_process_timeout(100);
-}
-
-void device_shutdown(void)
-{
- usbmuxd_log(LL_DEBUG, "device_shutdown");
- FOREACH(struct mux_device *dev, &device_list) {
- FOREACH(struct mux_connection *conn, &dev->connections) {
- connection_teardown(conn);
- } ENDFOREACH
- collection_free(&dev->connections);
- collection_remove(&device_list, dev);
- free(dev);
- } ENDFOREACH
- collection_free(&device_list);
-}
diff --git a/usbmuxd/device.h b/usbmuxd/device.h
deleted file mode 100644
index ce6c50b..0000000
--- a/usbmuxd/device.h
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- usbmuxd - iPhone/iPod Touch USB multiplex server daemon
-
-Copyright (C) 2009 Hector Martin "marcan" <hector@marcansoft.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 2 or version 3.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-
-*/
-
-#ifndef __DEVICE_H__
-#define __DEVICE_H__
-
-#include "usb.h"
-#include "client.h"
-
-struct device_info {
- int id;
- const char *serial;
- uint32_t location;
- uint16_t pid;
-};
-
-void device_data_input(struct usb_device *dev, unsigned char *buf, int length);
-
-int device_add(struct usb_device *dev);
-void device_remove(struct usb_device *dev);
-
-int device_start_connect(int device_id, uint16_t port, struct mux_client *client);
-void device_client_process(int device_id, struct mux_client *client, short events);
-void device_abort_connect(int device_id, struct mux_client *client);
-
-int device_get_count(void);
-int device_get_list(struct device_info *p);
-
-int device_get_timeout(void);
-void device_check_timeouts(void);
-
-void device_init(void);
-void device_kill_connections(void);
-void device_shutdown(void);
-#endif
diff --git a/usbmuxd/log.c b/usbmuxd/log.c
deleted file mode 100644
index 2ccb3cc..0000000
--- a/usbmuxd/log.c
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
- usbmuxd - iPhone/iPod Touch USB multiplex server daemon
-
-Copyright (C) 2009 Hector Martin "marcan" <hector@marcansoft.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 2 or version 3.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-
-*/
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <stdarg.h>
-#include <time.h>
-#include <sys/time.h>
-#include <syslog.h>
-
-#include "log.h"
-
-int log_level = LL_WARNING;
-
-int log_syslog = 0;
-
-void log_enable_syslog()
-{
- if (!log_syslog) {
- openlog("usbmuxd", LOG_PID, 0);
- log_syslog = 1;
- }
-}
-
-void log_disable_syslog()
-{
- if (log_syslog) {
- closelog();
- }
-}
-
-static int level_to_syslog_level(int level)
-{
- int result = level + LOG_CRIT;
- if (result > LOG_DEBUG) {
- result = LOG_DEBUG;
- }
- return result;
-}
-
-void usbmuxd_log(enum loglevel level, const char *fmt, ...)
-{
- va_list ap;
- char *fs;
- struct timeval ts;
- struct tm *tp;
-
- gettimeofday(&ts, NULL);
- tp = localtime(&ts.tv_sec);
-
- if(level > log_level)
- return;
-
- fs = malloc(20 + strlen(fmt));
-
- if(log_syslog) {
- sprintf(fs, "[%d] %s\n", level, fmt);
- } else {
- strftime(fs, 10, "[%H:%M:%S", tp);
- sprintf(fs+9, ".%03d][%d] %s\n", (int)(ts.tv_usec / 1000), level, fmt);
- }
-
- va_start(ap, fmt);
- if (log_syslog) {
- vsyslog(level_to_syslog_level(level), fs, ap);
- } else {
- vfprintf(stderr, fs, ap);
- }
- va_end(ap);
-
- free(fs);
-}
diff --git a/usbmuxd/log.h b/usbmuxd/log.h
deleted file mode 100644
index 4a2ac2e..0000000
--- a/usbmuxd/log.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- usbmuxd - iPhone/iPod Touch USB multiplex server daemon
-
-Copyright (C) 2009 Hector Martin "marcan" <hector@marcansoft.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 2 or version 3.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-
-*/
-
-#ifndef __LOG_H__
-#define __LOG_H__
-
-enum loglevel {
- LL_FATAL = 0,
- LL_ERROR,
- LL_WARNING,
- LL_NOTICE,
- LL_INFO,
- LL_DEBUG,
- LL_SPEW,
- LL_FLOOD,
-};
-
-extern int log_level;
-
-void log_enable_syslog();
-void log_disable_syslog();
-
-void usbmuxd_log(enum loglevel level, const char *fmt, ...) __attribute__ ((format (printf, 2, 3)));
-
-
-#endif
diff --git a/usbmuxd/main.c b/usbmuxd/main.c
deleted file mode 100644
index dde99c2..0000000
--- a/usbmuxd/main.c
+++ /dev/null
@@ -1,548 +0,0 @@
-/*
- usbmuxd - iPhone/iPod Touch USB multiplex server daemon
-
-Copyright (C) 2009 Hector Martin "marcan" <hector@marcansoft.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 2 or version 3.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-
-*/
-
-#define _BSD_SOURCE
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include <stdio.h>
-#include <errno.h>
-#include <string.h>
-#include <stdlib.h>
-#include <signal.h>
-#include <unistd.h>
-#include <sys/socket.h>
-#include <sys/un.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <fcntl.h>
-#include <getopt.h>
-#include <pwd.h>
-#include <grp.h>
-
-#include "log.h"
-#include "usb.h"
-#include "device.h"
-#include "client.h"
-
-static const char *socket_path = "/var/run/usbmuxd";
-static const char *lockfile = "/var/run/usbmuxd.pid";
-
-int should_exit;
-
-static int verbose = 0;
-static int foreground = 0;
-static int drop_privileges = 0;
-static const char *drop_user = "usbmux";
-static int opt_udev = 0;
-static int opt_exit = 0;
-static int exit_signal = 0;
-static int daemon_pipe;
-
-static int report_to_parent = 0;
-
-int create_socket(void) {
- struct sockaddr_un bind_addr;
- int listenfd;
-
- if(unlink(socket_path) == -1 && errno != ENOENT) {
- usbmuxd_log(LL_FATAL, "unlink(%s) failed: %s", socket_path, strerror(errno));
- return -1;
- }
-
- listenfd = socket(AF_UNIX, SOCK_STREAM, 0);
- if (listenfd == -1) {
- usbmuxd_log(LL_FATAL, "socket() failed: %s", strerror(errno));
- return -1;
- }
-
- bzero(&bind_addr, sizeof(bind_addr));
- bind_addr.sun_family = AF_UNIX;
- strcpy(bind_addr.sun_path, socket_path);
- if (bind(listenfd, (struct sockaddr*)&bind_addr, sizeof(bind_addr)) != 0) {
- usbmuxd_log(LL_FATAL, "bind() failed: %s", strerror(errno));
- return -1;
- }
-
- // Start listening
- if (listen(listenfd, 5) != 0) {
- usbmuxd_log(LL_FATAL, "listen() failed: %s", strerror(errno));
- return -1;
- }
-
- chmod(socket_path, 0666);
-
- return listenfd;
-}
-
-void handle_signal(int sig)
-{
- if (sig != SIGUSR1) {
- usbmuxd_log(LL_NOTICE,"Caught signal %d, exiting", sig);
- should_exit = 1;
- } else {
- if(opt_udev) {
- usbmuxd_log(LL_INFO, "Caught SIGUSR1, checking if we can terminate (no more devices attached)...");
- if (device_get_count() > 0) {
- // we can't quit, there are still devices attached.
- usbmuxd_log(LL_NOTICE, "Refusing to terminate, there are still devices attached. Kill me with signal 15 (TERM) to force quit.");
- } else {
- // it's safe to quit
- should_exit = 1;
- }
- } else {
- usbmuxd_log(LL_INFO, "Caught SIGUSR1 but we weren't started in --udev mode, ignoring");
- }
- }
-}
-
-void set_signal_handlers(void)
-{
- struct sigaction sa;
- memset(&sa, 0, sizeof(struct sigaction));
- sa.sa_handler = handle_signal;
- sigaction(SIGINT, &sa, NULL);
- sigaction(SIGQUIT, &sa, NULL);
- sigaction(SIGTERM, &sa, NULL);
- sigaction(SIGUSR1, &sa, NULL);
-}
-
-int main_loop(int listenfd)
-{
- int to, cnt, i, dto;
- struct fdlist pollfds;
-
- while(!should_exit) {
- usbmuxd_log(LL_FLOOD, "main_loop iteration");
- to = usb_get_timeout();
- usbmuxd_log(LL_FLOOD, "USB timeout is %d ms", to);
- dto = device_get_timeout();
- usbmuxd_log(LL_FLOOD, "Device timeout is %d ms", to);
- if(dto < to)
- to = dto;
-
- fdlist_create(&pollfds);
- fdlist_add(&pollfds, FD_LISTEN, listenfd, POLLIN);
- usb_get_fds(&pollfds);
- client_get_fds(&pollfds);
- usbmuxd_log(LL_FLOOD, "fd count is %d", pollfds.count);
-
- cnt = poll(pollfds.fds, pollfds.count, to);
- usbmuxd_log(LL_FLOOD, "poll() returned %d", cnt);
-
- if(cnt == -1) {
- if(errno == EINTR && should_exit) {
- usbmuxd_log(LL_INFO, "event processing interrupted");
- fdlist_free(&pollfds);
- return 0;
- }
- } else if(cnt == 0) {
- if(usb_process() < 0) {
- usbmuxd_log(LL_FATAL, "usb_process() failed");
- fdlist_free(&pollfds);
- return -1;
- }
- device_check_timeouts();
- } else {
- int done_usb = 0;
- for(i=0; i<pollfds.count; i++) {
- if(pollfds.fds[i].revents) {
- if(!done_usb && pollfds.owners[i] == FD_USB) {
- if(usb_process() < 0) {
- usbmuxd_log(LL_FATAL, "usb_process() failed");
- fdlist_free(&pollfds);
- return -1;
- }
- done_usb = 1;
- }
- if(pollfds.owners[i] == FD_LISTEN) {
- if(client_accept(listenfd) < 0) {
- usbmuxd_log(LL_FATAL, "client_accept() failed");
- fdlist_free(&pollfds);
- return -1;
- }
- }
- if(pollfds.owners[i] == FD_CLIENT) {
- client_process(pollfds.fds[i].fd, pollfds.fds[i].revents);
- }
- }
- }
- }
- fdlist_free(&pollfds);
- }
- return 0;
-}
-
-/**
- * make this program run detached from the current console
- */
-static int daemonize(void)
-{
- pid_t pid;
- pid_t sid;
- int pfd[2];
- int res;
-
- // already a daemon
- if (getppid() == 1)
- return 0;
-
- if((res = pipe(pfd)) < 0) {
- usbmuxd_log(LL_FATAL, "pipe() failed.");
- return res;
- }
-
- pid = fork();
- if (pid < 0) {
- usbmuxd_log(LL_FATAL, "fork() failed.");
- return pid;
- }
-
- if (pid > 0) {
- // exit parent process
- int status;
- close(pfd[1]);
-
- if((res = read(pfd[0],&status,sizeof(int))) != sizeof(int)) {
- fprintf(stderr, "usbmuxd: ERROR: Failed to get init status from child, check syslog for messages.\n");
- exit(1);
- }
- if(status != 0)
- fprintf(stderr, "usbmuxd: ERROR: Child process exited with error %d, check syslog for messages.\n", status);
- exit(status);
- }
- // At this point we are executing as the child process
- // but we need to do one more fork
-
- daemon_pipe = pfd[1];
- close(pfd[0]);
- report_to_parent = 1;
-
- // Change the file mode mask
- umask(0);
-
- // Create a new SID for the child process
- sid = setsid();
- if (sid < 0) {
- usbmuxd_log(LL_FATAL, "setsid() failed.");
- return -1;
- }
-
- pid = fork();
- if (pid < 0) {
- usbmuxd_log(LL_FATAL, "fork() failed (second).");
- return pid;
- }
-
- if (pid > 0) {
- // exit parent process
- close(daemon_pipe);
- exit(0);
- }
-
- // Change the current working directory.
- if ((chdir("/")) < 0) {
- usbmuxd_log(LL_FATAL, "chdir() failed");
- return -2;
- }
- // Redirect standard files to /dev/null
- if (!freopen("/dev/null", "r", stdin)) {
- usbmuxd_log(LL_FATAL, "Redirection of stdin failed.");
- return -3;
- }
- if (!freopen("/dev/null", "w", stdout)) {
- usbmuxd_log(LL_FATAL, "Redirection of stdout failed.");
- return -3;
- }
-
- return 0;
-}
-
-static int notify_parent(int status)
-{
- int res;
-
- report_to_parent = 0;
- if ((res = write(daemon_pipe, &status, sizeof(int))) != sizeof(int)) {
- usbmuxd_log(LL_FATAL, "Could not notify parent!");
- if(res >= 0)
- return -2;
- else
- return res;
- }
- close(daemon_pipe);
- if (!freopen("/dev/null", "w", stderr)) {
- usbmuxd_log(LL_FATAL, "Redirection of stderr failed.");
- return -1;
- }
- return 0;
-}
-
-static void usage()
-{
- printf("usage: usbmuxd [options]\n");
- printf("\t-h|--help Print this message.\n");
- printf("\t-v|--verbose Be verbose (use twice or more to increase).\n");
- printf("\t-f|--foreground Do not daemonize (implies one -v).\n");
- printf("\t-U|--user[=USER] Change to this user after startup (needs usb privileges).\n");
- printf("\t If USER is not specified, defaults to usbmux.\n");
- printf("\t-u|--udev Run in udev operation mode.\n");
- printf("\t-x|--exit Tell a running instance to exit if there are no devices\n");
- printf("\t connected (must be in udev mode).\n");
- printf("\t-X|--force-exit Tell a running instance to exit, even if there are still\n");
- printf("\t devices connected (always works).\n");
- printf("\n");
-}
-
-static void parse_opts(int argc, char **argv)
-{
- static struct option longopts[] = {
- {"help", 0, NULL, 'h'},
- {"foreground", 0, NULL, 'f'},
- {"verbose", 0, NULL, 'v'},
- {"user", 2, NULL, 'U'},
- {"udev", 0, NULL, 'u'},
- {"exit", 0, NULL, 'x'},
- {"force-exit", 0, NULL, 'X'},
- {NULL, 0, NULL, 0}
- };
- int c;
-
- while (1) {
- c = getopt_long(argc, argv, "hfvuU::xX", longopts, (int *) 0);
- if (c == -1) {
- break;
- }
-
- switch (c) {
- case 'h':
- usage();
- exit(0);
- case 'f':
- foreground = 1;
- break;
- case 'v':
- ++verbose;
- break;
- case 'U':
- drop_privileges = 1;
- if(optarg)
- drop_user = optarg;
- break;
- case 'u':
- opt_udev = 1;
- break;
- case 'x':
- opt_exit = 1;
- exit_signal = SIGUSR1;
- break;
- case 'X':
- opt_exit = 1;
- exit_signal = SIGTERM;
- break;
- default:
- usage();
- exit(2);
- }
- }
-}
-
-int main(int argc, char *argv[])
-{
- int listenfd;
- int res = 0;
- int lfd;
- struct flock lock;
- char pids[10];
-
- parse_opts(argc, argv);
-
- argc -= optind;
- argv += optind;
-
- if (!foreground) {
- verbose += LL_WARNING;
- log_enable_syslog();
- } else {
- verbose += LL_NOTICE;
- }
-
- /* set log level to specified verbosity */
- log_level = verbose;
-
- usbmuxd_log(LL_NOTICE, "usbmux v0.1 starting up");
- should_exit = 0;
-
- set_signal_handlers();
-
- res = lfd = open(lockfile, O_WRONLY|O_CREAT, 0644);
- if(res == -1) {
- usbmuxd_log(LL_FATAL, "Could not open lockfile");
- goto terminate;
- }
- lock.l_type = F_WRLCK;
- lock.l_whence = SEEK_SET;
- lock.l_start = 0;
- lock.l_len = 0;
- fcntl(lfd, F_GETLK, &lock);
- close(lfd);
- if (lock.l_type != F_UNLCK) {
- if (opt_exit) {
- if (lock.l_pid && !kill(lock.l_pid, 0)) {
- usbmuxd_log(LL_NOTICE, "Sending signal %d to instance with pid %d", exit_signal, lock.l_pid);
- res = 0;
- if (kill(lock.l_pid, exit_signal) < 0) {
- usbmuxd_log(LL_FATAL, "Could not deliver signal %d to pid %d", exit_signal, lock.l_pid);
- res = -1;
- }
- goto terminate;
- } else {
- usbmuxd_log(LL_ERROR, "Could not determine pid of the other running instance!");
- res = -1;
- goto terminate;
- }
- } else {
- if (!opt_udev) {
- usbmuxd_log(LL_ERROR, "Another instance is already running (pid %d). exiting.", lock.l_pid);
- res = -1;
- } else {
- usbmuxd_log(LL_NOTICE, "Another instance is already running (pid %d). exiting.", lock.l_pid);
- res = 0;
- }
- goto terminate;
- }
- }
- unlink(lockfile);
-
- if (opt_exit) {
- usbmuxd_log(LL_NOTICE, "No running instance found, none killed. exiting.");
- goto terminate;
- }
-
- if (!foreground) {
- if ((res = daemonize()) < 0) {
- fprintf(stderr, "usbmuxd: FATAL: Could not daemonize!\n");
- usbmuxd_log(LL_FATAL, "Could not daemonize!");
- goto terminate;
- }
- }
-
- // now open the lockfile and place the lock
- res = lfd = open(lockfile, O_WRONLY|O_CREAT|O_TRUNC|O_EXCL, 0644);
- if(res < 0) {
- usbmuxd_log(LL_FATAL, "Could not open lockfile");
- goto terminate;
- }
- lock.l_type = F_WRLCK;
- lock.l_whence = SEEK_SET;
- lock.l_start = 0;
- lock.l_len = 0;
- if ((res = fcntl(lfd, F_SETLK, &lock)) < 0) {
- usbmuxd_log(LL_FATAL, "Lockfile locking failed!");
- goto terminate;
- }
- sprintf(pids, "%d", getpid());
- if ((res = write(lfd, pids, strlen(pids))) != strlen(pids)) {
- usbmuxd_log(LL_FATAL, "Could not write pidfile!");
- if(res >= 0)
- res = -2;
- goto terminate;
- }
-
- usbmuxd_log(LL_INFO, "Creating socket");
- res = listenfd = create_socket();
- if(listenfd < 0)
- goto terminate;
-
- // drop elevated privileges
- if (drop_privileges && (getuid() == 0 || geteuid() == 0)) {
- struct passwd *pw = getpwnam(drop_user);
- if (!pw) {
- usbmuxd_log(LL_FATAL, "Dropping privileges failed, check if user '%s' exists!", drop_user);
- res = -1;
- goto terminate;
- }
-
- if ((res = initgroups(drop_user, pw->pw_gid)) < 0) {
- usbmuxd_log(LL_FATAL, "Failed to drop privileges (cannot set supplementary groups)");
- goto terminate;
- }
- if ((res = setgid(pw->pw_gid)) < 0) {
- usbmuxd_log(LL_FATAL, "Failed to drop privileges (cannot set group ID to %d)", pw->pw_gid);
- goto terminate;
- }
- if ((res = setuid(pw->pw_uid)) < 0) {
- usbmuxd_log(LL_FATAL, "Failed to drop privileges (cannot set user ID to %d)", pw->pw_uid);
- goto terminate;
- }
-
- // security check
- if (setuid(0) != -1) {
- usbmuxd_log(LL_FATAL, "Failed to drop privileges properly!");
- res = -1;
- goto terminate;
- }
- if (getuid() != pw->pw_uid || getgid() != pw->pw_gid) {
- usbmuxd_log(LL_FATAL, "Failed to drop privileges properly!");
- res = -1;
- goto terminate;
- }
- usbmuxd_log(LL_NOTICE, "Successfully dropped privileges to '%s'", drop_user);
- }
-
- client_init();
- device_init();
- usbmuxd_log(LL_INFO, "Initializing USB");
- if((res = usb_init()) < 0)
- goto terminate;
-
- usbmuxd_log(LL_INFO, "%d device%s detected", res, (res==1)?"":"s");
-
- usbmuxd_log(LL_NOTICE, "Initialization complete");
-
- if (report_to_parent)
- if((res = notify_parent(0)) < 0)
- goto terminate;
-
- res = main_loop(listenfd);
- if(res < 0)
- usbmuxd_log(LL_FATAL, "main_loop failed");
-
- usbmuxd_log(LL_NOTICE, "usbmux shutting down");
- device_kill_connections();
- usb_shutdown();
- device_shutdown();
- client_shutdown();
- usbmuxd_log(LL_NOTICE, "Shutdown complete");
-
-terminate:
- log_disable_syslog();
-
- if (res < 0)
- res = -res;
- else
- res = 0;
- if (report_to_parent)
- notify_parent(res);
-
- return res;
-}
diff --git a/usbmuxd/usb-linux.c b/usbmuxd/usb-linux.c
deleted file mode 100644
index c09cdc9..0000000
--- a/usbmuxd/usb-linux.c
+++ /dev/null
@@ -1,542 +0,0 @@
-/*
- usbmuxd - iPhone/iPod Touch USB multiplex server daemon
-
-Copyright (C) 2009 Hector Martin "marcan" <hector@marcansoft.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 2 or version 3.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-
-*/
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdint.h>
-#include <string.h>
-
-#include <libusb.h>
-
-#include "usb.h"
-#include "log.h"
-#include "device.h"
-
-// interval for device connection/disconnection polling, in milliseconds
-// we need this because there is currently no asynchronous device discovery mechanism in libusb
-#define DEVICE_POLL_TIME 1000
-
-struct usb_device {
- libusb_device_handle *dev;
- uint8_t bus, address;
- uint16_t vid, pid;
- char serial[256];
- int alive;
- struct libusb_transfer *rx_xfer;
- struct collection tx_xfers;
- int wMaxPacketSize;
-};
-
-static struct collection device_list;
-
-static struct timeval next_dev_poll_time;
-
-static int devlist_failures;
-
-static void usb_disconnect(struct usb_device *dev)
-{
- if(!dev->dev) {
- return;
- }
-
- // kill the rx xfer and tx xfers and try to make sure the callbacks get called before we free the device
- if(dev->rx_xfer) {
- usbmuxd_log(LL_DEBUG, "usb_disconnect: cancelling RX xfer");
- libusb_cancel_transfer(dev->rx_xfer);
- }
- FOREACH(struct libusb_transfer *xfer, &dev->tx_xfers) {
- usbmuxd_log(LL_DEBUG, "usb_disconnect: cancelling TX xfer %p", xfer);
- libusb_cancel_transfer(xfer);
- } ENDFOREACH
-
- while(dev->rx_xfer || collection_count(&dev->tx_xfers)) {
- struct timeval tv;
- int res;
-
- tv.tv_sec = 0;
- tv.tv_usec = 1000;
- if((res = libusb_handle_events_timeout(NULL, &tv)) < 0) {
- usbmuxd_log(LL_ERROR, "libusb_handle_events_timeout for usb_disconnect failed: %d", res);
- break;
- }
- }
- collection_free(&dev->tx_xfers);
- libusb_release_interface(dev->dev, USB_INTERFACE);
- libusb_close(dev->dev);
- dev->dev = NULL;
- collection_remove(&device_list, dev);
- free(dev);
-}
-
-static void tx_callback(struct libusb_transfer *xfer)
-{
- struct usb_device *dev = xfer->user_data;
- usbmuxd_log(LL_SPEW, "TX callback dev %d-%d len %d -> %d status %d", dev->bus, dev->address, xfer->length, xfer->actual_length, xfer->status);
- if(xfer->status != LIBUSB_TRANSFER_COMPLETED) {
- switch(xfer->status) {
- case LIBUSB_TRANSFER_COMPLETED: //shut up compiler
- case LIBUSB_TRANSFER_ERROR:
- // funny, this happens when we disconnect the device while waiting for a transfer, sometimes
- usbmuxd_log(LL_INFO, "Device %d-%d TX aborted due to error or disconnect", dev->bus, dev->address);
- break;
- case LIBUSB_TRANSFER_TIMED_OUT:
- usbmuxd_log(LL_ERROR, "TX transfer timed out for device %d-%d", dev->bus, dev->address);
- break;
- case LIBUSB_TRANSFER_CANCELLED:
- usbmuxd_log(LL_DEBUG, "Device %d-%d TX transfer cancelled", dev->bus, dev->address);
- break;
- case LIBUSB_TRANSFER_STALL:
- usbmuxd_log(LL_ERROR, "TX transfer stalled for device %d-%d", dev->bus, dev->address);
- break;
- case LIBUSB_TRANSFER_NO_DEVICE:
- // other times, this happens, and also even when we abort the transfer after device removal
- usbmuxd_log(LL_INFO, "Device %d-%d TX aborted due to disconnect", dev->bus, dev->address);
- break;
- case LIBUSB_TRANSFER_OVERFLOW:
- usbmuxd_log(LL_ERROR, "TX transfer overflow for device %d-%d", dev->bus, dev->address);
- break;
- // and nothing happens (this never gets called) if the device is freed after a disconnect! (bad)
- }
- // we can't usb_disconnect here due to a deadlock, so instead mark it as dead and reap it after processing events
- // we'll do device_remove there too
- dev->alive = 0;
- }
- if(xfer->buffer)
- free(xfer->buffer);
- collection_remove(&dev->tx_xfers, xfer);
- libusb_free_transfer(xfer);
-}
-
-int usb_send(struct usb_device *dev, const unsigned char *buf, int length)
-{
- int res;
- struct libusb_transfer *xfer = libusb_alloc_transfer(0);
- libusb_fill_bulk_transfer(xfer, dev->dev, BULK_OUT, (void*)buf, length, tx_callback, dev, 0);
- xfer->flags = LIBUSB_TRANSFER_SHORT_NOT_OK;
-#ifndef EXPLICIT_ZLP_TRANSACTION
- if (length % dev->wMaxPacketSize == 0) {
- xfer->flags |= LIBUSB_TRANSFER_ZERO_PACKET;
- }
-#endif
- if((res = libusb_submit_transfer(xfer)) < 0) {
- usbmuxd_log(LL_ERROR, "Failed to submit TX transfer %p len %d to device %d-%d: %d", buf, length, dev->bus, dev->address, res);
- libusb_free_transfer(xfer);
- return res;
- }
- collection_add(&dev->tx_xfers, xfer);
-#ifdef EXPLICIT_ZLP_TRANSACTION
- if (length % dev->wMaxPacketSize == 0) {
- usbmuxd_log(LL_DEBUG, "Send ZLP");
- // Send Zero Length Packet
- xfer = libusb_alloc_transfer(0);
- void *buffer = malloc(1);
- libusb_fill_bulk_transfer(xfer, dev->dev, BULK_OUT, buffer, 0, tx_callback, dev, 0);
- xfer->flags = LIBUSB_TRANSFER_SHORT_NOT_OK;
- if((res = libusb_submit_transfer(xfer)) < 0) {
- usbmuxd_log(LL_ERROR, "Failed to submit TX ZLP transfer to device %d-%d: %d", dev->bus, dev->address, res);
- libusb_free_transfer(xfer);
- return res;
- }
- collection_add(&dev->tx_xfers, xfer);
- }
-#endif
- return 0;
-}
-
-static void rx_callback(struct libusb_transfer *xfer)
-{
- struct usb_device *dev = xfer->user_data;
- usbmuxd_log(LL_SPEW, "RX callback dev %d-%d len %d status %d", dev->bus, dev->address, xfer->actual_length, xfer->status);
- if(xfer->status == LIBUSB_TRANSFER_COMPLETED) {
- device_data_input(dev, xfer->buffer, xfer->actual_length);
- libusb_submit_transfer(xfer);
- } else {
- switch(xfer->status) {
- case LIBUSB_TRANSFER_COMPLETED: //shut up compiler
- case LIBUSB_TRANSFER_ERROR:
- // funny, this happens when we disconnect the device while waiting for a transfer, sometimes
- usbmuxd_log(LL_INFO, "Device %d-%d RX aborted due to error or disconnect", dev->bus, dev->address);
- break;
- case LIBUSB_TRANSFER_TIMED_OUT:
- usbmuxd_log(LL_ERROR, "RX transfer timed out for device %d-%d", dev->bus, dev->address);
- break;
- case LIBUSB_TRANSFER_CANCELLED:
- usbmuxd_log(LL_DEBUG, "Device %d-%d RX transfer cancelled", dev->bus, dev->address);
- break;
- case LIBUSB_TRANSFER_STALL:
- usbmuxd_log(LL_ERROR, "RX transfer stalled for device %d-%d", dev->bus, dev->address);
- break;
- case LIBUSB_TRANSFER_NO_DEVICE:
- // other times, this happens, and also even when we abort the transfer after device removal
- usbmuxd_log(LL_INFO, "Device %d-%d RX aborted due to disconnect", dev->bus, dev->address);
- break;
- case LIBUSB_TRANSFER_OVERFLOW:
- usbmuxd_log(LL_ERROR, "RX transfer overflow for device %d-%d", dev->bus, dev->address);
- break;
- // and nothing happens (this never gets called) if the device is freed after a disconnect! (bad)
- }
- free(xfer->buffer);
- dev->rx_xfer = NULL;
- libusb_free_transfer(xfer);
- // we can't usb_disconnect here due to a deadlock, so instead mark it as dead and reap it after processing events
- // we'll do device_remove there too
- dev->alive = 0;
- }
-}
-
-static int start_rx(struct usb_device *dev)
-{
- int res;
- void *buf;
- dev->rx_xfer = libusb_alloc_transfer(0);
- buf = malloc(USB_MRU);
- libusb_fill_bulk_transfer(dev->rx_xfer, dev->dev, BULK_IN, buf, USB_MRU, rx_callback, dev, 0);
- if((res = libusb_submit_transfer(dev->rx_xfer)) != 0) {
- usbmuxd_log(LL_ERROR, "Failed to submit RX transfer to device %d-%d: %d", dev->bus, dev->address, res);
- libusb_free_transfer(dev->rx_xfer);
- dev->rx_xfer = NULL;
- return res;
- }
- return 0;
-}
-
-static int usb_discover(void)
-{
- int cnt, i, res;
- int valid_count = 0;
- libusb_device **devs;
-
- cnt = libusb_get_device_list(NULL, &devs);
- if(cnt < 0) {
- usbmuxd_log(LL_WARNING, "Could not get device list: %d", cnt);
- devlist_failures++;
- // sometimes libusb fails getting the device list if you've just removed something
- if(devlist_failures > 5) {
- usbmuxd_log(LL_FATAL, "Too many errors getting device list\n");
- return cnt;
- } else {
- gettimeofday(&next_dev_poll_time, NULL);
- next_dev_poll_time.tv_usec += DEVICE_POLL_TIME * 1000;
- next_dev_poll_time.tv_sec += next_dev_poll_time.tv_usec / 1000000;
- next_dev_poll_time.tv_usec = next_dev_poll_time.tv_usec % 1000000;
- return 0;
- }
- }
- devlist_failures = 0;
-
- usbmuxd_log(LL_SPEW, "usb_discover: scanning %d devices", cnt);
-
- FOREACH(struct usb_device *usbdev, &device_list) {
- usbdev->alive = 0;
- } ENDFOREACH
-
- for(i=0; i<cnt; i++) {
- // the following are non-blocking operations on the device list
- libusb_device *dev = devs[i];
- uint8_t bus = libusb_get_bus_number(dev);
- uint8_t address = libusb_get_device_address(dev);
- struct libusb_device_descriptor devdesc;
- int found = 0;
- FOREACH(struct usb_device *usbdev, &device_list) {
- if(usbdev->bus == bus && usbdev->address == address) {
- valid_count++;
- usbdev->alive = 1;
- found = 1;
- break;
- }
- } ENDFOREACH
- if(found)
- continue; //device already found
- if((res = libusb_get_device_descriptor(dev, &devdesc)) != 0) {
- usbmuxd_log(LL_WARNING, "Could not get device descriptor for device %d-%d: %d", bus, address, res);
- continue;
- }
- if(devdesc.idVendor != VID_APPLE)
- continue;
- if( (devdesc.idProduct != PID_IPHONE2G) &&
- (devdesc.idProduct != PID_ITOUCH1G) &&
- (devdesc.idProduct != PID_IPHONE3G) &&
- (devdesc.idProduct != PID_ITOUCH2G) &&
- (devdesc.idProduct != PID_IPHONE3GS))
- continue;
- libusb_device_handle *handle;
- usbmuxd_log(LL_INFO, "Found new device with v/p %04x:%04x at %d-%d", devdesc.idVendor, devdesc.idProduct, bus, address);
- // potentially blocking operations follow; they will only run when new devices are detected, which is acceptable
- if((res = libusb_open(dev, &handle)) != 0) {
- usbmuxd_log(LL_WARNING, "Could not open device %d-%d: %d", bus, address, res);
- continue;
- }
- int current_config = 0;
- if((res = libusb_get_configuration(handle, &current_config)) != 0) {
- usbmuxd_log(LL_WARNING, "Could not get configuration for device %d-%d: %d", bus, address, res);
- libusb_close(handle);
- continue;
- }
- if (current_config != devdesc.bNumConfigurations) {
- if((res = libusb_set_configuration(handle, devdesc.bNumConfigurations)) != 0) {
- usbmuxd_log(LL_WARNING, "Could not set configuration %d for device %d-%d: %d", devdesc.bNumConfigurations, bus, address, res);
- libusb_close(handle);
- continue;
- }
- }
- if((res = libusb_claim_interface(handle, USB_INTERFACE)) != 0) {
- usbmuxd_log(LL_WARNING, "Could not claim interface %d for device %d-%d: %d", USB_INTERFACE, bus, address, res);
- libusb_close(handle);
- continue;
- }
- struct usb_device *usbdev;
- usbdev = malloc(sizeof(struct usb_device));
-
- if((res = libusb_get_string_descriptor_ascii(handle, devdesc.iSerialNumber, (uint8_t *)usbdev->serial, 256)) <= 0) {
- usbmuxd_log(LL_WARNING, "Could not get serial number for device %d-%d: %d", bus, address, res);
- libusb_release_interface(handle, USB_INTERFACE);
- libusb_close(handle);
- free(usbdev);
- continue;
- }
- usbdev->serial[res] = 0;
- usbdev->bus = bus;
- usbdev->address = address;
- usbdev->vid = devdesc.idVendor;
- usbdev->pid = devdesc.idProduct;
- usbdev->dev = handle;
- usbdev->alive = 1;
- usbdev->wMaxPacketSize = 0;
- struct libusb_config_descriptor *cfg;
- if (libusb_get_active_config_descriptor(dev, &cfg) == 0
- && cfg && cfg->bNumInterfaces >= (USB_INTERFACE+1)) {
- const struct libusb_interface *ifp = &cfg->interface[USB_INTERFACE];
- if (ifp && ifp->num_altsetting >= 1) {
- const struct libusb_interface_descriptor *as = &ifp->altsetting[0];
- int i;
- for (i = 0; i < as->bNumEndpoints; i++) {
- const struct libusb_endpoint_descriptor *ep = &as->endpoint[i];
- if (ep->bEndpointAddress == BULK_OUT) {
- usbdev->wMaxPacketSize = ep->wMaxPacketSize;
- }
- }
- }
- }
- if (usbdev->wMaxPacketSize == 0) {
- usbmuxd_log(LL_ERROR, "Could not determine wMaxPacketSize for device %d-%d, setting to 64", usbdev->bus, usbdev->address);
- usbdev->wMaxPacketSize = 64;
- } else {
- usbmuxd_log(LL_INFO, "Using wMaxPacketSize=%d for device %d-%d", usbdev->wMaxPacketSize, usbdev->bus, usbdev->address);
- }
-
- collection_init(&usbdev->tx_xfers);
-
- collection_add(&device_list, usbdev);
-
- if(device_add(usbdev) < 0) {
- usb_disconnect(usbdev);
- continue;
- }
- if(start_rx(usbdev) < 0) {
- device_remove(usbdev);
- usb_disconnect(usbdev);
- continue;
- }
- valid_count++;
- }
- FOREACH(struct usb_device *usbdev, &device_list) {
- if(!usbdev->alive) {
- device_remove(usbdev);
- usb_disconnect(usbdev);
- }
- } ENDFOREACH
-
- libusb_free_device_list(devs, 1);
-
- gettimeofday(&next_dev_poll_time, NULL);
- next_dev_poll_time.tv_usec += DEVICE_POLL_TIME * 1000;
- next_dev_poll_time.tv_sec += next_dev_poll_time.tv_usec / 1000000;
- next_dev_poll_time.tv_usec = next_dev_poll_time.tv_usec % 1000000;
-
- return valid_count;
-}
-
-const char *usb_get_serial(struct usb_device *dev)
-{
- if(!dev->dev) {
- return NULL;
- }
- return dev->serial;
-}
-
-uint32_t usb_get_location(struct usb_device *dev)
-{
- if(!dev->dev) {
- return 0;
- }
- return (dev->bus << 16) | dev->address;
-}
-
-uint16_t usb_get_pid(struct usb_device *dev)
-{
- if(!dev->dev) {
- return 0;
- }
- return dev->pid;
-}
-
-void usb_get_fds(struct fdlist *list)
-{
- const struct libusb_pollfd **usbfds;
- const struct libusb_pollfd **p;
- usbfds = libusb_get_pollfds(NULL);
- if(!usbfds) {
- usbmuxd_log(LL_ERROR, "libusb_get_pollfds failed");
- return;
- }
- p = usbfds;
- while(*p) {
- fdlist_add(list, FD_USB, (*p)->fd, (*p)->events);
- p++;
- }
- free(usbfds);
-}
-
-static int dev_poll_remain_ms(void)
-{
- int msecs;
- struct timeval tv;
- gettimeofday(&tv, NULL);
- msecs = (next_dev_poll_time.tv_sec - tv.tv_sec) * 1000;
- msecs += (next_dev_poll_time.tv_usec - tv.tv_usec) / 1000;
- if(msecs < 0)
- return 0;
- return msecs;
-}
-
-int usb_get_timeout(void)
-{
- struct timeval tv;
- int msec;
- int res;
- int pollrem;
- pollrem = dev_poll_remain_ms();
- res = libusb_get_next_timeout(NULL, &tv);
- if(res == 0)
- return pollrem;
- if(res < 0) {
- usbmuxd_log(LL_ERROR, "libusb_get_next_timeout failed: %d", res);
- return pollrem;
- }
- msec = tv.tv_sec * 1000;
- msec += tv.tv_usec / 1000;
- if(msec > pollrem)
- return pollrem;
- return msec;
-}
-
-int usb_process(void)
-{
- int res;
- struct timeval tv;
- tv.tv_sec = tv.tv_usec = 0;
- res = libusb_handle_events_timeout(NULL, &tv);
- if(res < 0) {
- usbmuxd_log(LL_ERROR, "libusb_handle_events_timeout failed: %d", res);
- return res;
- }
- // reap devices marked dead due to an RX error
- FOREACH(struct usb_device *usbdev, &device_list) {
- if(!usbdev->alive) {
- device_remove(usbdev);
- usb_disconnect(usbdev);
- }
- } ENDFOREACH
-
- if(dev_poll_remain_ms() <= 0) {
- res = usb_discover();
- if(res < 0) {
- usbmuxd_log(LL_ERROR, "usb_discover failed: %d", res);
- return res;
- }
- }
- return 0;
-}
-
-int usb_process_timeout(int msec)
-{
- int res;
- struct timeval tleft, tcur, tfin;
- gettimeofday(&tcur, NULL);
- tfin.tv_sec = tcur.tv_sec + (msec / 1000);
- tfin.tv_usec = tcur.tv_usec + (msec % 1000) * 1000;
- tfin.tv_sec += tfin.tv_usec / 1000000;
- tfin.tv_usec %= 1000000;
- while((tfin.tv_sec > tcur.tv_sec) || ((tfin.tv_sec == tcur.tv_sec) && (tfin.tv_usec > tcur.tv_usec))) {
- tleft.tv_sec = tfin.tv_sec - tcur.tv_sec;
- tleft.tv_usec = tfin.tv_usec - tcur.tv_usec;
- if(tleft.tv_usec < 0) {
- tleft.tv_usec += 1000000;
- tleft.tv_sec -= 1;
- }
- res = libusb_handle_events_timeout(NULL, &tleft);
- if(res < 0) {
- usbmuxd_log(LL_ERROR, "libusb_handle_events_timeout failed: %d", res);
- return res;
- }
- // reap devices marked dead due to an RX error
- FOREACH(struct usb_device *usbdev, &device_list) {
- if(!usbdev->alive) {
- device_remove(usbdev);
- usb_disconnect(usbdev);
- }
- } ENDFOREACH
- gettimeofday(&tcur, NULL);
- }
- return 0;
-}
-
-int usb_init(void)
-{
- int res;
- usbmuxd_log(LL_DEBUG, "usb_init for linux / libusb 1.0");
-
- devlist_failures = 0;
- res = libusb_init(NULL);
- //libusb_set_debug(NULL, 3);
- if(res != 0) {
- usbmuxd_log(LL_FATAL, "libusb_init failed: %d", res);
- return -1;
- }
-
- collection_init(&device_list);
-
- return usb_discover();
-}
-
-void usb_shutdown(void)
-{
- usbmuxd_log(LL_DEBUG, "usb_shutdown");
- FOREACH(struct usb_device *usbdev, &device_list) {
- device_remove(usbdev);
- usb_disconnect(usbdev);
- } ENDFOREACH
- collection_free(&device_list);
- libusb_exit(NULL);
-}
diff --git a/usbmuxd/usb.h b/usbmuxd/usb.h
deleted file mode 100644
index 621ccb2..0000000
--- a/usbmuxd/usb.h
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
- usbmuxd - iPhone/iPod Touch USB multiplex server daemon
-
-Copyright (C) 2009 Hector Martin "marcan" <hector@marcansoft.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 2 or version 3.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-
-*/
-
-#ifndef __USB_H__
-#define __USB_H__
-
-#include <stdint.h>
-#include "utils.h"
-
-#define BULK_IN 0x85
-#define BULK_OUT 0x04
-
-// libusb fragments packets larger than this (usbfs limitation)
-// on input, this creates race conditions and other issues
-#define USB_MRU 16384
-
-// max transmission packet size
-// libusb fragments these too, but doesn't send ZLPs so we're safe
-// but we need to send a ZLP ourselves at the end (see usb-linux.c)
-// we're using 3 * 16384 to optimize for the fragmentation
-// this results in three URBs per full transfer, 32 USB packets each
-// if there are ZLP issues this should make them show up easily too
-#define USB_MTU (3 * 16384)
-
-#define USB_PACKET_SIZE 512
-
-#define VID_APPLE 0x5ac
-#define PID_IPHONE2G 0x1290
-#define PID_ITOUCH1G 0x1291
-#define PID_IPHONE3G 0x1292
-#define PID_ITOUCH2G 0x1293
-#define PID_IPHONE3GS 0x1294
-
-#define USB_INTERFACE 1
-
-struct usb_device;
-
-int usb_init(void);
-void usb_shutdown(void);
-const char *usb_get_serial(struct usb_device *dev);
-uint32_t usb_get_location(struct usb_device *dev);
-uint16_t usb_get_pid(struct usb_device *dev);
-void usb_get_fds(struct fdlist *list);
-int usb_get_timeout(void);
-int usb_send(struct usb_device *dev, const unsigned char *buf, int length);
-int usb_process(void);
-int usb_process_timeout(int msec);
-
-#endif
© 2009-2020 libimobiledevice.org - All rights reserved - Generated by cgit - Icons from Tango - Uses Google Analytics