summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--libusbmuxd.c138
-rw-r--r--main.c1875
-rw-r--r--sock_stuff.c470
-rw-r--r--sock_stuff.h15
-rw-r--r--usbmux.c325
5 files changed, 1559 insertions, 1264 deletions
diff --git a/libusbmuxd.c b/libusbmuxd.c
index edd585c..c8acbf8 100644
--- a/libusbmuxd.c
+++ b/libusbmuxd.c
@@ -14,37 +14,37 @@
// socket utility functions
#include "sock_stuff.h"
-static int usbmuxd_get_result(int sfd, uint32_t tag, uint32_t *result)
+static int usbmuxd_get_result(int sfd, uint32_t tag, uint32_t * result)
{
- struct usbmuxd_result res;
- int recv_len;
-
- if (!result) {
- return -EINVAL;
- }
-
- if ((recv_len = recv_buf(sfd, &res, sizeof(res))) <= 0) {
- perror("recv");
- return -errno;
- } else {
- if ((recv_len == sizeof(res))
- && (res.header.length == (uint32_t)recv_len)
- && (res.header.reserved == 0)
- && (res.header.type == USBMUXD_RESULT)
- ) {
- *result = res.result;
- if (res.header.tag == tag) {
- return 1;
- } else {
- return 0;
- }
- }
- }
-
- return -1;
+ struct usbmuxd_result res;
+ int recv_len;
+
+ if (!result) {
+ return -EINVAL;
+ }
+
+ if ((recv_len = recv_buf(sfd, &res, sizeof(res))) <= 0) {
+ perror("recv");
+ return -errno;
+ } else {
+ if ((recv_len == sizeof(res))
+ && (res.header.length == (uint32_t) recv_len)
+ && (res.header.reserved == 0)
+ && (res.header.type == USBMUXD_RESULT)
+ ) {
+ *result = res.result;
+ if (res.header.tag == tag) {
+ return 1;
+ } else {
+ return 0;
+ }
+ }
+ }
+
+ return -1;
}
-int usbmuxd_scan(usbmuxd_scan_result **available_devices)
+int usbmuxd_scan(usbmuxd_scan_result ** available_devices)
{
struct usbmuxd_scan_request s_req;
int sfd;
@@ -68,13 +68,16 @@ int usbmuxd_scan(usbmuxd_scan_result **available_devices)
s_req.header.tag = 2;
// send scan request packet
- if (send_buf(sfd, &s_req, s_req.header.length) == (int)s_req.header.length) {
+ if (send_buf(sfd, &s_req, s_req.header.length) ==
+ (int) s_req.header.length) {
res = -1;
// get response
if (usbmuxd_get_result(sfd, s_req.header.tag, &res) && (res == 0)) {
scan_success = 1;
} else {
- fprintf(stderr, "%s: Did not get response to scan request (with result=0)...\n", __func__);
+ fprintf(stderr,
+ "%s: Did not get response to scan request (with result=0)...\n",
+ __func__);
close(sfd);
return res;
}
@@ -91,29 +94,45 @@ int usbmuxd_scan(usbmuxd_scan_result **available_devices)
if (recv_buf_timeout(sfd, &pktlen, 4, MSG_PEEK, 1000) == 4) {
if (pktlen != sizeof(dev_info_pkt)) {
// invalid packet size received!
- fprintf(stderr, "%s: Invalid packet size (%d) received when expecting a device info record.\n", __func__, pktlen);
+ fprintf(stderr,
+ "%s: Invalid packet size (%d) received when expecting a device info record.\n",
+ __func__, pktlen);
break;
}
recv_len = recv_buf(sfd, &dev_info_pkt, pktlen);
if (recv_len <= 0) {
- fprintf(stderr, "%s: Error when receiving device info record\n", __func__);
+ fprintf(stderr,
+ "%s: Error when receiving device info record\n",
+ __func__);
break;
- } else if ((uint32_t)recv_len < pktlen) {
- fprintf(stderr, "%s: received less data than specified in header!\n", __func__);
+ } else if ((uint32_t) recv_len < pktlen) {
+ fprintf(stderr,
+ "%s: received less data than specified in header!\n",
+ __func__);
} else {
//fprintf(stderr, "%s: got device record with id %d, UUID=%s\n", __func__, dev_info_pkt.device_info.device_id, dev_info_pkt.device_info.serial_number);
- newlist = (usbmuxd_scan_result *)realloc(*available_devices, sizeof(usbmuxd_scan_result) * (dev_cnt+1));
+ newlist =
+ (usbmuxd_scan_result *) realloc(*available_devices,
+ sizeof
+ (usbmuxd_scan_result) *
+ (dev_cnt + 1));
if (newlist) {
- newlist[dev_cnt].handle = (int)dev_info_pkt.device.device_id;
- newlist[dev_cnt].product_id = dev_info_pkt.device.product_id;
- memset(newlist[dev_cnt].serial_number, '\0', sizeof(newlist[dev_cnt].serial_number));
- memcpy(newlist[dev_cnt].serial_number, dev_info_pkt.device.serial_number,
- sizeof(dev_info_pkt.device.serial_number));
+ newlist[dev_cnt].handle =
+ (int) dev_info_pkt.device.device_id;
+ newlist[dev_cnt].product_id =
+ dev_info_pkt.device.product_id;
+ memset(newlist[dev_cnt].serial_number, '\0',
+ sizeof(newlist[dev_cnt].serial_number));
+ memcpy(newlist[dev_cnt].serial_number,
+ dev_info_pkt.device.serial_number,
+ sizeof(dev_info_pkt.device.serial_number));
*available_devices = newlist;
dev_cnt++;
} else {
- fprintf(stderr, "%s: ERROR: out of memory when trying to realloc!\n", __func__);
+ fprintf(stderr,
+ "%s: ERROR: out of memory when trying to realloc!\n",
+ __func__);
break;
}
}
@@ -125,8 +144,11 @@ int usbmuxd_scan(usbmuxd_scan_result **available_devices)
}
// terminating zero record
- newlist = (usbmuxd_scan_result *)realloc(*available_devices, sizeof(usbmuxd_scan_result) * (dev_cnt+1));
- memset(newlist+dev_cnt, 0, sizeof(usbmuxd_scan_result));
+ newlist =
+ (usbmuxd_scan_result *) realloc(*available_devices,
+ sizeof(usbmuxd_scan_result) *
+ (dev_cnt + 1));
+ memset(newlist + dev_cnt, 0, sizeof(usbmuxd_scan_result));
*available_devices = newlist;
return dev_cnt;
@@ -141,31 +163,33 @@ int usbmuxd_connect(const int handle, const unsigned short tcp_port)
sfd = connect_unix_socket(USBMUXD_SOCKET_FILE);
if (sfd < 0) {
- fprintf(stderr, "%s: Error: Connection to usbmuxd failed: %s\n", __func__, strerror(errno));
- return sfd;
+ fprintf(stderr, "%s: Error: Connection to usbmuxd failed: %s\n",
+ __func__, strerror(errno));
+ return sfd;
}
c_req.header.length = sizeof(c_req);
c_req.header.reserved = 0;
c_req.header.type = USBMUXD_CONNECT;
c_req.header.tag = 3;
- c_req.device_id = (uint32_t)handle;
+ c_req.device_id = (uint32_t) handle;
c_req.tcp_dport = htons(tcp_port);
c_req.reserved = 0;
if (send_buf(sfd, &c_req, sizeof(c_req)) < 0) {
- perror("send");
+ perror("send");
} else {
- // read ACK
- //fprintf(stderr, "%s: Reading connect result...\n", __func__);
- if (usbmuxd_get_result(sfd, c_req.header.tag, &res)) {
- if (res == 0) {
- //fprintf(stderr, "%s: Connect success!\n", __func__);
- connected = 1;
- } else {
- fprintf(stderr, "%s: Connect failed, Error code=%d\n", __func__, res);
+ // read ACK
+ //fprintf(stderr, "%s: Reading connect result...\n", __func__);
+ if (usbmuxd_get_result(sfd, c_req.header.tag, &res)) {
+ if (res == 0) {
+ //fprintf(stderr, "%s: Connect success!\n", __func__);
+ connected = 1;
+ } else {
+ fprintf(stderr, "%s: Connect failed, Error code=%d\n",
+ __func__, res);
+ }
}
- }
}
if (connected) {
@@ -173,6 +197,6 @@ int usbmuxd_connect(const int handle, const unsigned short tcp_port)
}
close(sfd);
-
+
return -1;
}
diff --git a/main.c b/main.c
index 43f0425..e7292cc 100644
--- a/main.c
+++ b/main.c
@@ -59,29 +59,29 @@ static int foreground = 0;
static int exit_on_no_devices = 0;
struct device_info {
- uint32_t device_id;
- usbmux_device_t phone;
- int use_count;
- pthread_t bulk_reader;
- pthread_mutex_t mutex;
- /* mutex for mutual exclusion of calling the usbmux_send function
- * TODO: I don't know if we need really need this? */
- pthread_mutex_t writer_mutex;
+ uint32_t device_id;
+ usbmux_device_t phone;
+ int use_count;
+ pthread_t bulk_reader;
+ pthread_mutex_t mutex;
+ /* mutex for mutual exclusion of calling the usbmux_send function
+ * TODO: I don't know if we need really need this? */
+ pthread_mutex_t writer_mutex;
};
struct client_data {
- volatile int dead;
- int socket;
- int tag;
- pthread_t thread;
- pthread_t handler;
- pthread_t reader;
- int reader_quit;
- int reader_dead;
- int handler_dead;
- int connected;
- usbmux_client_t muxclient;
- struct device_info *dev;
+ volatile int dead;
+ int socket;
+ int tag;
+ pthread_t thread;
+ pthread_t handler;
+ pthread_t reader;
+ int reader_quit;
+ int reader_dead;
+ int handler_dead;
+ int connected;
+ usbmux_client_t muxclient;
+ struct device_info *dev;
};
static struct device_info **devices = NULL;
@@ -97,69 +97,77 @@ static pthread_mutex_t usb_mutex = PTHREAD_MUTEX_INITIALIZER;
*/
static void logmsg(int prio, const char *format, ...)
{
- va_list args;
- va_start(args, format);
-
- if (!foreground) {
- // daemon. log using syslog.
- vsyslog(prio, format, args);
- } else {
- // running in foreground. log to stdout/stderr.
- char msgbuf[256];
- FILE *lfp = stdout;
- switch(prio) {
- case LOG_EMERG:
- case LOG_ALERT:
- case LOG_CRIT:
- case LOG_ERR:
- case LOG_WARNING:
- lfp = stderr;
- break;
- default:
- lfp = stdout;
+ va_list args;
+ va_start(args, format);
+
+ if (!foreground) {
+ // daemon. log using syslog.
+ vsyslog(prio, format, args);
+ } else {
+ // running in foreground. log to stdout/stderr.
+ char msgbuf[256];
+ FILE *lfp = stdout;
+ switch (prio) {
+ case LOG_EMERG:
+ case LOG_ALERT:
+ case LOG_CRIT:
+ case LOG_ERR:
+ case LOG_WARNING:
+ lfp = stderr;
+ break;
+ default:
+ lfp = stdout;
+ }
+ strcpy(msgbuf, "usbmuxd: ");
+ vsnprintf(msgbuf + 9, 244, format, args);
+ strcat(msgbuf, "\n");
+ fputs(msgbuf, lfp);
}
- strcpy(msgbuf, "usbmuxd: ");
- vsnprintf(msgbuf+9, 244, format, args);
- strcat(msgbuf, "\n");
- fputs(msgbuf, lfp);
- }
- va_end(args);
+ va_end(args);
}
#ifdef DEBUG
/**
* for debugging purposes.
*/
-static void print_buffer(FILE *fp, const char *data, const int length)
+static void print_buffer(FILE * fp, const char *data, const int length)
{
- int i;
+ int i;
int j;
unsigned char c;
- for(i=0; i<length; i+=16) {
- if (verbose >= 4) fprintf(fp, "%04x: ", i);
- for (j=0;j<16;j++) {
- if (i+j >= length) {
- if (verbose >= 4) fprintf(fp, " ");
+ for (i = 0; i < length; i += 16) {
+ if (verbose >= 4)
+ fprintf(fp, "%04x: ", i);
+ for (j = 0; j < 16; j++) {
+ if (i + j >= length) {
+ if (verbose >= 4)
+ fprintf(fp, " ");
continue;
}
- if (verbose >= 4) fprintf(fp, "%02hhx ", *(data+i+j));
+ if (verbose >= 4)
+ fprintf(fp, "%02hhx ", *(data + i + j));
}
- if (verbose >= 4) fprintf(fp, " | ");
- for(j=0;j<16;j++) {
- if (i+j >= length)
+ if (verbose >= 4)
+ fprintf(fp, " | ");
+ for (j = 0; j < 16; j++) {
+ if (i + j >= length)
break;
- c = *(data+i+j);
+ c = *(data + i + j);
if ((c < 32) || (c > 127)) {
- if (verbose >= 4) fprintf(fp, ".");
+ if (verbose >= 4)
+ fprintf(fp, ".");
continue;
}
- if (verbose >= 4) fprintf(fp, "%c", c);
+ if (verbose >= 4)
+ fprintf(fp, "%c", c);
}
- if (verbose >= 4) fprintf(fp, "\n");
+ if (verbose >= 4)
+ fprintf(fp, "\n");
}
- if (verbose >= 4) fprintf(fp, "\n");
+ if (verbose >= 4)
+ fprintf(fp, "\n");
}
#endif
@@ -176,35 +184,40 @@ static void print_buffer(FILE *fp, const char *data, const int length)
*/
static int usbmuxd_get_request(int fd, void **data, size_t len)
{
- uint32_t pktlen;
- int recv_len;
-
- if (peek_buf(fd, &pktlen, sizeof(pktlen)) < (int)sizeof(pktlen)) {
- return -errno;
- }
-
- if (len == 0) {
- // allocate buffer space
- *data = malloc(pktlen);
- } else if (len < pktlen) {
- // target buffer is to small to hold this packet! fix it!
- if (verbose >= 2) logmsg(LOG_WARNING, "%s: WARNING -- packet (%d) is larger than target buffer (%d)! Truncating.", __func__, pktlen, len);
- pktlen = len;
- }
-
- recv_len = recv_buf(fd, *data, pktlen);
- if ((recv_len > 0) && ((uint32_t)recv_len < pktlen)) {
- if (verbose >= 2) logmsg(LOG_WARNING, "%s: Uh-oh, we got less than the packet's size, %d instead of %d...", __func__, recv_len, pktlen);
- }
+ uint32_t pktlen;
+ int recv_len;
+
+ if (peek_buf(fd, &pktlen, sizeof(pktlen)) < (int) sizeof(pktlen)) {
+ return -errno;
+ }
+ if (len == 0) {
+ // allocate buffer space
+ *data = malloc(pktlen);
+ } else if (len < pktlen) {
+ // target buffer is to small to hold this packet! fix it!
+ if (verbose >= 2)
+ logmsg(LOG_WARNING,
+ "%s: WARNING -- packet (%d) is larger than target buffer (%d)! Truncating.",
+ __func__, pktlen, len);
+ pktlen = len;
+ }
+
+ recv_len = recv_buf(fd, *data, pktlen);
+ if ((recv_len > 0) && ((uint32_t) recv_len < pktlen)) {
+ if (verbose >= 2)
+ logmsg(LOG_WARNING,
+ "%s: Uh-oh, we got less than the packet's size, %d instead of %d...",
+ __func__, recv_len, pktlen);
+ }
#ifdef DEBUG
- if (*data && (recv_len > 0) && verbose >= 4) {
- fprintf(stderr, "%s: received:\n", __func__);
- print_buffer(stderr, *data, recv_len);
- }
+ if (*data && (recv_len > 0) && verbose >= 4) {
+ fprintf(stderr, "%s: received:\n", __func__);
+ print_buffer(stderr, *data, recv_len);
+ }
#endif
- return recv_len;
+ return recv_len;
}
/**
@@ -218,20 +231,22 @@ 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 usbmuxd_result res;
- int ret;
-
- res.header.length = sizeof(res);
- res.header.reserved = 0;
- res.header.type = USBMUXD_RESULT;
- res.header.tag = tag;
- res.result = result_code;
-
- if (verbose >= 4) logmsg(LOG_NOTICE, "%s: tag=%d result=%d", __func__, res.header.tag, res.result);
-
- ret = send_buf(fd, &res, sizeof(res));
- fsync(fd); // let's get it sent
- return ret;
+ struct usbmuxd_result res;
+ int ret;
+
+ res.header.length = sizeof(res);
+ res.header.reserved = 0;
+ res.header.type = USBMUXD_RESULT;
+ res.header.tag = tag;
+ res.result = result_code;
+
+ if (verbose >= 4)
+ logmsg(LOG_NOTICE, "%s: tag=%d result=%d", __func__,
+ res.header.tag, res.result);
+
+ ret = send_buf(fd, &res, sizeof(res));
+ fsync(fd); // let's get it sent
+ return ret;
}
/**
@@ -244,69 +259,84 @@ static int usbmuxd_send_result(int fd, uint32_t tag, uint32_t result_code)
*/
static void *usbmuxd_client_reader_thread(void *arg)
{
- struct client_data *cdata;
-
- char rbuffer[512];
- uint32_t rbuffersize = 512;
- uint32_t rlen;
- int err;
- char *cursor;
- ssize_t len;
- int result;
-
- if (!arg) {
- if (verbose >= 2) logmsg(LOG_ERR, "%s: invalid client_data supplied!", __func__);
- cdata->reader_dead = 1;
- return NULL;
- }
+ struct client_data *cdata;
+
+ char rbuffer[512];
+ uint32_t rbuffersize = 512;
+ uint32_t rlen;
+ int err;
+ char *cursor;
+ ssize_t len;
+ int result;
+
+ if (!arg) {
+ if (verbose >= 2)
+ logmsg(LOG_ERR, "%s: invalid client_data supplied!", __func__);
+ cdata->reader_dead = 1;
+ return NULL;
+ }
- cdata = (struct client_data*)arg;
+ cdata = (struct client_data *) arg;
- cdata->reader_dead = 0;
+ cdata->reader_dead = 0;
- if (verbose >= 3) logmsg(LOG_NOTICE, "%s[%d:%d]: started", __func__, cdata->dev->device_id, cdata->dev->use_count);
+ if (verbose >= 3)
+ logmsg(LOG_NOTICE, "%s[%d:%d]: started", __func__,
+ cdata->dev->device_id, cdata->dev->use_count);
- while (!quit_flag && !cdata->reader_quit) {
- result = check_fd(cdata->socket, FD_WRITE, DEFAULT_TIMEOUT);
- if (result <= 0) {
- if (result < 0) {
- if (verbose >= 2) logmsg(LOG_ERR, "%s: select error: %s", __func__, strerror(errno));
- }
- continue;
- }
+ while (!quit_flag && !cdata->reader_quit) {
+ result = check_fd(cdata->socket, FD_WRITE, DEFAULT_TIMEOUT);
+ if (result <= 0) {
+ if (result < 0) {
+ if (verbose >= 2)
+ logmsg(LOG_ERR, "%s: select error: %s", __func__,
+ strerror(errno));
+ }
+ continue;
+ }
- rlen = 0;
- err = usbmux_recv_timeout(cdata->muxclient, rbuffer, rbuffersize, &rlen, DEFAULT_TIMEOUT);
- if (err != 0) {
- if (verbose >= 2) logmsg(LOG_ERR, "%s[%d:%d]: encountered USB read error: %d", __func__, cdata->dev->device_id, cdata->dev->use_count, err);
- break;
- }
+ rlen = 0;
+ err =
+ usbmux_recv_timeout(cdata->muxclient, rbuffer, rbuffersize,
+ &rlen, DEFAULT_TIMEOUT);
+ if (err != 0) {
+ if (verbose >= 2)
+ logmsg(LOG_ERR,
+ "%s[%d:%d]: encountered USB read error: %d",
+ __func__, cdata->dev->device_id,
+ cdata->dev->use_count, err);
+ break;
+ }
- cursor = rbuffer;
- while (rlen > 0) {
- len = send_buf(cdata->socket, cursor, rlen);
- if (len <= 0) {
- logmsg(LOG_ERR, "%s: Error: send returned %d", __func__, len);
- err = 1;
- break;
- }
- // calculate remainder
- rlen -= len;
- // advance cursor
- cursor += len;
- }
- if (err != 0) {
- logmsg(LOG_ERR, "%s: Error when writing to client...", __func__);
- break;
+ cursor = rbuffer;
+ while (rlen > 0) {
+ len = send_buf(cdata->socket, cursor, rlen);
+ if (len <= 0) {
+ logmsg(LOG_ERR, "%s: Error: send returned %d", __func__,
+ len);
+ err = 1;
+ break;
+ }
+ // calculate remainder
+ rlen -= len;
+ // advance cursor
+ cursor += len;
+ }
+ if (err != 0) {
+ logmsg(LOG_ERR, "%s: Error when writing to client...",
+ __func__);
+ break;
+ }
+ fsync(cdata->socket);
}
- fsync(cdata->socket);
- }
- if (verbose >= 3) logmsg(LOG_NOTICE, "%s[%d:%d]: terminated", __func__, cdata->dev->device_id, cdata->dev->use_count);
+ if (verbose >= 3)
+ logmsg(LOG_NOTICE, "%s[%d:%d]: terminated", __func__,
+ cdata->dev->device_id, cdata->dev->use_count);
- cdata->reader_dead = 1;
+ cdata->reader_dead = 1;
- return NULL;
+ return NULL;
}
/**
@@ -321,60 +351,73 @@ static void *usbmuxd_client_reader_thread(void *arg)
*/
static int usbmuxd_handleConnectResult(struct client_data *cdata)
{
- int result;
- char buffer[512];
- char err_type[64];
- int err_code;
- ssize_t maxlen = 512;
- uint32_t rlen;
- int err;
-
- if (!cdata) {
- if (verbose >= 2) logmsg(LOG_ERR, "%s: Invalid client_data provided!", __func__);
- return -EINVAL;
- }
-
- result = check_fd(cdata->socket, FD_WRITE, DEFAULT_TIMEOUT);
- if (result <= 0) {
- if (result < 0) {
- if (verbose >= 2) logmsg(LOG_ERR, "%s: select error: %s", __func__, strerror(errno));
- return result;
+ int result;
+ char buffer[512];
+ char err_type[64];
+ int err_code;
+ ssize_t maxlen = 512;
+ uint32_t rlen;
+ int err;
+
+ if (!cdata) {
+ if (verbose >= 2)
+ logmsg(LOG_ERR, "%s: Invalid client_data provided!", __func__);
+ return -EINVAL;
}
- } else {
- result = 0;
- err = usbmux_recv_timeout(cdata->muxclient, buffer, maxlen, &rlen, 100);
- if (err < 0) {
- if (verbose >= 2) logmsg(LOG_ERR, "%s: encountered USB read error: %d", __func__, err);
- usbmuxd_send_result(cdata->socket, cdata->tag, -err);
- return err;
+
+ result = check_fd(cdata->socket, FD_WRITE, DEFAULT_TIMEOUT);
+ if (result <= 0) {
+ if (result < 0) {
+ if (verbose >= 2)
+ logmsg(LOG_ERR, "%s: select error: %s", __func__,
+ strerror(errno));
+ return result;
+ }
} else {
- if (rlen > 0) {
- if ((buffer[0] == 1) && (rlen > 20) && !memcmp(buffer+1, "handleConnectResult:", 20)) {
- // hm... we got an error message!
- buffer[rlen] = 0;
- if (verbose >= 1) logmsg(LOG_ERR, "%s: %s\n", __func__, buffer+22);
-
- if (sscanf(buffer+22, "%s - %d\n", err_type, &err_code) == 2) {
- usbmuxd_send_result(cdata->socket, cdata->tag, err_code);
- return -err_code;
- } else {
- usbmuxd_send_result(cdata->socket, cdata->tag, ENODATA);
- return -ENODATA;
- }
+ result = 0;
+ err =
+ usbmux_recv_timeout(cdata->muxclient, buffer, maxlen, &rlen,
+ 100);
+ if (err < 0) {
+ if (verbose >= 2)
+ logmsg(LOG_ERR, "%s: encountered USB read error: %d",
+ __func__, err);
+ usbmuxd_send_result(cdata->socket, cdata->tag, -err);
+ return err;
} else {
- // send success result
- usbmuxd_send_result(cdata->socket, cdata->tag, 0);
- // and the server greeting message
- send_buf(cdata->socket, buffer, rlen);
+ if (rlen > 0) {
+ if ((buffer[0] == 1) && (rlen > 20)
+ && !memcmp(buffer + 1, "handleConnectResult:", 20)) {
+ // hm... we got an error message!
+ buffer[rlen] = 0;
+ if (verbose >= 1)
+ logmsg(LOG_ERR, "%s: %s\n", __func__, buffer + 22);
+
+ if (sscanf
+ (buffer + 22, "%s - %d\n", err_type, &err_code)
+ == 2) {
+ usbmuxd_send_result(cdata->socket, cdata->tag,
+ err_code);
+ return -err_code;
+ } else {
+ usbmuxd_send_result(cdata->socket, cdata->tag,
+ ENODATA);
+ return -ENODATA;
+ }
+ } else {
+ // send success result
+ usbmuxd_send_result(cdata->socket, cdata->tag, 0);
+ // and the server greeting message
+ send_buf(cdata->socket, buffer, rlen);
+ }
+ } else {
+ // no server greeting? this seems to be ok. send success.
+ usbmuxd_send_result(cdata->socket, cdata->tag, 0);
+ }
}
- } else {
- // no server greeting? this seems to be ok. send success.
- usbmuxd_send_result(cdata->socket, cdata->tag, 0);
- }
+ //fsync(cdata->socket);
}
- //fsync(cdata->socket);
- }
- return result;
+ return result;
}
/**
@@ -383,96 +426,115 @@ static int usbmuxd_handleConnectResult(struct client_data *cdata)
*/
static void *usbmuxd_client_handler_thread(void *arg)
{
- struct client_data *cdata;
- int result;
- char *cursor;
- char buffer[65536];
- ssize_t len;
- ssize_t maxlen = sizeof(buffer);
- uint32_t wlen;
- int err;
-
- if (!arg) {
- if (verbose >= 2) logmsg(LOG_ERR, "%s: invalid client_data provided!", __func__);
- return NULL;
- }
-
- cdata = (struct client_data*)arg;
-
- if (verbose >= 3) logmsg(LOG_NOTICE, "%s[%d:%d]: started", __func__, cdata->dev->device_id,cdata->dev->use_count);
+ struct client_data *cdata;
+ int result;
+ char *cursor;
+ char buffer[65536];
+ ssize_t len;
+ ssize_t maxlen = sizeof(buffer);
+ uint32_t wlen;
+ int err;
+
+ if (!arg) {
+ if (verbose >= 2)
+ logmsg(LOG_ERR, "%s: invalid client_data provided!", __func__);
+ return NULL;
+ }
- if (usbmuxd_handleConnectResult(cdata)) {
- if (verbose >= 3) logmsg(LOG_ERR, "handleConnectResult: Error");
- goto leave;
- } else {
- if (verbose >= 3) logmsg(LOG_NOTICE, "handleConnectResult: Success");
- }
+ cdata = (struct client_data *) arg;
- // starting mux reader thread
- cdata->reader_quit = 0;
- cdata->reader_dead = 0;
- if (pthread_create(&cdata->reader, NULL, usbmuxd_client_reader_thread, cdata) != 0) {
- if (verbose >= 2) logmsg(LOG_ERR, "%s: could not start client_reader thread", __func__);
- cdata->reader = 0;
- }
+ if (verbose >= 3)
+ logmsg(LOG_NOTICE, "%s[%d:%d]: started", __func__,
+ cdata->dev->device_id, cdata->dev->use_count);
- while (!quit_flag && !cdata->reader_dead) {
- result = check_fd(cdata->socket, FD_READ, DEFAULT_TIMEOUT);
- if (result <= 0) {
- if (result < 0) {
- if (verbose >= 3) logmsg(LOG_ERR, "%s: Error: checkfd: %s", __func__, strerror(errno));
- }
- continue;
+ if (usbmuxd_handleConnectResult(cdata)) {
+ if (verbose >= 3)
+ logmsg(LOG_ERR, "handleConnectResult: Error");
+ goto leave;
+ } else {
+ if (verbose >= 3)
+ logmsg(LOG_NOTICE, "handleConnectResult: Success");
}
- // check_fd told us there's data available, so read from client
- // and push to USB device.
- len = recv(cdata->socket, buffer, maxlen, 0);
- if (len == 0) {
- break;
- }
- if (len < 0) {
- if (verbose >= 2) logmsg(LOG_ERR, "%s[%d:%d]: Error: recv: %s", __func__, cdata->dev->device_id, cdata->dev->use_count, strerror(errno));
- break;
+ // starting mux reader thread
+ cdata->reader_quit = 0;
+ cdata->reader_dead = 0;
+ if (pthread_create
+ (&cdata->reader, NULL, usbmuxd_client_reader_thread, cdata) != 0) {
+ if (verbose >= 2)
+ logmsg(LOG_ERR, "%s: could not start client_reader thread",
+ __func__);
+ cdata->reader = 0;
}
- cursor = buffer;
-
- pthread_mutex_lock(&cdata->dev->writer_mutex);
- do {
- wlen = 0;
- err = usbmux_send(cdata->muxclient, cursor, len, &wlen);
- if (err == -ETIMEDOUT) {
- // some kind of timeout... just be patient and retry.
- } else if (err < 0) {
- if (verbose >= 2) logmsg(LOG_ERR, "%s[%d:%d]: USB write error: %d", __func__, cdata->dev->device_id, cdata->dev->use_count, err);
- len = -1;
- break;
- }
-
- // calculate remainder.
- len -= wlen;
- // advance cursor appropiately.
- cursor += wlen;
- } while ((len > 0) && !quit_flag);
- pthread_mutex_unlock(&cdata->dev->writer_mutex);
- if (len < 0) {
- break;
+ while (!quit_flag && !cdata->reader_dead) {
+ result = check_fd(cdata->socket, FD_READ, DEFAULT_TIMEOUT);
+ if (result <= 0) {
+ if (result < 0) {
+ if (verbose >= 3)
+ logmsg(LOG_ERR, "%s: Error: checkfd: %s", __func__,
+ strerror(errno));
+ }
+ continue;
+ }
+ // check_fd told us there's data available, so read from client
+ // and push to USB device.
+ len = recv(cdata->socket, buffer, maxlen, 0);
+ if (len == 0) {
+ break;
+ }
+ if (len < 0) {
+ if (verbose >= 2)
+ logmsg(LOG_ERR, "%s[%d:%d]: Error: recv: %s", __func__,
+ cdata->dev->device_id, cdata->dev->use_count,
+ strerror(errno));
+ break;
+ }
+
+ cursor = buffer;
+
+ pthread_mutex_lock(&cdata->dev->writer_mutex);
+ do {
+ wlen = 0;
+ err = usbmux_send(cdata->muxclient, cursor, len, &wlen);
+ if (err == -ETIMEDOUT) {
+ // some kind of timeout... just be patient and retry.
+ } else if (err < 0) {
+ if (verbose >= 2)
+ logmsg(LOG_ERR, "%s[%d:%d]: USB write error: %d",
+ __func__, cdata->dev->device_id,
+ cdata->dev->use_count, err);
+ len = -1;
+ break;
+ }
+ // calculate remainder.
+ len -= wlen;
+ // advance cursor appropiately.
+ cursor += wlen;
+ }
+ while ((len > 0) && !quit_flag);
+ pthread_mutex_unlock(&cdata->dev->writer_mutex);
+ if (len < 0) {
+ break;
+ }
}
- }
-leave:
- // cleanup
- if (verbose >= 3) logmsg(LOG_NOTICE, "%s[%d:%d]: terminating", __func__, cdata->dev->device_id, cdata->dev->use_count);
- if (cdata->reader != 0) {
- cdata->reader_quit = 1;
- pthread_join(cdata->reader, NULL);
- }
+ leave:
+ // cleanup
+ if (verbose >= 3)
+ logmsg(LOG_NOTICE, "%s[%d:%d]: terminating", __func__,
+ cdata->dev->device_id, cdata->dev->use_count);
+ if (cdata->reader != 0) {
+ cdata->reader_quit = 1;
+ pthread_join(cdata->reader, NULL);
+ }
- cdata->handler_dead = 1;
+ cdata->handler_dead = 1;
- if (verbose >= 3) logmsg(LOG_NOTICE, "%s[%d:%d]: terminated", __func__, cdata->dev->device_id, cdata->dev->use_count);
- return NULL;
+ if (verbose >= 3)
+ logmsg(LOG_NOTICE, "%s[%d:%d]: terminated", __func__,
+ cdata->dev->device_id, cdata->dev->use_count);
+ return NULL;
}
/**
@@ -481,36 +543,41 @@ leave:
*/
static void *usbmuxd_bulk_reader_thread(void *arg)
{
- struct device_info *cur_dev;
- int err;
+ struct device_info *cur_dev;
+ int err;
- if (!arg) {
- if (verbose >= 2) logmsg(LOG_ERR, "%s: Invalid client_data provided", __func__);
- return NULL;
- }
+ if (!arg) {
+ if (verbose >= 2)
+ logmsg(LOG_ERR, "%s: Invalid client_data provided", __func__);
+ return NULL;
+ }
- cur_dev = (struct device_info*)arg;
+ cur_dev = (struct device_info *) arg;
- if (verbose >= 3) logmsg(LOG_NOTICE, "%s: started", __func__);
+ if (verbose >= 3)
+ logmsg(LOG_NOTICE, "%s: started", __func__);
- while (!quit_flag && cur_dev) {
+ while (!quit_flag && cur_dev) {
- pthread_mutex_lock(&cur_dev->mutex);
- if (cur_dev->use_count <= 0) {
- pthread_mutex_unlock(&cur_dev->mutex);
- break;
- }
- pthread_mutex_unlock(&cur_dev->mutex);
+ pthread_mutex_lock(&cur_dev->mutex);
+ if (cur_dev->use_count <= 0) {
+ pthread_mutex_unlock(&cur_dev->mutex);
+ break;
+ }
+ pthread_mutex_unlock(&cur_dev->mutex);
- if ((err = usbmux_pullbulk(cur_dev->phone)) < 0) {
- if (verbose >= 1) logmsg(LOG_ERR, "%s: error %d when reading from device", __func__, err);
- break;
+ if ((err = usbmux_pullbulk(cur_dev->phone)) < 0) {
+ if (verbose >= 1)
+ logmsg(LOG_ERR, "%s: error %d when reading from device",
+ __func__, err);
+ break;
+ }
}
- }
- if (verbose >= 3) logmsg(LOG_NOTICE, "%s: terminated", __func__);
+ if (verbose >= 3)
+ logmsg(LOG_NOTICE, "%s: terminated", __func__);
- return NULL;
+ return NULL;
}
/**
@@ -520,286 +587,374 @@ static void *usbmuxd_bulk_reader_thread(void *arg)
*/
static void *usbmuxd_client_init_thread(void *arg)
{
- struct client_data *cdata;
- struct usbmuxd_scan_request *s_req = NULL;
- struct usbmuxd_device_info_record dev_info_rec;
- struct usbmuxd_connect_request *c_req = NULL;
+ struct client_data *cdata;
+ struct usbmuxd_scan_request *s_req = NULL;
+ struct usbmuxd_device_info_record dev_info_rec;
+ struct usbmuxd_connect_request *c_req = NULL;
+
+ struct usb_bus *bus;
+ struct usb_device *dev;
+
+ int recv_len;
+ int found = 0;
+ int res;
+ int i;
+
+ usbmux_device_t phone = NULL;
+ struct device_info *cur_dev = NULL;
+
+ if (!arg) {
+ if (verbose >= 1)
+ logmsg(LOG_ERR, "%s[%x]: invalid client_data provided!",
+ __func__, THREAD);
+ return NULL;
+ }
- struct usb_bus *bus;
- struct usb_device *dev;
+ cdata = (struct client_data *) arg;
+ cdata->dead = 0;
- int recv_len;
- int found = 0;
- int res;
- int i;
+ if (verbose >= 3)
+ logmsg(LOG_NOTICE, "%s[%x]: started (fd=%d)", __func__, THREAD,
+ cdata->socket);
- usbmux_device_t phone = NULL;
- struct device_info *cur_dev = NULL;
+ if ((recv_len =
+ usbmuxd_get_request(cdata->socket, (void **) &s_req, 0)) <= 0) {
+ if (verbose >= 2)
+ logmsg(LOG_ERR, "%s[%x]: No scan packet received, error %s",
+ __func__, THREAD, strerror(errno));
+ goto leave;
+ }
- if (!arg) {
- if (verbose >= 1) logmsg(LOG_ERR, "%s[%x]: invalid client_data provided!", __func__, THREAD);
- return NULL;
- }
-
- cdata = (struct client_data*)arg;
- cdata->dead = 0;
-
- if (verbose >= 3) logmsg(LOG_NOTICE, "%s[%x]: started (fd=%d)", __func__, THREAD, cdata->socket);
-
- if ((recv_len = usbmuxd_get_request(cdata->socket, (void**)&s_req, 0)) <= 0) {
- if (verbose >= 2) logmsg(LOG_ERR, "%s[%x]: No scan packet received, error %s", __func__, THREAD, strerror(errno));
- goto leave;
- }
-
- if ((recv_len == sizeof(struct usbmuxd_scan_request)) && (s_req->header.length == sizeof(struct usbmuxd_scan_request))
- && (s_req->header.reserved == 0) && (s_req->header.type == USBMUXD_SCAN)) {
- // send success response
- if (verbose >= 3) logmsg(LOG_NOTICE, "%s[%x]: Got scan packet!", __func__, THREAD);
- usbmuxd_send_result(cdata->socket, s_req->header.tag, 0);
- } else if ((recv_len == sizeof(struct usbmuxd_connect_request)) && (s_req->header.type == USBMUXD_CONNECT)) {
- c_req = (struct usbmuxd_connect_request*)s_req;
- s_req = NULL;
- goto connect;
- } else {
- // send error response and exit
- if (verbose >= 2) logmsg(LOG_ERR, "%s[%x]: Invalid scan packet received.", __func__, THREAD);
- // TODO is this required?!
- usbmuxd_send_result(cdata->socket, s_req->header.tag, EINVAL);
- goto leave;
- }
-
- pthread_mutex_lock(&usb_mutex);
- // gather data about all iPhones/iPods attached
-
- if (verbose >= 5) logmsg(LOG_DEBUG, "%s[%x]: usb init", __func__, THREAD);
- usb_init();
- if (verbose >= 5) logmsg(LOG_DEBUG, "%s[%x]: usb find busses", __func__, THREAD);
- usb_find_busses();
- if (verbose >= 5) logmsg(LOG_DEBUG, "%s[%x]: usb find devices", __func__, THREAD);
- usb_find_devices();
-
- if (verbose >= 2) logmsg(LOG_NOTICE, "%s[%x]: Looking for attached devices...", __func__, THREAD);
-
- for (bus = usb_get_busses(); bus; bus = bus->next) {
- for (dev = bus->devices; dev; dev = dev->next) {
- if (dev->descriptor.idVendor == 0x05ac
- && dev->descriptor.idProduct >= 0x1290
- && dev->descriptor.idProduct <= 0x1293)
- {
- if (verbose >= 1) logmsg(LOG_NOTICE, "%s[%x]: Found device on bus %d, id %d", __func__, THREAD, bus->location, dev->devnum);
- found++;
-
- // construct packet
- memset(&dev_info_rec, 0, sizeof(dev_info_rec));
- dev_info_rec.header.length = sizeof(dev_info_rec);
- dev_info_rec.header.type = USBMUXD_DEVICE_INFO;
- dev_info_rec.device.device_id = dev->devnum;
- dev_info_rec.device.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_rec.device.serial_number, sizeof(dev_info_rec.device.serial_number)+1);
- usb_close(udev);
- }
- //pthread_mutex_unlock(&usbmux_mutex);
- }
+ if ((recv_len == sizeof(struct usbmuxd_scan_request))
+ && (s_req->header.length == sizeof(struct usbmuxd_scan_request))
+ && (s_req->header.reserved == 0)
+ && (s_req->header.type == USBMUXD_SCAN)) {
+ // send success response
+ if (verbose >= 3)
+ logmsg(LOG_NOTICE, "%s[%x]: Got scan packet!", __func__,
+ THREAD);
+ usbmuxd_send_result(cdata->socket, s_req->header.tag, 0);
+ } else if ((recv_len == sizeof(struct usbmuxd_connect_request))
+ && (s_req->header.type == USBMUXD_CONNECT)) {
+ c_req = (struct usbmuxd_connect_request *) s_req;
+ s_req = NULL;
+ goto connect;
+ } else {
+ // send error response and exit
+ if (verbose >= 2)
+ logmsg(LOG_ERR, "%s[%x]: Invalid scan packet received.",
+ __func__, THREAD);
+ // TODO is this required?!
+ usbmuxd_send_result(cdata->socket, s_req->header.tag, EINVAL);
+ goto leave;
+ }
+ pthread_mutex_lock(&usb_mutex);
+ // gather data about all iPhones/iPods attached
+
+ if (verbose >= 5)
+ logmsg(LOG_DEBUG, "%s[%x]: usb init", __func__, THREAD);
+ usb_init();
+ if (verbose >= 5)
+ logmsg(LOG_DEBUG, "%s[%x]: usb find busses", __func__, THREAD);
+ usb_find_busses();
+ if (verbose >= 5)
+ logmsg(LOG_DEBUG, "%s[%x]: usb find devices", __func__, THREAD);
+ usb_find_devices();
+
+ if (verbose >= 2)
+ logmsg(LOG_NOTICE, "%s[%x]: Looking for attached devices...",
+ __func__, THREAD);
+
+ for (bus = usb_get_busses(); bus; bus = bus->next) {
+ for (dev = bus->devices; dev; dev = dev->next) {
+ if (dev->descriptor.idVendor == 0x05ac
+ && dev->descriptor.idProduct >= 0x1290
+ && dev->descriptor.idProduct <= 0x1293) {
+ if (verbose >= 1)
+ logmsg(LOG_NOTICE,
+ "%s[%x]: Found device on bus %d, id %d",
+ __func__, THREAD, bus->location, dev->devnum);
+ found++;
+
+ // construct packet
+ memset(&dev_info_rec, 0, sizeof(dev_info_rec));
+ dev_info_rec.header.length = sizeof(dev_info_rec);
+ dev_info_rec.header.type = USBMUXD_DEVICE_INFO;
+ dev_info_rec.device.device_id = dev->devnum;
+ dev_info_rec.device.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_rec.device.
+ serial_number,
+ sizeof(dev_info_rec.device.
+ serial_number) + 1);
+ usb_close(udev);
+ }
+ //pthread_mutex_unlock(&usbmux_mutex);
+ }
#ifdef DEBUG
- if (verbose >= 4) print_buffer(stderr, (char*)&dev_info_rec, sizeof(dev_info_rec));
+ if (verbose >= 4)
+ print_buffer(stderr, (char *) &dev_info_rec,
+ sizeof(dev_info_rec));
#endif
- // send it
- if (send_buf(cdata->socket, &dev_info_rec, sizeof(dev_info_rec)) <= 0) {
- if (verbose >= 3) logmsg(LOG_ERR, "%s[%x]: Error: Could not send device info: %s", __func__, THREAD, strerror(errno));
- found--;
+ // send it
+ if (send_buf
+ (cdata->socket, &dev_info_rec,
+ sizeof(dev_info_rec)) <= 0) {
+ if (verbose >= 3)
+ logmsg(LOG_ERR,
+ "%s[%x]: Error: Could not send device info: %s",
+ __func__, THREAD, strerror(errno));
+ found--;
+ }
+ }
}
- }
}
- }
- pthread_mutex_unlock(&usb_mutex);
-
- if (found <= 0) {
- if (verbose >= 1) logmsg(LOG_NOTICE, "%s[%x]: No attached iPhone/iPod devices found.", __func__, THREAD);
- goto leave;
- }
-
- if (verbose >= 3) logmsg(LOG_NOTICE, "%s[%x]: Waiting for connect request", __func__, THREAD);
-
- // now wait for connect request
- //memset(&c_req, 0, sizeof(c_req));
- if ((recv_len = usbmuxd_get_request(cdata->socket, (void**)&c_req, 0)) <= 0) {
- if (verbose >= 3) logmsg(LOG_NOTICE, "%s[%x]: Did not receive any connect request.", __func__, THREAD);
- goto leave;
- }
-
-connect:
-
- if (c_req->header.type != USBMUXD_CONNECT) {
- if (verbose >= 2) logmsg(LOG_ERR, "%s[%x]: Unexpected packet of type %d received.", __func__, THREAD, c_req->header.type);
- goto leave;
- }
-
- if (verbose >= 3) logmsg(LOG_NOTICE, "%s[%x]: Setting up connection to usb device #%d on port %d", __func__, THREAD, c_req->device_id, ntohs(c_req->tcp_dport));
-
- // find the device, and open usb connection
- pthread_mutex_lock(&usbmux_mutex);
- phone = NULL;
- cur_dev = NULL;
- // first check if we already have an open connection
- if (devices) {
- for (i = 0; i < device_count; i++) {
- if (devices[i]) {
- if (devices[i]->device_id == c_req->device_id) {
- devices[i]->use_count++;
- cur_dev = devices[i];
- phone = cur_dev->phone;
- break;
- }
- }
+ pthread_mutex_unlock(&usb_mutex);
+
+ if (found <= 0) {
+ if (verbose >= 1)
+ logmsg(LOG_NOTICE,
+ "%s[%x]: No attached iPhone/iPod devices found.",
+ __func__, THREAD);
+ goto leave;
}
- }
- if (!phone) {
- // if not found, make a new connection
- if (verbose >= 2) logmsg(LOG_NOTICE, "%s[%x]: creating new usb connection, device_id=%d", __func__, THREAD, c_req->device_id);
- pthread_mutex_lock(&usb_mutex);
- if (usbmux_get_specific_device(0, c_req->device_id, &phone) < 0) {
- pthread_mutex_unlock(&usb_mutex);
- pthread_mutex_unlock(&usbmux_mutex);
- if (verbose >= 1) logmsg(LOG_ERR, "%s[%x]: device_id %d could not be opened", __func__, THREAD, c_req->device_id);
- usbmuxd_send_result(cdata->socket, c_req->header.tag, ENODEV);
- goto leave;
+ if (verbose >= 3)
+ logmsg(LOG_NOTICE, "%s[%x]: Waiting for connect request", __func__,
+ THREAD);
+
+ // now wait for connect request
+ //memset(&c_req, 0, sizeof(c_req));
+ if ((recv_len =
+ usbmuxd_get_request(cdata->socket, (void **) &c_req, 0)) <= 0) {
+ if (verbose >= 3)
+ logmsg(LOG_NOTICE,
+ "%s[%x]: Did not receive any connect request.",
+ __func__, THREAD);
+ goto leave;
}
- pthread_mutex_unlock(&usb_mutex);
-
- // create device object
- if (verbose >= 3) logmsg(LOG_DEBUG, "%s[%x]: add to device list", __func__, THREAD);
- cur_dev = (struct device_info*)malloc(sizeof(struct device_info));
- memset(cur_dev, 0, sizeof(struct device_info));
- cur_dev->use_count = 1;
- cur_dev->device_id = c_req->device_id;
- cur_dev->phone = phone;
- cur_dev->bulk_reader = 0;
- pthread_mutex_init(&cur_dev->mutex, NULL);
- pthread_mutex_init(&cur_dev->writer_mutex, NULL);
-
- if (verbose >= 3) logmsg(LOG_DEBUG, "%s[%x]: device_count = %d", __func__, THREAD, device_count);
-
- // add to list of devices
- devices = (struct device_info**)realloc(devices, sizeof(struct device_info*) * (device_count+1));
+
+ connect:
+
+ if (c_req->header.type != USBMUXD_CONNECT) {
+ if (verbose >= 2)
+ logmsg(LOG_ERR,
+ "%s[%x]: Unexpected packet of type %d received.",
+ __func__, THREAD, c_req->header.type);
+ goto leave;
+ }
+
+ if (verbose >= 3)
+ logmsg(LOG_NOTICE,
+ "%s[%x]: Setting up connection to usb device #%d on port %d",
+ __func__, THREAD, c_req->device_id,
+ ntohs(c_req->tcp_dport));
+
+ // find the device, and open usb connection
+ pthread_mutex_lock(&usbmux_mutex);
+ phone = NULL;
+ cur_dev = NULL;
+ // first check if we already have an open connection
if (devices) {
- devices[device_count] = cur_dev;
- device_count++;
+ for (i = 0; i < device_count; i++) {
+ if (devices[i]) {
+ if (devices[i]->device_id == c_req->device_id) {
+ devices[i]->use_count++;
+ cur_dev = devices[i];
+ phone = cur_dev->phone;
+ break;
+ }
+ }
+ }
+ }
+ if (!phone) {
+ // if not found, make a new connection
+ if (verbose >= 2)
+ logmsg(LOG_NOTICE,
+ "%s[%x]: creating new usb connection, device_id=%d",
+ __func__, THREAD, c_req->device_id);
+
+ pthread_mutex_lock(&usb_mutex);
+ if (usbmux_get_specific_device(0, c_req->device_id, &phone) < 0) {
+ pthread_mutex_unlock(&usb_mutex);
+ pthread_mutex_unlock(&usbmux_mutex);
+ if (verbose >= 1)
+ logmsg(LOG_ERR, "%s[%x]: device_id %d could not be opened",
+ __func__, THREAD, c_req->device_id);
+ usbmuxd_send_result(cdata->socket, c_req->header.tag, ENODEV);
+ goto leave;
+ }
+ pthread_mutex_unlock(&usb_mutex);
+
+ // create device object
+ if (verbose >= 3)
+ logmsg(LOG_DEBUG, "%s[%x]: add to device list", __func__,
+ THREAD);
+ cur_dev =
+ (struct device_info *) malloc(sizeof(struct device_info));
+ memset(cur_dev, 0, sizeof(struct device_info));
+ cur_dev->use_count = 1;
+ cur_dev->device_id = c_req->device_id;
+ cur_dev->phone = phone;
+ cur_dev->bulk_reader = 0;
+ pthread_mutex_init(&cur_dev->mutex, NULL);
+ pthread_mutex_init(&cur_dev->writer_mutex, NULL);
+
+ if (verbose >= 3)
+ logmsg(LOG_DEBUG, "%s[%x]: device_count = %d", __func__,
+ THREAD, device_count);
+
+ // add to list of devices
+ devices =
+ (struct device_info **) realloc(devices,
+ sizeof(struct device_info *) *
+ (device_count + 1));
+ if (devices) {
+ devices[device_count] = cur_dev;
+ device_count++;
+ }
+ } else {
+ if (verbose >= 2)
+ logmsg(LOG_NOTICE,
+ "%s[%x]: reusing usb connection, device_id=%d",
+ __func__, THREAD, c_req->device_id);
}
- } else {
- if (verbose >= 2) logmsg(LOG_NOTICE, "%s[%x]: reusing usb connection, device_id=%d", __func__, THREAD, c_req->device_id);
- }
- pthread_mutex_unlock(&usbmux_mutex);
+ pthread_mutex_unlock(&usbmux_mutex);
- // setup connection to iPhone/iPod
+ // setup connection to iPhone/iPod
// pthread_mutex_lock(&usbmux_mutex);
- res = usbmux_new_client(cur_dev->phone, 0, ntohs(c_req->tcp_dport), &(cdata->muxclient));
+ res =
+ usbmux_new_client(cur_dev->phone, 0, ntohs(c_req->tcp_dport),
+ &(cdata->muxclient));
// pthread_mutex_unlock(&usbmux_mutex);
- if (res != 0) {
- usbmuxd_send_result(cdata->socket, c_req->header.tag, res);
- if (verbose >= 1) logmsg(LOG_ERR, "%s[%x]: mux_new_client returned %d, aborting.", __func__, THREAD, res);
- goto leave;
- }
-
- // start bulk reader thread (once per device)
- pthread_mutex_lock(&cur_dev->mutex);
- if (cur_dev->bulk_reader == 0) {
- pthread_create(&cur_dev->bulk_reader, NULL, usbmuxd_bulk_reader_thread, cur_dev);
- }
- pthread_mutex_unlock(&cur_dev->mutex);
-
- // start connection handler thread
- cdata->handler_dead = 0;
- cdata->tag = c_req->header.tag;
- cdata->dev = cur_dev;
- if (pthread_create(&cdata->handler, NULL, usbmuxd_client_handler_thread, cdata) != 0) {
- if (verbose >= 1) logmsg(LOG_ERR, "%s[%x]: could not create usbmuxd_client_handler_thread!", __func__, THREAD);
- cdata->handler = 0;
- goto leave;
- }
-
- // wait for handler thread to finish its work
- if (cdata->handler != 0) {
- pthread_join(cdata->handler, NULL);
- }
-
- if (verbose >= 2) logmsg(LOG_NOTICE, "%s[%x]: closing connection", __func__, THREAD);
-
- // time to clean up
- if (cdata && cdata->muxclient) { // should be non-NULL
- usbmux_free_client(cdata->muxclient);
- }
-
-leave:
- if (verbose >= 3) logmsg(LOG_NOTICE, "%s[%x]: terminating", __func__, THREAD);
-
- if (s_req) {
- free(s_req);
- }
- if (c_req) {
- free(c_req);
- }
-
- // this has to be freed only if it's not in use anymore as it closes
- // the USB connection
- pthread_mutex_lock(&usbmux_mutex);
- if (cur_dev) {
+ if (res != 0) {
+ usbmuxd_send_result(cdata->socket, c_req->header.tag, res);
+ if (verbose >= 1)
+ logmsg(LOG_ERR,
+ "%s[%x]: mux_new_client returned %d, aborting.",
+ __func__, THREAD, res);
+ goto leave;
+ }
+ // start bulk reader thread (once per device)
pthread_mutex_lock(&cur_dev->mutex);
- if (cur_dev->use_count > 1) {
- if (verbose >= 2) logmsg(LOG_NOTICE, "%s[%x]: decreasing device use count (from %d to %d)", __func__, THREAD, cur_dev->use_count, cur_dev->use_count-1);
- cur_dev->use_count--;
- pthread_mutex_unlock(&cur_dev->mutex);
- } else {
- if (verbose >= 2) logmsg(LOG_NOTICE, "%s[%x]: last client disconnected, cleaning up", __func__, THREAD);
- cur_dev->use_count = 0;
- pthread_mutex_unlock(&cur_dev->mutex);
- if (cur_dev->bulk_reader != 0) {
- if (verbose >= 3) logmsg(LOG_NOTICE, "%s[%x]: joining bulk_reader...", __func__, THREAD);
- pthread_join(cur_dev->bulk_reader, NULL);
- }
- pthread_mutex_lock(&usb_mutex);
- usbmux_free_device(cur_dev->phone);
- pthread_mutex_unlock(&usb_mutex);
- pthread_mutex_destroy(&cur_dev->writer_mutex);
- pthread_mutex_destroy(&cur_dev->mutex);
- free(cur_dev);
- cur_dev = NULL;
- if (device_count > 1) {
- struct device_info **newlist;
- int j;
-
- newlist = (struct device_info**)malloc(sizeof(struct device_info*) * device_count-1);
- for (i = 0; i < device_count; i++) {
- if (devices[i] != NULL) {
- newlist[j++] = devices[i];
- }
+ if (cur_dev->bulk_reader == 0) {
+ pthread_create(&cur_dev->bulk_reader, NULL,
+ usbmuxd_bulk_reader_thread, cur_dev);
+ }
+ pthread_mutex_unlock(&cur_dev->mutex);
+
+ // start connection handler thread
+ cdata->handler_dead = 0;
+ cdata->tag = c_req->header.tag;
+ cdata->dev = cur_dev;
+ if (pthread_create
+ (&cdata->handler, NULL, usbmuxd_client_handler_thread, cdata) != 0)
+ {
+ if (verbose >= 1)
+ logmsg(LOG_ERR,
+ "%s[%x]: could not create usbmuxd_client_handler_thread!",
+ __func__, THREAD);
+ cdata->handler = 0;
+ goto leave;
+ }
+ // wait for handler thread to finish its work
+ if (cdata->handler != 0) {
+ pthread_join(cdata->handler, NULL);
+ }
+
+ if (verbose >= 2)
+ logmsg(LOG_NOTICE, "%s[%x]: closing connection", __func__, THREAD);
+
+ // time to clean up
+ if (cdata && cdata->muxclient) { // should be non-NULL
+ usbmux_free_client(cdata->muxclient);
+ }
+
+ leave:
+ if (verbose >= 3)
+ logmsg(LOG_NOTICE, "%s[%x]: terminating", __func__, THREAD);
+
+ if (s_req) {
+ free(s_req);
+ }
+ if (c_req) {
+ free(c_req);
+ }
+ // this has to be freed only if it's not in use anymore as it closes
+ // the USB connection
+ pthread_mutex_lock(&usbmux_mutex);
+ if (cur_dev) {
+ pthread_mutex_lock(&cur_dev->mutex);
+ if (cur_dev->use_count > 1) {
+ if (verbose >= 2)
+ logmsg(LOG_NOTICE,
+ "%s[%x]: decreasing device use count (from %d to %d)",
+ __func__, THREAD, cur_dev->use_count,
+ cur_dev->use_count - 1);
+ cur_dev->use_count--;
+ pthread_mutex_unlock(&cur_dev->mutex);
+ } else {
+ if (verbose >= 2)
+ logmsg(LOG_NOTICE,
+ "%s[%x]: last client disconnected, cleaning up",
+ __func__, THREAD);
+ cur_dev->use_count = 0;
+ pthread_mutex_unlock(&cur_dev->mutex);
+ if (cur_dev->bulk_reader != 0) {
+ if (verbose >= 3)
+ logmsg(LOG_NOTICE, "%s[%x]: joining bulk_reader...",
+ __func__, THREAD);
+ pthread_join(cur_dev->bulk_reader, NULL);
+ }
+ pthread_mutex_lock(&usb_mutex);
+ usbmux_free_device(cur_dev->phone);
+ pthread_mutex_unlock(&usb_mutex);
+ pthread_mutex_destroy(&cur_dev->writer_mutex);
+ pthread_mutex_destroy(&cur_dev->mutex);
+ free(cur_dev);
+ cur_dev = NULL;
+ if (device_count > 1) {
+ struct device_info **newlist;
+ int j;
+
+ newlist =
+ (struct device_info **)
+ malloc(sizeof(struct device_info *)
+ * device_count - 1);
+ for (i = 0; i < device_count; i++) {
+ if (devices[i] != NULL) {
+ newlist[j++] = devices[i];
+ }
+ }
+ free(devices);
+ devices = newlist;
+ device_count--;
+ } else {
+ free(devices);
+ devices = NULL;
+ device_count = 0;
+ }
}
- free(devices);
- devices = newlist;
- device_count--;
- } else {
- free(devices);
- devices = NULL;
- device_count = 0;
- }
}
- }
- pthread_mutex_unlock(&usbmux_mutex);
+ pthread_mutex_unlock(&usbmux_mutex);
+
+ cdata->dead = 1;
+ close(cdata->socket);
- cdata->dead = 1;
- close(cdata->socket);
-
- if (verbose >= 3) logmsg(LOG_NOTICE, "%s[%x]: terminated", __func__, THREAD);
+ if (verbose >= 3)
+ logmsg(LOG_NOTICE, "%s[%x]: terminated", __func__, THREAD);
- return NULL;
+ return NULL;
}
/**
@@ -807,44 +962,42 @@ leave:
*/
static int daemonize()
{
- pid_t pid;
- pid_t sid;
+ pid_t pid;
+ pid_t sid;
- // already a daemon
- if (getppid() == 1) return 0;
+ // already a daemon
+ if (getppid() == 1)
+ return 0;
- pid = fork();
- if (pid < 0) {
- exit(EXIT_FAILURE);
- }
-
- if (pid > 0) {
- // exit parent process
- exit(EXIT_SUCCESS);
- }
-
- // At this point we are executing as the child process
-
- // Change the file mode mask
- umask(0);
+ pid = fork();
+ if (pid < 0) {
+ exit(EXIT_FAILURE);
+ }
- // Create a new SID for the child process
- sid = setsid();
- if (sid < 0) {
- return -1;
- }
+ if (pid > 0) {
+ // exit parent process
+ exit(EXIT_SUCCESS);
+ }
+ // At this point we are executing as the child process
- // Change the current working directory.
- if ((chdir("/")) < 0) {
- return -2;
- }
+ // Change the file mode mask
+ umask(0);
- // Redirect standard files to /dev/null
- freopen("/dev/null", "r", stdin);
- freopen("/dev/null", "w", stdout);
- freopen("/dev/null", "w", stderr);
+ // Create a new SID for the child process
+ sid = setsid();
+ if (sid < 0) {
+ return -1;
+ }
+ // Change the current working directory.
+ if ((chdir("/")) < 0) {
+ return -2;
+ }
+ // Redirect standard files to /dev/null
+ freopen("/dev/null", "r", stdin);
+ freopen("/dev/null", "w", stdout);
+ freopen("/dev/null", "w", stderr);
- return 0;
+ return 0;
}
/**
@@ -852,56 +1005,57 @@ static int daemonize()
*/
static void clean_exit(int sig)
{
- if (sig == SIGINT) {
- if (verbose >= 1) fprintf(stderr, "CTRL+C pressed\n");
- }
- quit_flag = 1;
+ if (sig == SIGINT) {
+ if (verbose >= 1)
+ fprintf(stderr, "CTRL+C pressed\n");
+ }
+ quit_flag = 1;
}
static void usage()
{
- printf("usage: usbmuxd [options]\n");
- printf("\t-h|--help print this message.\n");
- printf("\t-v|--verbose be verbose\n");
- printf("\t-f|--foreground do not daemonize\n");
- printf("\n");
+ printf("usage: usbmuxd [options]\n");
+ printf("\t-h|--help print this message.\n");
+ printf("\t-v|--verbose be verbose\n");
+ printf("\t-f|--foreground do not daemonize\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' },
- { "exit-on-no-devices", 0, NULL, 'e' },
- { NULL, 0, NULL, 0}
- };
- int c;
-
- while (1) {
- c = getopt_long(argc, argv, "hfve", longopts, (int *) 0);
- if (c == -1) {
- break;
- }
+ static struct option longopts[] = {
+ {"help", 0, NULL, 'h'},
+ {"foreground", 0, NULL, 'f'},
+ {"verbose", 0, NULL, 'v'},
+ {"exit-on-no-devices", 0, NULL, 'e'},
+ {NULL, 0, NULL, 0}
+ };
+ int c;
+
+ while (1) {
+ c = getopt_long(argc, argv, "hfve", longopts, (int *) 0);
+ if (c == -1) {
+ break;
+ }
- switch (c) {
- case 'h':
- usage();
- exit(0);
- case 'f':
- foreground = 1;
- break;
- case 'v':
- sock_stuff_set_verbose(++verbose);
- break;
- case 'e':
- exit_on_no_devices = 1;
- break;
- default:
- usage();
- exit(2);
+ switch (c) {
+ case 'h':
+ usage();
+ exit(0);
+ case 'f':
+ foreground = 1;
+ break;
+ case 'v':
+ sock_stuff_set_verbose(++verbose);
+ break;
+ case 'e':
+ exit_on_no_devices = 1;
+ break;
+ default:
+ usage();
+ exit(2);
+ }
}
- }
}
/**
@@ -911,26 +1065,25 @@ static void parse_opts(int argc, char **argv)
*/
static int devices_attached()
{
- struct usb_bus *bus;
- struct usb_device *dev;
- int res = 0;
-
- usb_init();
- usb_find_busses();
- usb_find_devices();
-
- for (bus = usb_get_busses(); bus; bus = bus->next) {
- for (dev = bus->devices; dev; dev = dev->next) {
- if (dev->descriptor.idVendor == 0x05ac
- && dev->descriptor.idProduct >= 0x1290
- && dev->descriptor.idProduct <= 0x1293)
- {
- res++;
- }
+ struct usb_bus *bus;
+ struct usb_device *dev;
+ int res = 0;
+
+ usb_init();
+ usb_find_busses();
+ usb_find_devices();
+
+ for (bus = usb_get_busses(); bus; bus = bus->next) {
+ for (dev = bus->devices; dev; dev = dev->next) {
+ if (dev->descriptor.idVendor == 0x05ac
+ && dev->descriptor.idProduct >= 0x1290
+ && dev->descriptor.idProduct <= 0x1293) {
+ res++;
+ }
+ }
}
- }
- return res;
+ return res;
}
/**
@@ -938,233 +1091,261 @@ static int devices_attached()
*/
int main(int argc, char **argv)
{
- struct sockaddr_un c_addr;
- socklen_t len = sizeof(struct sockaddr_un);
- struct client_data *cdata = NULL;
- struct client_data **children = NULL;
- int children_capacity = DEFAULT_CHILDREN_CAPACITY;
- int i;
- int result = 0;
- int cnt = 0;
- FILE *lfd = NULL;
- struct flock lock;
-
- parse_opts(argc, argv);
-
- argc -= optind;
- argv += optind;
-
- if (!foreground) {
- openlog("usbmuxd", LOG_PID, 0);
- }
-
- if (verbose >= 2) logmsg(LOG_NOTICE, "starting");
-
- // signal(SIGHUP, reload_conf); // none yet
- signal(SIGINT, clean_exit);
- signal(SIGQUIT, clean_exit);
- signal(SIGTERM, clean_exit);
- signal(SIGPIPE, SIG_IGN);
-
- // check for other running instance
- lfd = fopen(LOCKFILE, "r");
- if (lfd) {
- lock.l_type = 0;
- lock.l_whence = SEEK_SET;
- lock.l_start = 0;
- lock.l_len = 0;
- fcntl(fileno(lfd), F_GETLK, &lock);
- fclose(lfd);
- if (lock.l_type != F_UNLCK) {
- logmsg(LOG_NOTICE, "another instance is already running. exiting.");
- return -1;
+ struct sockaddr_un c_addr;
+ socklen_t len = sizeof(struct sockaddr_un);
+ struct client_data *cdata = NULL;
+ struct client_data **children = NULL;
+ int children_capacity = DEFAULT_CHILDREN_CAPACITY;
+ int i;
+ int result = 0;
+ int cnt = 0;
+ FILE *lfd = NULL;
+ struct flock lock;
+
+ parse_opts(argc, argv);
+
+ argc -= optind;
+ argv += optind;
+
+ if (!foreground) {
+ openlog("usbmuxd", LOG_PID, 0);
}
- }
- if (exit_on_no_devices) {
- if (devices_attached() <= 0) {
- logmsg(LOG_NOTICE, "no devices attached. exiting.");
- return 0;
+ if (verbose >= 2)
+ logmsg(LOG_NOTICE, "starting");
+
+ // signal(SIGHUP, reload_conf); // none yet
+ signal(SIGINT, clean_exit);
+ signal(SIGQUIT, clean_exit);
+ signal(SIGTERM, clean_exit);
+ signal(SIGPIPE, SIG_IGN);
+
+ // check for other running instance
+ lfd = fopen(LOCKFILE, "r");
+ if (lfd) {
+ lock.l_type = 0;
+ lock.l_whence = SEEK_SET;
+ lock.l_start = 0;
+ lock.l_len = 0;
+ fcntl(fileno(lfd), F_GETLK, &lock);
+ fclose(lfd);
+ if (lock.l_type != F_UNLCK) {
+ logmsg(LOG_NOTICE,
+ "another instance is already running. exiting.");
+ return -1;
+ }
}
- }
- fsock = create_unix_socket(USBMUXD_SOCKET_FILE);
- if (fsock < 0) {
- logmsg(LOG_ERR, "Could not create socket, exiting");
- if (!foreground) {
- closelog();
+ if (exit_on_no_devices) {
+ if (devices_attached() <= 0) {
+ logmsg(LOG_NOTICE, "no devices attached. exiting.");
+ return 0;
+ }
}
- return -1;
- }
- chmod(USBMUXD_SOCKET_FILE, 0666);
+ fsock = create_unix_socket(USBMUXD_SOCKET_FILE);
+ if (fsock < 0) {
+ logmsg(LOG_ERR, "Could not create socket, exiting");
+ if (!foreground) {
+ closelog();
+ }
+ return -1;
+ }
- if (verbose >= 3) usbmux_set_debug(1);
+ chmod(USBMUXD_SOCKET_FILE, 0666);
- if (!foreground) {
- if (daemonize() < 0) {
- fprintf(stderr, "usbmuxd: FATAL: Could not daemonize!\n");
- syslog(LOG_ERR, "FATAL: Could not daemonize!");
- closelog();
- exit(EXIT_FAILURE);
- }
- }
-
- // now open the lockfile and place the lock
- lfd = fopen(LOCKFILE, "w");
- if (lfd) {
- lock.l_type = F_WRLCK;
- lock.l_whence = SEEK_SET;
- lock.l_start = 0;
- lock.l_len = 0;
- if (fcntl(fileno(lfd), F_SETLK, &lock) == -1) {
- logmsg(LOG_ERR, "ERROR: lockfile locking failed!");
- }
- }
+ if (verbose >= 3)
+ usbmux_set_debug(1);
- // drop elevated privileges
- if (getuid() == 0 || geteuid() == 0) {
- struct passwd *pw = getpwnam("nobody");
- if (pw) {
- setuid(pw->pw_uid);
- } else {
- logmsg(LOG_ERR, "ERROR: Dropping privileges failed, check if user 'nobody' exists! Will now terminate.");
- exit(EXIT_FAILURE);
+ if (!foreground) {
+ if (daemonize() < 0) {
+ fprintf(stderr, "usbmuxd: FATAL: Could not daemonize!\n");
+ syslog(LOG_ERR, "FATAL: Could not daemonize!");
+ closelog();
+ exit(EXIT_FAILURE);
+ }
}
+ // now open the lockfile and place the lock
+ lfd = fopen(LOCKFILE, "w");
+ if (lfd) {
+ lock.l_type = F_WRLCK;
+ lock.l_whence = SEEK_SET;
+ lock.l_start = 0;
+ lock.l_len = 0;
+ if (fcntl(fileno(lfd), F_SETLK, &lock) == -1) {
+ logmsg(LOG_ERR, "ERROR: lockfile locking failed!");
+ }
+ }
+ // drop elevated privileges
+ if (getuid() == 0 || geteuid() == 0) {
+ struct passwd *pw = getpwnam("nobody");
+ if (pw) {
+ setuid(pw->pw_uid);
+ } else {
+ logmsg(LOG_ERR,
+ "ERROR: Dropping privileges failed, check if user 'nobody' exists! Will now terminate.");
+ exit(EXIT_FAILURE);
+ }
- // security check
- if (setuid(0) != -1) {
- logmsg(LOG_ERR, "ERROR: Failed to drop privileges properly!");
- exit(EXIT_FAILURE);
+ // security check
+ if (setuid(0) != -1) {
+ logmsg(LOG_ERR, "ERROR: Failed to drop privileges properly!");
+ exit(EXIT_FAILURE);
+ }
+ if (verbose >= 2)
+ logmsg(LOG_NOTICE, "Successfully dropped privileges");
}
- if (verbose >= 2) logmsg(LOG_NOTICE, "Successfully dropped privileges");
- }
-
- // Reserve space for 10 clients which should be enough. If not, the
- // buffer gets enlarged later.
- children = (struct client_data**)malloc(sizeof(struct client_data*) * children_capacity);
- if (!children) {
- logmsg(LOG_ERR, "Out of memory when allocating memory for child threads. Terminating.");
- if (!foreground) {
- closelog();
+ // Reserve space for 10 clients which should be enough. If not, the
+ // buffer gets enlarged later.
+ children =
+ (struct client_data **) malloc(sizeof(struct client_data *) *
+ children_capacity);
+ if (!children) {
+ logmsg(LOG_ERR,
+ "Out of memory when allocating memory for child threads. Terminating.");
+ if (!foreground) {
+ closelog();
+ }
+ exit(EXIT_FAILURE);
}
- exit(EXIT_FAILURE);
- }
- memset(children, 0, sizeof(struct client_data*) * children_capacity);
-
- if (verbose >= 2) logmsg(LOG_NOTICE, "waiting for connection");
- while (!quit_flag) {
- // Check the file descriptor before accepting a connection.
- // If no connection attempt is made, just repeat...
- result = check_fd(fsock, FD_READ, 1000);
- if (result <= 0) {
- if (result == 0) {
- // cleanup
- for (i = 0; i < children_capacity; i++) {
- if (children[i]) {
- if (children[i]->dead != 0) {
- pthread_join(children[i]->thread, NULL);
- if (verbose >= 3) logmsg(LOG_NOTICE, "reclaimed client thread (fd=%d)", children[i]->socket);
- free(children[i]);
- children[i] = NULL;
- cnt++;
+ memset(children, 0, sizeof(struct client_data *) * children_capacity);
+
+ if (verbose >= 2)
+ logmsg(LOG_NOTICE, "waiting for connection");
+ while (!quit_flag) {
+ // Check the file descriptor before accepting a connection.
+ // If no connection attempt is made, just repeat...
+ result = check_fd(fsock, FD_READ, 1000);
+ if (result <= 0) {
+ if (result == 0) {
+ // cleanup
+ for (i = 0; i < children_capacity; i++) {
+ if (children[i]) {
+ if (children[i]->dead != 0) {
+ pthread_join(children[i]->thread, NULL);
+ if (verbose >= 3)
+ logmsg(LOG_NOTICE,
+ "reclaimed client thread (fd=%d)",
+ children[i]->socket);
+ free(children[i]);
+ children[i] = NULL;
+ cnt++;
+ } else {
+ cnt = 0;
+ }
+ } else {
+ cnt++;
+ }
+ }
+
+ if ((children_capacity > DEFAULT_CHILDREN_CAPACITY)
+ && ((children_capacity - cnt) <=
+ DEFAULT_CHILDREN_CAPACITY)) {
+ children_capacity = DEFAULT_CHILDREN_CAPACITY;
+ children =
+ realloc(children,
+ sizeof(struct client_data *) *
+ children_capacity);
+ }
+ continue;
} else {
- cnt = 0;
+ if (verbose >= 3)
+ logmsg(LOG_ERR, "usbmuxd: select error: %s",
+ strerror(errno));
+ continue;
}
- } else {
- cnt++;
- }
}
- if ((children_capacity > DEFAULT_CHILDREN_CAPACITY)
- && ((children_capacity - cnt) <= DEFAULT_CHILDREN_CAPACITY)) {
- children_capacity = DEFAULT_CHILDREN_CAPACITY;
- children = realloc(children, sizeof(struct client_data*) * children_capacity);
+ cdata = (struct client_data *) malloc(sizeof(struct client_data));
+ memset(cdata, 0, sizeof(struct client_data));
+ if (!cdata) {
+ quit_flag = 1;
+ logmsg(LOG_ERR, "Error: Out of memory! Terminating.");
+ break;
}
- continue;
- } else {
- if (verbose >= 3) logmsg(LOG_ERR, "usbmuxd: select error: %s", strerror(errno));
- continue;
- }
- }
- cdata = (struct client_data*)malloc(sizeof(struct client_data));
- memset(cdata, 0, sizeof(struct client_data));
- if (!cdata) {
- quit_flag = 1;
- logmsg(LOG_ERR, "Error: Out of memory! Terminating.");
- break;
- }
-
- cdata->socket = accept(fsock, (struct sockaddr*)&c_addr, &len);
- if (cdata->socket < 0) {
- free(cdata);
- if (errno == EINTR) {
- continue;
- } else {
- if (verbose >= 3) logmsg(LOG_ERR, "Error in accept: %s", strerror(errno));
- continue;
- }
- }
+ cdata->socket = accept(fsock, (struct sockaddr *) &c_addr, &len);
+ if (cdata->socket < 0) {
+ free(cdata);
+ if (errno == EINTR) {
+ continue;
+ } else {
+ if (verbose >= 3)
+ logmsg(LOG_ERR, "Error in accept: %s",
+ strerror(errno));
+ continue;
+ }
+ }
- if (verbose >= 1) logmsg(LOG_NOTICE, "new client connected (fd=%d)", cdata->socket);
-
- // create client thread:
- if (pthread_create(&cdata->thread, NULL, usbmuxd_client_init_thread, cdata) == 0) {
- for (i = 0; i < children_capacity; i++) {
- if (children[i] == NULL) break;
- }
- if (i == children_capacity) {
- // enlarge buffer
- children_capacity++;
- children = realloc(children, sizeof(struct client_data*) * children_capacity);
- if (!children) {
- logmsg(LOG_ERR, "Out of memory when enlarging child thread buffer");
+ if (verbose >= 1)
+ logmsg(LOG_NOTICE, "new client connected (fd=%d)",
+ cdata->socket);
+
+ // create client thread:
+ if (pthread_create
+ (&cdata->thread, NULL, usbmuxd_client_init_thread, cdata) == 0)
+ {
+ for (i = 0; i < children_capacity; i++) {
+ if (children[i] == NULL)
+ break;
+ }
+ if (i == children_capacity) {
+ // enlarge buffer
+ children_capacity++;
+ children =
+ realloc(children,
+ sizeof(struct client_data *) *
+ children_capacity);
+ if (!children) {
+ logmsg(LOG_ERR,
+ "Out of memory when enlarging child thread buffer");
+ }
+ }
+ children[i] = cdata;
+ } else {
+ logmsg(LOG_ERR, "Failed to create client_init_thread.");
+ close(cdata->socket);
+ free(cdata);
+ cdata = NULL;
}
- }
- children[i] = cdata;
- } else {
- logmsg(LOG_ERR, "Failed to create client_init_thread.");
- close(cdata->socket);
- free(cdata);
- cdata = NULL;
}
- }
- if (verbose >= 3) logmsg(LOG_NOTICE, "terminating");
+ if (verbose >= 3)
+ logmsg(LOG_NOTICE, "terminating");
- // preparing for shutdown: wait for child threads to terminate (if any)
- if (verbose >= 2) logmsg(LOG_NOTICE, "waiting for child threads to terminate...");
- for (i = 0; i < children_capacity; i++) {
- if (children[i] != NULL) {
- pthread_join(children[i]->thread, NULL);
- free(children[i]);
- }
- }
+ // preparing for shutdown: wait for child threads to terminate (if any)
+ if (verbose >= 2)
+ logmsg(LOG_NOTICE, "waiting for child threads to terminate...");
+ for (i = 0; i < children_capacity; i++) {
+ if (children[i] != NULL) {
+ pthread_join(children[i]->thread, NULL);
+ free(children[i]);
+ }
+ }
- // delete the children set.
- free(children);
- children = NULL;
+ // delete the children set.
+ free(children);
+ children = NULL;
- if (fsock >= 0) {
- close(fsock);
- }
+ if (fsock >= 0) {
+ close(fsock);
+ }
- unlink(USBMUXD_SOCKET_FILE);
+ unlink(USBMUXD_SOCKET_FILE);
- // unlock lock file and close it.
- if (lfd) {
- lock.l_type = F_UNLCK;
- fcntl(fileno(lfd), F_SETLK, &lock);
- fclose(lfd);
- }
+ // unlock lock file and close it.
+ if (lfd) {
+ lock.l_type = F_UNLCK;
+ fcntl(fileno(lfd), F_SETLK, &lock);
+ fclose(lfd);
+ }
- if (verbose >= 1) logmsg(LOG_NOTICE, "usbmuxd: terminated");
- if (!foreground) {
- closelog();
- }
+ if (verbose >= 1)
+ logmsg(LOG_NOTICE, "usbmuxd: terminated");
+ if (!foreground) {
+ closelog();
+ }
- return 0;
+ return 0;
}
-
diff --git a/sock_stuff.c b/sock_stuff.c
index 43fdf0e..b51d6ba 100644
--- a/sock_stuff.c
+++ b/sock_stuff.c
@@ -17,270 +17,282 @@ static int verbose = 0;
void sock_stuff_set_verbose(int level)
{
- verbose = level;
+ verbose = level;
}
-int create_unix_socket (const char *filename)
+int create_unix_socket(const char *filename)
{
- struct sockaddr_un name;
- int sock;
- size_t size;
-
- // remove if still present
- unlink(filename);
-
- /* Create the socket. */
- sock = socket (PF_LOCAL, SOCK_STREAM, 0);
- if (sock < 0) {
- perror ("socket");
- return -1;
- }
-
- /* Bind a name to the socket. */
- name.sun_family = AF_LOCAL;
- strncpy (name.sun_path, filename, sizeof (name.sun_path));
- name.sun_path[sizeof (name.sun_path) - 1] = '\0';
-
- /* The size of the address is
- the offset of the start of the filename,
- plus its length,
- plus one for the terminating null byte.
- Alternatively you can just do:
- size = SUN_LEN (&name);
- */
- size = (offsetof (struct sockaddr_un, sun_path)
- + strlen (name.sun_path) + 1);
-
- if (bind (sock, (struct sockaddr *) &name, size) < 0) {
- perror("bind");
- close(sock);
- return -1;
- }
-
- if (listen(sock, 10) < 0) {
- perror("listen");
- close(sock);
- return -1;
- }
-
- return sock;
+ struct sockaddr_un name;
+ int sock;
+ size_t size;
+
+ // remove if still present
+ unlink(filename);
+
+ /* Create the socket. */
+ sock = socket(PF_LOCAL, SOCK_STREAM, 0);
+ if (sock < 0) {
+ perror("socket");
+ return -1;
+ }
+
+ /* Bind a name to the socket. */
+ name.sun_family = AF_LOCAL;
+ strncpy(name.sun_path, filename, sizeof(name.sun_path));
+ name.sun_path[sizeof(name.sun_path) - 1] = '\0';
+
+ /* The size of the address is
+ the offset of the start of the filename,
+ plus its length,
+ plus one for the terminating null byte.
+ Alternatively you can just do:
+ size = SUN_LEN (&name);
+ */
+ size = (offsetof(struct sockaddr_un, sun_path)
+ + strlen(name.sun_path) + 1);
+
+ if (bind(sock, (struct sockaddr *) &name, size) < 0) {
+ perror("bind");
+ close(sock);
+ return -1;
+ }
+
+ if (listen(sock, 10) < 0) {
+ perror("listen");
+ close(sock);
+ return -1;
+ }
+
+ return sock;
}
int connect_unix_socket(const char *filename)
{
- struct sockaddr_un name;
- int sfd = -1;
- size_t size;
- struct stat fst;
-
- // check if socket file exists...
- if (stat(filename, &fst) != 0) {
- if (verbose >= 2) fprintf(stderr, "%s: stat '%s': %s\n", __func__, filename, strerror(errno));
- return -1;
- }
-
- // ... and if it is a unix domain socket
- if (!S_ISSOCK(fst.st_mode)) {
- if (verbose >= 2) fprintf(stderr, "%s: File '%s' is not a socket!\n", __func__, filename);
- return -1;
- }
-
- // make a new socket
- if ((sfd = socket(PF_LOCAL, SOCK_STREAM, 0)) < 0) {
- if (verbose >= 2) fprintf(stderr, "%s: socket: %s\n", __func__, strerror(errno));
- return -1;
- }
-
- // and connect to 'filename'
- name.sun_family = AF_LOCAL;
- strncpy(name.sun_path, filename, sizeof(name.sun_path));
- name.sun_path[sizeof(name.sun_path) - 1] = 0;
-
- size = (offsetof (struct sockaddr_un, sun_path)
- + strlen (name.sun_path) + 1);
-
- if (connect(sfd, (struct sockaddr*)&name, size) < 0) {
- close(sfd);
- if (verbose >= 2) fprintf(stderr, "%s: connect: %s\n", __func__, strerror(errno));
- return -1;
- }
-
- return sfd;
+ struct sockaddr_un name;
+ int sfd = -1;
+ size_t size;
+ struct stat fst;
+
+ // check if socket file exists...
+ if (stat(filename, &fst) != 0) {
+ if (verbose >= 2)
+ fprintf(stderr, "%s: stat '%s': %s\n", __func__, filename,
+ strerror(errno));
+ return -1;
+ }
+ // ... and if it is a unix domain socket
+ if (!S_ISSOCK(fst.st_mode)) {
+ if (verbose >= 2)
+ fprintf(stderr, "%s: File '%s' is not a socket!\n", __func__,
+ filename);
+ return -1;
+ }
+ // make a new socket
+ if ((sfd = socket(PF_LOCAL, SOCK_STREAM, 0)) < 0) {
+ if (verbose >= 2)
+ fprintf(stderr, "%s: socket: %s\n", __func__, strerror(errno));
+ return -1;
+ }
+ // and connect to 'filename'
+ name.sun_family = AF_LOCAL;
+ strncpy(name.sun_path, filename, sizeof(name.sun_path));
+ name.sun_path[sizeof(name.sun_path) - 1] = 0;
+
+ size = (offsetof(struct sockaddr_un, sun_path)
+ + strlen(name.sun_path) + 1);
+
+ if (connect(sfd, (struct sockaddr *) &name, size) < 0) {
+ close(sfd);
+ if (verbose >= 2)
+ fprintf(stderr, "%s: connect: %s\n", __func__,
+ strerror(errno));
+ return -1;
+ }
+
+ return sfd;
}
int create_socket(uint16_t port)
{
- int sfd = -1;
- int yes = 1;
- struct sockaddr_in saddr;
-
- if ( 0 > ( sfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP) ) ) {
- perror("socket()");
- return -1;
- }
-
- if (setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1) {
- perror("setsockopt()");
- close(sfd);
- return -1;
- }
-
- memset((void *)&saddr, 0, sizeof(saddr));
- saddr.sin_family = AF_INET;
- saddr.sin_addr.s_addr = htonl(INADDR_ANY);
- saddr.sin_port = htons(port);
-
- if(0 > bind(sfd, (struct sockaddr *)&saddr , sizeof(saddr))) {
- perror("bind()");
- close(sfd);
- return -1;
- }
-
- if (listen(sfd, 1) == -1) {
- perror("listen()");
- close(sfd);
- return -1;
- }
-
- return sfd;
+ int sfd = -1;
+ int yes = 1;
+ struct sockaddr_in saddr;
+
+ if (0 > (sfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP))) {
+ perror("socket()");
+ return -1;
+ }
+
+ if (setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1) {
+ perror("setsockopt()");
+ close(sfd);
+ return -1;
+ }
+
+ memset((void *) &saddr, 0, sizeof(saddr));
+ saddr.sin_family = AF_INET;
+ saddr.sin_addr.s_addr = htonl(INADDR_ANY);
+ saddr.sin_port = htons(port);
+
+ if (0 > bind(sfd, (struct sockaddr *) &saddr, sizeof(saddr))) {
+ perror("bind()");
+ close(sfd);
+ return -1;
+ }
+
+ if (listen(sfd, 1) == -1) {
+ perror("listen()");
+ close(sfd);
+ return -1;
+ }
+
+ return sfd;
}
int connect_socket(const char *addr, uint16_t port)
{
- int sfd = -1;
- int yes = 1;
- struct hostent *hp;
- struct sockaddr_in saddr;
-
- if (!addr) {
- errno = EINVAL;
- return -1;
- }
-
- if ((hp = gethostbyname(addr)) == NULL) {
- if (verbose >= 2) fprintf(stderr, "%s: unknown host '%s'\n", __func__, addr);
- return -1;
- }
-
- if (!hp->h_addr) {
- if (verbose >= 2) fprintf(stderr, "%s: gethostbyname returned NULL address!\n", __func__);
- return -1;
- }
-
- if ( 0 > ( sfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP) ) ) {
- perror("socket()");
- return -1;
- }
-
- if (setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1) {
- perror("setsockopt()");
- close(sfd);
- return -1;
- }
-
- memset((void *)&saddr, 0, sizeof(saddr));
- saddr.sin_family = AF_INET;
- saddr.sin_addr.s_addr = *(uint32_t*)hp->h_addr;
- saddr.sin_port = htons(port);
-
- if (connect(sfd, (struct sockaddr*)&saddr, sizeof(saddr)) < 0) {
- perror("connect");
- close(sfd);
- return -2;
- }
-
- return sfd;
+ int sfd = -1;
+ int yes = 1;
+ struct hostent *hp;
+ struct sockaddr_in saddr;
+
+ if (!addr) {
+ errno = EINVAL;
+ return -1;
+ }
+
+ if ((hp = gethostbyname(addr)) == NULL) {
+ if (verbose >= 2)
+ fprintf(stderr, "%s: unknown host '%s'\n", __func__, addr);
+ return -1;
+ }
+
+ if (!hp->h_addr) {
+ if (verbose >= 2)
+ fprintf(stderr, "%s: gethostbyname returned NULL address!\n",
+ __func__);
+ return -1;
+ }
+
+ if (0 > (sfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP))) {
+ perror("socket()");
+ return -1;
+ }
+
+ if (setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1) {
+ perror("setsockopt()");
+ close(sfd);
+ return -1;
+ }
+
+ memset((void *) &saddr, 0, sizeof(saddr));
+ saddr.sin_family = AF_INET;
+ saddr.sin_addr.s_addr = *(uint32_t *) hp->h_addr;
+ saddr.sin_port = htons(port);
+
+ if (connect(sfd, (struct sockaddr *) &saddr, sizeof(saddr)) < 0) {
+ perror("connect");
+ close(sfd);
+ return -2;
+ }
+
+ return sfd;
}
int check_fd(int fd, fd_mode fdm, unsigned int timeout)
{
- fd_set fds;
- int sret;
- int eagain;
- struct timeval to;
-
- if (fd <= 0) {
- if (verbose >= 2) fprintf(stderr, "ERROR: invalid fd in check_fd %d\n", fd);
- return -1;
- }
-
- FD_ZERO(&fds);
- FD_SET(fd, &fds);
-
- to.tv_sec = (time_t)(timeout/1000);
- to.tv_usec = (time_t)((timeout-(to.tv_sec*1000))*1000);
-
- sret = -1;
-
- do {
- eagain = 0;
- switch(fdm) {
- case FD_READ:
- sret = select(fd+1,&fds,NULL,NULL,&to);
- break;
- case FD_WRITE:
- sret = select(fd+1,NULL,&fds,NULL,&to);
- break;
- case FD_EXCEPT:
- sret = select(fd+1,NULL,NULL,&fds,&to);
- break;
- default:
+ fd_set fds;
+ int sret;
+ int eagain;
+ struct timeval to;
+
+ if (fd <= 0) {
+ if (verbose >= 2)
+ fprintf(stderr, "ERROR: invalid fd in check_fd %d\n", fd);
return -1;
}
-
- if (sret < 0) {
- switch(errno) {
- case EINTR:
- // interrupt signal in select
- if (verbose >= 2) fprintf(stderr, "%s: EINTR\n", __func__);
- eagain = 1;
- break;
- case EAGAIN:
- if (verbose >= 2) fprintf(stderr, "%s: EAGAIN\n", __func__);
- break;
- default:
- if (verbose >= 2) fprintf(stderr, "%s: select failed: %s\n", __func__, strerror(errno));
- return -1;
- }
- }
- } while (eagain);
- return sret;
+ FD_ZERO(&fds);
+ FD_SET(fd, &fds);
+
+ to.tv_sec = (time_t) (timeout / 1000);
+ to.tv_usec = (time_t) ((timeout - (to.tv_sec * 1000)) * 1000);
+
+ sret = -1;
+
+ do {
+ eagain = 0;
+ switch (fdm) {
+ case FD_READ:
+ sret = select(fd + 1, &fds, NULL, NULL, &to);
+ break;
+ case FD_WRITE:
+ sret = select(fd + 1, NULL, &fds, NULL, &to);
+ break;
+ case FD_EXCEPT:
+ sret = select(fd + 1, NULL, NULL, &fds, &to);
+ break;
+ default:
+ return -1;
+ }
+
+ if (sret < 0) {
+ switch (errno) {
+ case EINTR:
+ // interrupt signal in select
+ if (verbose >= 2)
+ fprintf(stderr, "%s: EINTR\n", __func__);
+ eagain = 1;
+ break;
+ case EAGAIN:
+ if (verbose >= 2)
+ fprintf(stderr, "%s: EAGAIN\n", __func__);
+ break;
+ default:
+ if (verbose >= 2)
+ fprintf(stderr, "%s: select failed: %s\n", __func__,
+ strerror(errno));
+ return -1;
+ }
+ }
+ } while (eagain);
+
+ return sret;
}
int recv_buf(int fd, void *data, size_t length)
{
- return recv_buf_timeout(fd, data, length, 0, RECV_TIMEOUT);
+ return recv_buf_timeout(fd, data, length, 0, RECV_TIMEOUT);
}
int peek_buf(int fd, void *data, size_t length)
{
- return recv_buf_timeout(fd, data, length, MSG_PEEK, RECV_TIMEOUT);
+ return recv_buf_timeout(fd, data, length, MSG_PEEK, RECV_TIMEOUT);
}
-int recv_buf_timeout(int fd, void *data, size_t length, int flags, unsigned int timeout)
+int recv_buf_timeout(int fd, void *data, size_t length, int flags,
+ unsigned int timeout)
{
- int res;
- int result;
-
- // check if data is available
- res = check_fd(fd, FD_READ, timeout);
- if (res <= 0) {
- return res;
- }
-
- // if we get here, there _is_ data available
- result = recv(fd, data, length, flags);
- if (res > 0 && result == 0) {
- // but this is an error condition
- if (verbose >= 3) fprintf(stderr, "%s: fd=%d recv returned 0\n", __func__, fd);
- return -1;
- }
- return result;
+ int res;
+ int result;
+
+ // check if data is available
+ res = check_fd(fd, FD_READ, timeout);
+ if (res <= 0) {
+ return res;
+ }
+ // if we get here, there _is_ data available
+ result = recv(fd, data, length, flags);
+ if (res > 0 && result == 0) {
+ // but this is an error condition
+ if (verbose >= 3)
+ fprintf(stderr, "%s: fd=%d recv returned 0\n", __func__, fd);
+ return -1;
+ }
+ return result;
}
int send_buf(int fd, void *data, size_t length)
{
- return send(fd, data, length, 0);
+ return send(fd, data, length, 0);
}
-
diff --git a/sock_stuff.h b/sock_stuff.h
index b9766ba..190f7e1 100644
--- a/sock_stuff.h
+++ b/sock_stuff.h
@@ -3,11 +3,10 @@
#include <stdint.h>
-enum fd_mode
-{
- FD_READ,
- FD_WRITE,
- FD_EXCEPT
+enum fd_mode {
+ FD_READ,
+ FD_WRITE,
+ FD_EXCEPT
};
typedef enum fd_mode fd_mode;
@@ -19,11 +18,11 @@ int check_fd(int fd, fd_mode fdm, unsigned int timeout);
int recv_buf(int fd, void *data, size_t size);
int peek_buf(int fd, void *data, size_t size);
-int recv_buf_timeout(int fd, void *data, size_t size, int flags, unsigned int timeout);
+int recv_buf_timeout(int fd, void *data, size_t size, int flags,
+ unsigned int timeout);
int send_buf(int fd, void *data, size_t size);
void sock_stuff_set_verbose(int level);
-#endif /* __SOCK_STUFF_H */
-
+#endif /* __SOCK_STUFF_H */
diff --git a/usbmux.c b/usbmux.c
index 0a175ed..106c5ff 100644
--- a/usbmux.c
+++ b/usbmux.c
@@ -50,7 +50,7 @@ static const uint32_t WINDOW_MAX = 5 * 1024;
static const uint32_t WINDOW_INCREMENT = 512;
typedef struct {
- char* buffer;
+ char *buffer;
int leftover;
int capacity;
} receivebuf_t;
@@ -145,20 +145,20 @@ static void print_buffer(const char *data, const int length)
int j;
unsigned char c;
- for(i=0; i<length; i+=16) {
+ for (i = 0; i < length; i += 16) {
printf("%04x: ", i);
- for (j=0;j<16;j++) {
- if (i+j >= length) {
+ for (j = 0; j < 16; j++) {
+ if (i + j >= length) {
printf(" ");
continue;
}
- printf("%02hhx ", *(data+i+j));
+ printf("%02hhx ", *(data + i + j));
}
printf(" | ");
- for(j=0;j<16;j++) {
- if (i+j >= length)
+ for (j = 0; j < 16; j++) {
+ if (i + j >= length)
break;
- c = *(data+i+j);
+ c = *(data + i + j);
if ((c < 32) || (c > 127)) {
printf(".");
continue;
@@ -171,7 +171,7 @@ static void print_buffer(const char *data, const int length)
}
#endif
-void hton_header(usbmux_tcp_header *hdr)
+void hton_header(usbmux_tcp_header * hdr)
{
if (hdr) {
hdr->length = htonl(hdr->length);
@@ -181,7 +181,7 @@ void hton_header(usbmux_tcp_header *hdr)
}
}
-void ntoh_header(usbmux_tcp_header *hdr)
+void ntoh_header(usbmux_tcp_header * hdr)
{
if (hdr) {
hdr->length = ntohl(hdr->length);
@@ -197,7 +197,8 @@ void ntoh_header(usbmux_tcp_header *hdr)
*/
usbmux_version_header *version_header()
{
- usbmux_version_header *version = (usbmux_version_header *) malloc(sizeof(usbmux_version_header));
+ usbmux_version_header *version =
+ (usbmux_version_header *) malloc(sizeof(usbmux_version_header));
version->type = 0;
version->length = htonl(20);
version->major = htonl(1);
@@ -222,25 +223,34 @@ static int usbmux_config_usb_device(usbmux_device_t device)
#if 0
log_debug_msg("checking configuration...\n");
if (device->__device->config->bConfigurationValue != 3) {
- log_debug_msg("WARNING: usb device configuration is not 3 as expected!\n");
+ log_debug_msg
+ ("WARNING: usb device configuration is not 3 as expected!\n");
}
log_debug_msg("setting configuration...\n");
ret = usb_set_configuration(device->device, 3);
if (ret != 0) {
- log_debug_msg("Hm, usb_set_configuration returned %d: %s\n", ret, strerror(-ret));
+ log_debug_msg("Hm, usb_set_configuration returned %d: %s\n", ret,
+ strerror(-ret));
#if LIBUSB_HAS_GET_DRIVER_NP
log_debug_msg("trying to fix:\n");
log_debug_msg("-> detaching kernel driver... ");
- ret = usb_detach_kernel_driver_np(device->device, device->__device->config->interface->altsetting->bInterfaceNumber);
+ ret =
+ usb_detach_kernel_driver_np(device->device,
+ device->__device->config->
+ interface->altsetting->
+ bInterfaceNumber);
if (ret != 0) {
- log_debug_msg("usb_detach_kernel_driver_np returned %d: %s\n", ret, strerror(-ret));
+ log_debug_msg("usb_detach_kernel_driver_np returned %d: %s\n",
+ ret, strerror(-ret));
} else {
log_debug_msg("done.\n");
log_debug_msg("setting configuration again... ");
ret = usb_set_configuration(device->device, 3);
if (ret != 0) {
- log_debug_msg("Error: usb_set_configuration returned %d: %s\n", ret, strerror(-ret));
+ log_debug_msg
+ ("Error: usb_set_configuration returned %d: %s\n", ret,
+ strerror(-ret));
log_debug_msg("--> trying to continue anyway...\n");
} else {
log_debug_msg("done.\n");
@@ -257,7 +267,8 @@ static int usbmux_config_usb_device(usbmux_device_t device)
log_debug_msg("claiming interface... ");
ret = usb_claim_interface(device->usbdev, 1);
if (ret != 0) {
- log_debug_msg("Error: usb_claim_interface returned %d: %s\n", ret, strerror(-ret));
+ log_debug_msg("Error: usb_claim_interface returned %d: %s\n", ret,
+ strerror(-ret));
return -ENODEV;
} else {
log_debug_msg("done.\n");
@@ -266,7 +277,7 @@ static int usbmux_config_usb_device(usbmux_device_t device)
do {
bytes = usb_bulk_read(device->usbdev, BULKIN, buf, 512, 800);
} while (bytes > 0);
-
+
return 0;
}
@@ -283,7 +294,8 @@ static int usbmux_config_usb_device(usbmux_device_t device)
* descriptor on return.
* @return 0 if ok, otherwise a negative errno value.
*/
-int usbmux_get_specific_device(int bus_n, int dev_n, usbmux_device_t * device)
+int usbmux_get_specific_device(int bus_n, int dev_n,
+ usbmux_device_t * device)
{
struct usb_bus *bus;
struct usb_device *dev;
@@ -294,7 +306,8 @@ int usbmux_get_specific_device(int bus_n, int dev_n, usbmux_device_t * device)
if (!device || (device && *device))
return -EINVAL;
- usbmux_device_t newdevice = (usbmux_device_t) malloc(sizeof(struct usbmux_device_int));
+ usbmux_device_t newdevice =
+ (usbmux_device_t) malloc(sizeof(struct usbmux_device_int));
// Initialize the struct
newdevice->usbdev = NULL;
@@ -314,40 +327,49 @@ int usbmux_get_specific_device(int bus_n, int dev_n, usbmux_device_t * device)
// Set the device configuration
for (bus = usb_get_busses(); bus; bus = bus->next)
//if (bus->location == bus_n)
- for (dev = bus->devices; dev != NULL; dev = dev->next)
- if (dev->devnum == dev_n) {
- newdevice->__device = dev;
- newdevice->usbdev = usb_open(newdevice->__device);
- if (usbmux_config_usb_device(newdevice) == 0) {
- goto found;
- }
+ for (dev = bus->devices; dev != NULL; dev = dev->next)
+ if (dev->devnum == dev_n) {
+ newdevice->__device = dev;
+ newdevice->usbdev = usb_open(newdevice->__device);
+ if (usbmux_config_usb_device(newdevice) == 0) {
+ goto found;
}
+ }
usbmux_free_device(newdevice);
log_debug_msg("usbmux_get_specific_device: device not found\n");
return -ENODEV;
-found:
+ found:
// Send the version command to the device
version = version_header();
- bytes = usb_bulk_write(newdevice->usbdev, BULKOUT, (char *) version, sizeof(*version), 800);
+ bytes =
+ usb_bulk_write(newdevice->usbdev, BULKOUT, (char *) version,
+ sizeof(*version), 800);
if (bytes < 20) {
log_debug_msg("%s: libusb did NOT send enough!\n", __func__);
if (bytes < 0) {
- log_debug_msg("%s: libusb gave me the error %d: %s (%s)\n", __func__, bytes, usb_strerror(), strerror(-bytes));
+ log_debug_msg("%s: libusb gave me the error %d: %s (%s)\n",
+ __func__, bytes, usb_strerror(),
+ strerror(-bytes));
}
}
// Read the device's response
- bytes = usb_bulk_read(newdevice->usbdev, BULKIN, (char *) version, sizeof(*version), 800);
+ bytes =
+ usb_bulk_read(newdevice->usbdev, BULKIN, (char *) version,
+ sizeof(*version), 800);
// Check for bad response
if (bytes < 20) {
free(version);
usbmux_free_device(newdevice);
- log_debug_msg("%s: Invalid version message -- header too short.\n", __func__);
+ log_debug_msg("%s: Invalid version message -- header too short.\n",
+ __func__);
if (bytes < 0) {
- log_debug_msg("%s: libusb error message %d: %s (%s)\n", __func__, bytes, usb_strerror(), strerror(-bytes));
+ log_debug_msg("%s: libusb error message %d: %s (%s)\n",
+ __func__, bytes, usb_strerror(),
+ strerror(-bytes));
return bytes;
}
return -EBADMSG;
@@ -363,7 +385,8 @@ found:
// Bad header
usbmux_free_device(newdevice);
free(version);
- log_debug_msg("%s: Received a bad header/invalid version number.", __func__);
+ log_debug_msg("%s: Received a bad header/invalid version number.",
+ __func__);
return -EBADMSG;
}
@@ -371,7 +394,7 @@ found:
log_debug_msg("%s: Unknown error.\n", __func__);
usbmux_free_device(newdevice);
free(version);
- return -EBADMSG; // if it got to this point it's gotta be bad
+ return -EBADMSG; // if it got to this point it's gotta be bad
}
/** Cleans up an usbmux_device_t structure, then frees the structure itself.
@@ -435,25 +458,31 @@ int send_to_device(usbmux_device_t device, char *data, int datalen)
int bytes = 0;
#ifdef DEBUG
- #ifdef DEBUG_MORE
- printf("===============================\n%s: trying to send\n", __func__);
+#ifdef DEBUG_MORE
+ printf("===============================\n%s: trying to send\n",
+ __func__);
print_buffer(data, datalen);
printf("===============================\n");
- #endif
+#endif
#endif
do {
if (retrycount > 3) {
- log_debug_msg("EPIC FAIL! aborting on retry count overload.\n");
+ log_debug_msg
+ ("EPIC FAIL! aborting on retry count overload.\n");
return -ECOMM;
}
- bytes = usb_bulk_write(device->usbdev, BULKOUT, data, datalen, timeout);
+ bytes =
+ usb_bulk_write(device->usbdev, BULKOUT, data, datalen,
+ timeout);
if (bytes == -ETIMEDOUT) {
// timed out waiting for write.
log_debug_msg("usb_bulk_write timeout error.\n");
return bytes;
} else if (bytes < 0) {
- log_debug_msg("usb_bulk_write failed with error. err:%d (%s)(%s)\n", bytes, usb_strerror(), strerror(-bytes));
+ log_debug_msg
+ ("usb_bulk_write failed with error. err:%d (%s)(%s)\n",
+ bytes, usb_strerror(), strerror(-bytes));
return bytes;
} else if (bytes == 0) {
log_debug_msg("usb_bulk_write sent nothing. retrying.\n");
@@ -461,22 +490,24 @@ int send_to_device(usbmux_device_t device, char *data, int datalen)
retrycount++;
continue;
} else if (bytes < datalen) {
- log_debug_msg("usb_bulk_write failed to send full dataload. %d of %d\n", bytes, datalen);
+ log_debug_msg
+ ("usb_bulk_write failed to send full dataload. %d of %d\n",
+ bytes, datalen);
timeout = timeout * 4;
retrycount++;
data += bytes;
datalen -= bytes;
continue;
}
- } while(0); // fall out
+ } while (0); // fall out
#ifdef DEBUG
if (bytes > 0) {
if (toto_debug > 0) {
- printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
- printf("%s: sent to device\n", __func__);
- print_buffer(data, bytes);
- printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
+ printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
+ printf("%s: sent to device\n", __func__);
+ print_buffer(data, bytes);
+ printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
}
}
#endif
@@ -493,13 +524,16 @@ int send_to_device(usbmux_device_t device, char *data, int datalen)
*
* @return How many bytes were read in, or -1 on error.
*/
-int recv_from_device_timeout(usbmux_device_t device, char *data, int datalen, int timeoutmillis)
+int recv_from_device_timeout(usbmux_device_t device, char *data,
+ int datalen, int timeoutmillis)
{
if (!device)
return -EINVAL;
//log_debug_msg("%s: attempting to receive %i bytes\n", __func__, datalen);
- int bytes = usb_bulk_read(device->usbdev, BULKIN, data, datalen, timeoutmillis);
+ int bytes =
+ usb_bulk_read(device->usbdev, BULKIN, data, datalen,
+ timeoutmillis);
// There are some things which are errors, others which are no problem.
// It's not documented in libUSB, but it seems that the error values
// returned are just negated ERRNO values.
@@ -509,12 +543,14 @@ int recv_from_device_timeout(usbmux_device_t device, char *data, int datalen, in
// picked up any data. no problem.
return 0;
} else {
- fprintf(stderr, "%s: libusb gave me the error %d: %s (%s)\n", __func__, bytes, usb_strerror(), strerror(-bytes));
- log_debug_msg("%s: libusb gave me the error %d: %s (%s)\n", __func__, bytes, usb_strerror(), strerror(-bytes));
+ fprintf(stderr, "%s: libusb gave me the error %d: %s (%s)\n",
+ __func__, bytes, usb_strerror(), strerror(-bytes));
+ log_debug_msg("%s: libusb gave me the error %d: %s (%s)\n",
+ __func__, bytes, usb_strerror(),
+ strerror(-bytes));
}
return bytes;
}
-
#ifdef DEBUG
if (bytes > 0) {
if (toto_debug > 0) {
@@ -538,7 +574,8 @@ int recv_from_device_timeout(usbmux_device_t device, char *data, int datalen, in
*/
usbmux_tcp_header *new_mux_packet(uint16_t s_port, uint16_t d_port)
{
- usbmux_tcp_header *conn = (usbmux_tcp_header *) malloc(sizeof(usbmux_tcp_header));
+ usbmux_tcp_header *conn =
+ (usbmux_tcp_header *) malloc(sizeof(usbmux_tcp_header));
conn->type = htonl(6);
conn->length = HEADERLEN;
conn->sport = htons(s_port);
@@ -566,7 +603,9 @@ static void delete_connection(usbmux_client_t connection)
// update the global list of connections
if (clients > 1) {
- newlist = (usbmux_client_t *) malloc(sizeof(usbmux_client_t) * (clients - 1));
+ newlist =
+ (usbmux_client_t *) malloc(sizeof(usbmux_client_t) *
+ (clients - 1));
int i = 0, j = 0;
for (i = 0; i < clients; i++) {
if (connlist[i] == connection)
@@ -607,7 +646,9 @@ static void add_connection(usbmux_client_t connection)
{
pthread_mutex_lock(&usbmuxmutex);
usbmux_client_t *newlist =
- (usbmux_client_t *) realloc(connlist, sizeof(usbmux_client_t) * (clients + 1));
+ (usbmux_client_t *) realloc(connlist,
+ sizeof(usbmux_client_t) * (clients +
+ 1));
newlist[clients] = connection;
connlist = newlist;
clients++;
@@ -661,7 +702,8 @@ static uint16_t get_free_port()
* @param client A mux TCP header for the connection which is used for tracking and data transfer.
* @return 0 on success, a negative errno value otherwise.
*/
-int usbmux_new_client(usbmux_device_t device, uint16_t src_port, uint16_t dst_port, usbmux_client_t * client)
+int usbmux_new_client(usbmux_device_t device, uint16_t src_port,
+ uint16_t dst_port, usbmux_client_t * client)
{
if (!device || !dst_port)
return -EINVAL;
@@ -670,11 +712,11 @@ int usbmux_new_client(usbmux_device_t device, uint16_t src_port, uint16_t dst_po
if (!src_port) {
// this is a special case, if we get 0, this is not good, so
- return -EISCONN; // TODO: error code suitable?
+ return -EISCONN; // TODO: error code suitable?
}
-
// Initialize connection stuff
- usbmux_client_t new_connection = (usbmux_client_t) malloc(sizeof(struct usbmux_client_int));
+ usbmux_client_t new_connection =
+ (usbmux_client_t) malloc(sizeof(struct usbmux_client_int));
new_connection->header = new_mux_packet(src_port, dst_port);
// send TCP syn
@@ -682,7 +724,8 @@ int usbmux_new_client(usbmux_device_t device, uint16_t src_port, uint16_t dst_po
int err = 0;
new_connection->header->tcp_flags = TCP_SYN;
new_connection->header->length = new_connection->header->length;
- new_connection->header->length16 = new_connection->header->length16;
+ new_connection->header->length16 =
+ new_connection->header->length16;
new_connection->header->scnt = 0;
new_connection->header->ocnt = 0;
new_connection->device = device;
@@ -697,8 +740,12 @@ int usbmux_new_client(usbmux_device_t device, uint16_t src_port, uint16_t dst_po
new_connection->error = 0;
new_connection->cleanup = 0;
hton_header(new_connection->header);
- log_debug_msg("%s: send_to_device (%d --> %d)\n", __func__, ntohs(new_connection->header->sport), ntohs(new_connection->header->dport));
- err = send_to_device(device, (char *) new_connection->header, sizeof(usbmux_tcp_header));
+ log_debug_msg("%s: send_to_device (%d --> %d)\n", __func__,
+ ntohs(new_connection->header->sport),
+ ntohs(new_connection->header->dport));
+ err =
+ send_to_device(device, (char *) new_connection->header,
+ sizeof(usbmux_tcp_header));
if (err >= 0) {
*client = new_connection;
return 0;
@@ -732,7 +779,9 @@ int usbmux_free_client(usbmux_client_t client)
client->header->length16 = 0x1C;
hton_header(client->header);
- err = send_to_device(client->device, (char*)client->header, sizeof(usbmux_tcp_header));
+ err =
+ send_to_device(client->device, (char *) client->header,
+ sizeof(usbmux_tcp_header));
if (err < 0) {
log_debug_msg("%s: error sending TCP_FIN\n", __func__);
result = err;
@@ -762,7 +811,8 @@ int usbmux_free_client(usbmux_client_t client)
*
* @return 0 on success or a negative errno value on error.
*/
-int usbmux_send(usbmux_client_t client, const char *data, uint32_t datalen, uint32_t * sent_bytes)
+int usbmux_send(usbmux_client_t client, const char *data, uint32_t datalen,
+ uint32_t * sent_bytes)
{
if (!client->device || !client || !sent_bytes)
return -EINVAL;
@@ -781,7 +831,8 @@ int usbmux_send(usbmux_client_t client, const char *data, uint32_t datalen, uint
clock_gettime(CLOCK_REALTIME, &ts);
//ts.tv_sec += 1;
ts.tv_nsec += 750 * 1000;
- if (pthread_cond_timedwait(&client->wait, &client->mutex, &ts) == ETIMEDOUT) {
+ if (pthread_cond_timedwait(&client->wait, &client->mutex, &ts) ==
+ ETIMEDOUT) {
// timed out. optimistically grow the window and try to make progress
client->wr_window += WINDOW_INCREMENT;
}
@@ -791,7 +842,7 @@ int usbmux_send(usbmux_client_t client, const char *data, uint32_t datalen, uint
// client->scnt and client->ocnt should already be in host notation...
// we don't need to change them juuuust yet.
- char *buffer = (char *) malloc(blocksize + 2); // allow 2 bytes of safety padding
+ char *buffer = (char *) malloc(blocksize + 2); // allow 2 bytes of safety padding
// Set the length
client->header->length = blocksize;
client->header->length16 = blocksize;
@@ -802,7 +853,9 @@ int usbmux_send(usbmux_client_t client, const char *data, uint32_t datalen, uint
memcpy(buffer, client->header, sizeof(usbmux_tcp_header));
memcpy(buffer + sizeof(usbmux_tcp_header), data, datalen);
- log_debug_msg("%s: send_to_device(%d --> %d)\n", __func__, ntohs(client->header->sport), ntohs(client->header->dport));
+ log_debug_msg("%s: send_to_device(%d --> %d)\n", __func__,
+ ntohs(client->header->sport),
+ ntohs(client->header->dport));
sendresult = send_to_device(client->device, buffer, blocksize);
// Now that we've sent it off, we can clean up after our sloppy selves.
if (buffer)
@@ -812,7 +865,7 @@ int usbmux_send(usbmux_client_t client, const char *data, uint32_t datalen, uint
ntoh_header(client->header);
// update counts ONLY if the send succeeded.
- if ((uint32_t)sendresult == blocksize) {
+ if ((uint32_t) sendresult == blocksize) {
// Re-calculate scnt
client->header->scnt += datalen;
client->wr_window -= blocksize;
@@ -826,12 +879,14 @@ int usbmux_send(usbmux_client_t client, const char *data, uint32_t datalen, uint
return -ETIMEDOUT;
} else if (sendresult < 0) {
return sendresult;
- } else if ((uint32_t)sendresult == blocksize) {
+ } else if ((uint32_t) sendresult == blocksize) {
// actual number of data bytes sent.
*sent_bytes = sendresult - HEADERLEN;
return 0;
} else {
- fprintf(stderr, "usbsend managed to dump a packet that is not full size. %d of %d\n", sendresult, blocksize);
+ fprintf(stderr,
+ "usbsend managed to dump a packet that is not full size. %d of %d\n",
+ sendresult, blocksize);
return -EBADMSG;
}
}
@@ -844,14 +899,15 @@ int usbmux_send(usbmux_client_t client, const char *data, uint32_t datalen, uint
*
* @return number of bytes consumed (header + data)
*/
-uint32_t append_receive_buffer(usbmux_client_t client, char* packet)
+uint32_t append_receive_buffer(usbmux_client_t client, char *packet)
{
- if (client == NULL || packet == NULL) return 0;
+ if (client == NULL || packet == NULL)
+ return 0;
usbmux_tcp_header *header = (usbmux_tcp_header *) packet;
- char* data = &packet[HEADERLEN];
+ char *data = &packet[HEADERLEN];
uint32_t packetlen = ntohl(header->length);
- uint32_t datalen = packetlen-HEADERLEN;
+ uint32_t datalen = packetlen - HEADERLEN;
int dobroadcast = 0;
@@ -860,7 +916,7 @@ uint32_t append_receive_buffer(usbmux_client_t client, char* packet)
// we need to handle a few corner case tasks and book-keeping which
// falls on our responsibility because we are the ones reading in
// feedback.
- if (client->header->scnt == 0 && client->header->ocnt == 0 ) {
+ if (client->header->scnt == 0 && client->header->ocnt == 0) {
log_debug_msg("client is still waiting for handshake.\n");
if (header->tcp_flags == (TCP_SYN | TCP_ACK)) {
log_debug_msg("yes, got syn+ack ; replying with ack.\n");
@@ -872,9 +928,14 @@ uint32_t append_receive_buffer(usbmux_client_t client, char* packet)
hton_header(client->header);
// push it to USB
// TODO: need to check for error in the send here.... :(
- log_debug_msg("%s: send_to_device (%d --> %d)\n", __func__, ntohs(client->header->sport), ntohs(client->header->dport));
- if (send_to_device(client->device, (char *)client->header, sizeof(usbmux_tcp_header)) <= 0) {
- log_debug_msg("%s: error when pushing to usb...\n", __func__);
+ log_debug_msg("%s: send_to_device (%d --> %d)\n", __func__,
+ ntohs(client->header->sport),
+ ntohs(client->header->dport));
+ if (send_to_device
+ (client->device, (char *) client->header,
+ sizeof(usbmux_tcp_header)) <= 0) {
+ log_debug_msg("%s: error when pushing to usb...\n",
+ __func__);
}
// need to revert some of the fields back to host notation.
ntoh_header(client->header);
@@ -885,7 +946,6 @@ uint32_t append_receive_buffer(usbmux_client_t client, char* packet)
log_debug_msg("WOAH! client failed to get proper syn+ack.\n");
}
}
-
// update TCP counters and windows.
//
// save the window that we're getting from the USB device.
@@ -899,30 +959,33 @@ uint32_t append_receive_buffer(usbmux_client_t client, char* packet)
char e_msg[128];
e_msg[0] = 0;
if (datalen > 1) {
- memcpy(e_msg, data+1, datalen-1);
- e_msg[datalen-1] = 0;
+ memcpy(e_msg, data + 1, datalen - 1);
+ e_msg[datalen - 1] = 0;
}
// fetch the message
- switch(data[0]) {
- case 0:
- // this is not an error, it's just a status message.
- log_debug_msg("received status message: %s\n", e_msg);
- datalen = 0;
- break;
- case 1:
- log_debug_msg("received error message: %s\n", e_msg);
- datalen = 0;
- break;
- default:
- log_debug_msg("received unknown message (type 0x%02x): %s\n", data[0], e_msg);
- //datalen = 0; // <-- we let this commented out for testing
- break;
+ switch (data[0]) {
+ case 0:
+ // this is not an error, it's just a status message.
+ log_debug_msg("received status message: %s\n", e_msg);
+ datalen = 0;
+ break;
+ case 1:
+ log_debug_msg("received error message: %s\n", e_msg);
+ datalen = 0;
+ break;
+ default:
+ log_debug_msg
+ ("received unknown message (type 0x%02x): %s\n",
+ data[0], e_msg);
+ //datalen = 0; // <-- we let this commented out for testing
+ break;
}
} else {
- log_debug_msg("peer sent connection reset. setting error: %d\n", client->error);
+ log_debug_msg
+ ("peer sent connection reset. setting error: %d\n",
+ client->error);
}
}
-
// the packet's ocnt tells us how much of our data the device has received.
if (header->tcp_flags & TCP_ACK) {
// this is a hacky magic number condition. it seems that once
@@ -930,7 +993,7 @@ uint32_t append_receive_buffer(usbmux_client_t client, char* packet)
// number, we quickly fall into connection reset problems.
// Once we see the reported window size start falling off,
// ut off and wait for solid acks to come back.
- if (ntohs(header->window) < 256)
+ if (ntohs(header->window) < 256)
client->wr_window = 0;
// check what just got acked.
@@ -938,21 +1001,24 @@ uint32_t append_receive_buffer(usbmux_client_t client, char* packet)
// we got some kind of ack, but it hasn't caught up
// with the pending that have been sent.
pthread_cond_broadcast(&client->wr_wait);
- } else if (ntohl(header->ocnt) > /*client->wr_pending_scnt*/ client->header->scnt) {
- fprintf(stderr, "WTF?! acks overtook pending outstanding. %u,%u\n", ntohl(header->ocnt), client->wr_pending_scnt);
+ } else if (ntohl(header->ocnt) >
+ /*client->wr_pending_scnt */ client->header->scnt) {
+ fprintf(stderr,
+ "WTF?! acks overtook pending outstanding. %u,%u\n",
+ ntohl(header->ocnt), client->wr_pending_scnt);
} else {
// reset the window
client->wr_window = WINDOW_MAX;
pthread_cond_broadcast(&client->wr_wait);
}
}
-
// the packet's scnt will be our new ocnt.
client->header->ocnt = ntohl(header->scnt);
// ensure there is enough space, either by first malloc or realloc
if (datalen > 0) {
- log_debug_msg("%s: putting %d bytes into client's recv_buffer\n", __func__, datalen);
+ log_debug_msg("%s: putting %d bytes into client's recv_buffer\n",
+ __func__, datalen);
if (client->r_len == 0)
dobroadcast = 1;
@@ -960,7 +1026,8 @@ uint32_t append_receive_buffer(usbmux_client_t client, char* packet)
client->recv_buffer = malloc(datalen);
client->r_len = 0;
} else {
- client->recv_buffer = realloc(client->recv_buffer, client->r_len + datalen);
+ client->recv_buffer =
+ realloc(client->recv_buffer, client->r_len + datalen);
}
memcpy(&client->recv_buffer[client->r_len], data, datalen);
@@ -982,7 +1049,7 @@ uint32_t append_receive_buffer(usbmux_client_t client, char* packet)
* because we're only called from one location, pullbulk, where the lock
* is already held.
*/
-usbmux_client_t find_client(usbmux_tcp_header* recv_header)
+usbmux_client_t find_client(usbmux_tcp_header * recv_header)
{
// remember, as we're looking for the client, the receive header is
// coming from the USB into our client. This means that when we check
@@ -1017,17 +1084,19 @@ int usbmux_pullbulk(usbmux_device_t device)
return -EINVAL;
int res = 0;
- static const int DEFAULT_CAPACITY = 128*1024;
+ static const int DEFAULT_CAPACITY = 128 * 1024;
if (device->usbReceive.buffer == NULL) {
device->usbReceive.capacity = DEFAULT_CAPACITY;
device->usbReceive.buffer = malloc(device->usbReceive.capacity);
device->usbReceive.leftover = 0;
}
-
// start the cursor off just ahead of the leftover.
- char* cursor = &device->usbReceive.buffer[device->usbReceive.leftover];
+ char *cursor = &device->usbReceive.buffer[device->usbReceive.leftover];
// pull in content, note that the amount we can pull is capacity minus leftover
- int readlen = recv_from_device_timeout(device, cursor, device->usbReceive.capacity - device->usbReceive.leftover, 3000);
+ int readlen =
+ recv_from_device_timeout(device, cursor,
+ device->usbReceive.capacity -
+ device->usbReceive.leftover, 3000);
if (readlen < 0) {
res = readlen;
//fprintf(stderr, "recv_from_device_timeout gave us an error.\n");
@@ -1036,7 +1105,6 @@ int usbmux_pullbulk(usbmux_device_t device)
if (readlen > 0) {
//fprintf(stdout, "recv_from_device_timeout pulled an extra %d bytes\n", readlen);
}
-
// the amount of content we have to work with is the remainder plus
// what we managed to read
device->usbReceive.leftover += readlen;
@@ -1050,23 +1118,29 @@ int usbmux_pullbulk(usbmux_device_t device)
break;
usbmux_tcp_header *header = (usbmux_tcp_header *) cursor;
- log_debug_msg("%s: recv_from_device_timeout (%d --> %d)\n", __func__, ntohs(header->sport), ntohs(header->dport));
+ log_debug_msg("%s: recv_from_device_timeout (%d --> %d)\n",
+ __func__, ntohs(header->sport),
+ ntohs(header->dport));
// now that we have a header, check if there is sufficient data
// to construct a full packet, including its data
uint32_t packetlen = ntohl(header->length);
- if ((uint32_t)device->usbReceive.leftover < packetlen) {
- fprintf(stderr, "%s: not enough data to construct a full packet\n", __func__);
+ if ((uint32_t) device->usbReceive.leftover < packetlen) {
+ fprintf(stderr,
+ "%s: not enough data to construct a full packet\n",
+ __func__);
break;
}
-
// ok... find the client this packet will get stuffed to.
usbmux_client_t client = find_client(header);
if (client == NULL) {
- log_debug_msg("WARNING: client for packet cannot be found. dropping packet.\n");
+ log_debug_msg
+ ("WARNING: client for packet cannot be found. dropping packet.\n");
} else {
// stuff the data
- log_debug_msg("%s: found client, calling append_receive_buffer\n", __func__);
+ log_debug_msg
+ ("%s: found client, calling append_receive_buffer\n",
+ __func__);
append_receive_buffer(client, cursor);
// perhaps this is too general, == -ECONNRESET
@@ -1075,7 +1149,9 @@ int usbmux_pullbulk(usbmux_device_t device)
pthread_mutex_lock(&client->mutex);
if (client->cleanup) {
pthread_mutex_unlock(&client->mutex);
- log_debug_msg("freeing up connection (%d->%d)\n", ntohs(client->header->sport), ntohs(client->header->dport));
+ log_debug_msg("freeing up connection (%d->%d)\n",
+ ntohs(client->header->sport),
+ ntohs(client->header->dport));
delete_connection(client);
} else {
pthread_mutex_unlock(&client->mutex);
@@ -1096,9 +1172,10 @@ int usbmux_pullbulk(usbmux_device_t device)
//
// if there are no leftovers, we just leave the datastructure as is,
// and re-use the block next time.
- if (device->usbReceive.leftover > 0 && cursor != device->usbReceive.buffer) {
+ if (device->usbReceive.leftover > 0
+ && cursor != device->usbReceive.buffer) {
log_debug_msg("%s: we got a leftover, so handle it\n", __func__);
- char* newbuff = malloc(DEFAULT_CAPACITY);
+ char *newbuff = malloc(DEFAULT_CAPACITY);
memcpy(newbuff, cursor, device->usbReceive.leftover);
free(device->usbReceive.buffer);
device->usbReceive.buffer = newbuff;
@@ -1133,7 +1210,9 @@ int usbmux_get_error(usbmux_client_t client)
*
* @return 0 on success or a negative errno value on failure.
*/
-int usbmux_recv_timeout(usbmux_client_t client, char *data, uint32_t datalen, uint32_t * recv_bytes, int timeout)
+int usbmux_recv_timeout(usbmux_client_t client, char *data,
+ uint32_t datalen, uint32_t * recv_bytes,
+ int timeout)
{
if (!client || !data || datalen == 0 || !recv_bytes)
@@ -1147,15 +1226,15 @@ int usbmux_recv_timeout(usbmux_client_t client, char *data, uint32_t datalen, ui
if (timeout > 0 && (client->recv_buffer == NULL || client->r_len == 0)) {
struct timespec ts;
clock_gettime(CLOCK_REALTIME, &ts);
- ts.tv_sec += timeout/1000;
- ts.tv_nsec += (timeout-((int)(timeout/1000))*1000)*1000;
+ ts.tv_sec += timeout / 1000;
+ ts.tv_nsec += (timeout - ((int) (timeout / 1000)) * 1000) * 1000;
pthread_cond_timedwait(&client->wait, &client->mutex, &ts);
}
*recv_bytes = 0;
if (client->recv_buffer != NULL && client->r_len > 0) {
uint32_t foolen = datalen;
- if ((int)foolen > client->r_len)
+ if ((int) foolen > client->r_len)
foolen = client->r_len;
memcpy(data, client->recv_buffer, foolen);
*recv_bytes = foolen;
@@ -1163,7 +1242,7 @@ int usbmux_recv_timeout(usbmux_client_t client, char *data, uint32_t datalen, ui
// preserve any left-over unread amounts.
int remainder = client->r_len - foolen;
if (remainder > 0) {
- char* newbuf = malloc(remainder);
+ char *newbuf = malloc(remainder);
memcpy(newbuf, client->recv_buffer + foolen, remainder);
client->r_len = remainder;
free(client->recv_buffer);