diff options
| -rw-r--r-- | libusbmuxd.c | 138 | ||||
| -rw-r--r-- | main.c | 1875 | ||||
| -rw-r--r-- | sock_stuff.c | 470 | ||||
| -rw-r--r-- | sock_stuff.h | 15 | ||||
| -rw-r--r-- | usbmux.c | 325 |
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; } @@ -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 */ @@ -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); |