VPCD: partial rewrite of socket communication

- memory for buffer of received data is now reused with realloc
- internal functions now use a similar interface like recv/send/...
- added documentation about memory handling of vicc_getatr/vicc_transmit
- fixed transmit when using send in multiple passes

pcsc-relay/src/vpcd-driver.c

@@ -88,27 +88,32 @@ static int vpcd_transmit(driver_data_t *driver_data,
         const unsigned char *send, size_t send_len,
         unsigned char *recv, size_t *recv_len)
 {
-    char *rapdu;
+    unsigned char *rapdu = NULL;
-    int size = vicc_transmit(send_len, (char *) send, &rapdu);
+    int r = 0;
+    ssize_t size = vicc_transmit(send_len, send, &rapdu);
 
     if (size < 0) {
         RELAY_ERROR("could not send apdu or receive rapdu\n");
-        *recv_len = 0;
+        goto err;
-        return 0;
     }
 
     if (*recv_len < size) {
         RELAY_ERROR("Not enough memory for rapdu\n");
-        *recv_len = 0;
+        goto err;
-        free(rapdu);
-        return 0;
     }
 
-    *recv_len = size;
     memcpy(recv, rapdu, size);
+    *recv_len = size;
+
+    r = 1;
+
+err:
+    if (!r)
+        *recv_len = 0;
+
     free(rapdu);
 
-    return 1;
+    return r;
 }
 
 

virtualsmartcard/src/vpcd/ifd-vpcd.c

@@ -78,8 +78,12 @@ IFDHCloseChannel (DWORD Lun)
 RESPONSECODE
 IFDHGetCapabilities (DWORD Lun, DWORD Tag, PDWORD Length, PUCHAR Value)
 {
-    char *atr;
+    unsigned char *atr = NULL;
-    int size;
+    ssize_t size;
+
+    if (!Length || !Value)
+        return IFD_COMMUNICATION_ERROR;
+
     switch (Tag) {
         case TAG_IFD_ATR:
 
@@ -88,19 +92,23 @@ IFDHGetCapabilities (DWORD Lun, DWORD Tag, PDWORD Length, PUCHAR Value)
                 Log1(PCSC_LOG_ERROR, "could not get ATR");
                 return IFD_COMMUNICATION_ERROR;
             }
+            if (size == 0) {
+                Log1(PCSC_LOG_ERROR, "Virtual ICC removed");
+                return IFD_ICC_NOT_PRESENT;
+            }
             Log2(PCSC_LOG_DEBUG, "Got ATR (%d bytes)", size);
 
             if (*Length < size) {
+                free(atr);
                 Log1(PCSC_LOG_ERROR, "Not enough memory for ATR");
                 return IFD_COMMUNICATION_ERROR;
             }
 
-            /* Flawfinder: ignore */
             memcpy(Value, atr, size);
             *Length = size;
             free(atr);
-
             break;
+
         case TAG_IFD_SLOTS_NUMBER:
             if (*Length < 1) {
                 Log1(PCSC_LOG_ERROR, "Invalid input data");
@@ -109,8 +117,8 @@ IFDHGetCapabilities (DWORD Lun, DWORD Tag, PDWORD Length, PUCHAR Value)
 
             *Value  = 1;
             *Length = 1;
-
             break;
+
         default:
             Log2(PCSC_LOG_DEBUG, "unknown tag %d", (int)Tag);
             return IFD_ERROR_TAG;
@@ -179,34 +187,40 @@ IFDHTransmitToICC (DWORD Lun, SCARD_IO_HEADER SendPci, PUCHAR TxBuffer,
         DWORD TxLength, PUCHAR RxBuffer, PDWORD RxLength,
         PSCARD_IO_HEADER RecvPci)
 {
+    unsigned char *rapdu = NULL;
+    ssize_t size;
+    RESPONSECODE r = IFD_COMMUNICATION_ERROR;
+
     if (!RxLength || !RecvPci) {
         Log1(PCSC_LOG_ERROR, "Invalid input data");
-        return IFD_COMMUNICATION_ERROR;
+        goto err;
     }
 
-    char *rapdu;
+    size = vicc_transmit(TxLength, TxBuffer, &rapdu);
-    int size = vicc_transmit(TxLength, (char *) TxBuffer, &rapdu);
 
     if (size < 0) {
         Log1(PCSC_LOG_ERROR, "could not send apdu or receive rapdu");
-        *RxLength = 0;
+        goto err;
-        return IFD_COMMUNICATION_ERROR;
     }
 
     if (*RxLength < size) {
         Log1(PCSC_LOG_ERROR, "Not enough memory for rapdu");
-        *RxLength = 0;
+        goto err;
-        free(rapdu);
-        return IFD_COMMUNICATION_ERROR;
     }
 
-    (*RxLength) = size;
+    *RxLength = size;
-    /* Flawfinder: ignore */
     memcpy(RxBuffer, rapdu, size);
-    free(rapdu);
     RecvPci->Protocol = 1;
 
-    return IFD_SUCCESS;
+    r = IFD_SUCCESS;
+
+err:
+    if (r != IFD_SUCCESS)
+        *RxLength = 0;
+
+    free(rapdu);
+
+    return r;
 }
 
 RESPONSECODE

virtualsmartcard/src/vpcd/vpcd.c

@@ -16,19 +16,17 @@
  * You should have received a copy of the GNU General Public License along with
  * virtualsmartcard.  If not, see <http://www.gnu.org/licenses/>.
  */
+#include "vpcd.h"
 #include <arpa/inet.h>
+#include <errno.h>
 #include <stdint.h>
+#include <stdlib.h>
 #include <string.h>
 #include <sys/socket.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <unistd.h>
 
-
-#include <stdlib.h>
-
-#include "vpcd.h"
-
 #define VPCD_CTRL_LEN 	1
 
 #define VPCD_CTRL_OFF   0
@@ -36,144 +34,135 @@
 #define VPCD_CTRL_RESET 2
 #define VPCD_CTRL_ATR	4
 
-/*
- * First send length (unsigned integer in network byte order), then send the
- * message itself to the socket.
- */
-int sendToVICC(uint16_t size, const char* buffer);
-/*
- * Receive a message from icc
- */
-int recvFromVICC(char** buffer);
-
 static int server_sock = -1;
 static int client_sock = -1;
 
-/*
+ssize_t sendToVICC(size_t size, const unsigned char *buffer);
- * Send all size bytes from buffer to sock
+ssize_t recvFromVICC(unsigned char **buffer);
- */
+
-static int sendall(int sock, size_t size, const char* buffer);
+static int sendall(int sock, const void *buffer, size_t size);
-/*
+static ssize_t recvall(int sock, void *buffer, size_t size);
- * Receive size bytes from sock
+
- */
-static char* recvall(int sock, size_t size);
-/*
- * Open a TCP socket and listen.
- */
 static int opensock(unsigned short port);
 
 
-int sendall(int sock, size_t size, const char* buffer) {
+ssize_t sendall(int sock, const void *buffer, size_t size)
+{
     size_t sent = 0;
-    int i;
+    ssize_t r;
+
     while (sent < size) {
-        i = send(sock, buffer, size-sent, 0);
+        r = send(sock, buffer, size-sent, 0);
-        if (i < 0) return i;
+        if (r < 0)
-        sent += i;
+            return r;
+
+        sent += r;
+        buffer += r;
     }
-    return 0;
+
+    return sent;
 }
 
-char* recvall(int sock, size_t size) {
+ssize_t recvall(int sock, void *buffer, size_t size) {
-    char* buffer = (char*) malloc(size);
+    return recv(sock, buffer, size, MSG_WAITALL);
-    if (buffer == NULL) return NULL;
-
-    if (recv(sock, buffer, size, MSG_WAITALL) < size) {
-        free(buffer);
-        return NULL;
-    }
-    return buffer;
 }
 
 int opensock(unsigned short port)
 {
     int sock;
+    socklen_t yes = 1;
+    struct sockaddr_in server_sockaddr;
 
     sock = socket(AF_INET, SOCK_STREAM, 0);
-    if (sock < 0) return -1;
+    if (sock < 0)
+        return -1;
 
-	int i = 1;
+    if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof yes) != 0)
-	if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &i, sizeof(i)) < 0)
 		return -1;
 
-    struct sockaddr_in server_sockaddr;
     memset(&server_sockaddr, 0, sizeof server_sockaddr);
     server_sockaddr.sin_family      = PF_INET;
     server_sockaddr.sin_port        = htons(port);
     server_sockaddr.sin_addr.s_addr = htonl(INADDR_ANY);
 
-    if (bind(sock, (struct sockaddr*)&server_sockaddr,
+    if (bind(sock, (struct sockaddr *) &server_sockaddr,
-                sizeof server_sockaddr) < 0) return -1;
+                sizeof server_sockaddr) != 0)
+        return -1;
 
-    if (listen(sock, 0) < 0) return -1;
+    if (listen(sock, 0) != 0)
+        return -1;
 
     return sock;
 }
 
-int waitforclient(int server, long int secs, long int usecs) {
+int waitforclient(int server, long secs, long usecs)
-    int sock = 0;
+{
-
     fd_set rfds;
+    struct sockaddr_in client_sockaddr;
+    socklen_t client_socklen = sizeof client_sockaddr;
+    struct timeval tv;
+
     FD_ZERO(&rfds);
     FD_SET(server, &rfds);
 
-    /* Wait up to one microsecond. */
-    struct timeval tv;
     tv.tv_sec = secs;
     tv.tv_usec = usecs;
 
-    if (select(server+1, &rfds, NULL, NULL, &tv) < 0) return -1;
+    if (select(server+1, &rfds, NULL, NULL, &tv) == -1)
+        return -1;
 
-    if (FD_ISSET(server, &rfds)) {
+    if (FD_ISSET(server, &rfds))
-        struct sockaddr_in client_sockaddr;
+        return accept(server, (struct sockaddr *) &client_sockaddr,
-        socklen_t client_socklen = sizeof client_sockaddr;
-        sock = accept(server,
-                (struct sockaddr*)&client_sockaddr,
                 &client_socklen);
-    }
-
-    return sock;
-}
-
-int sendToVICC(uint16_t size, const char* buffer) {
-    /* send size of message */
-    uint16_t i = htons(size);
-    i = sendall(client_sock, sizeof i, (char *) &i);
-    if (i<0) {
-        vicc_eject();
-        return i;
-    }
-    /* send message */
-    i = sendall(client_sock, size, buffer);
-    if (i<0) {
-        vicc_eject();
-        return i;
-    }
 
     return 0;
 }
 
-/*
+ssize_t sendToVICC(size_t length, const unsigned char* buffer)
- * Receive a message from icc
+{
- */
+    ssize_t r;
-int recvFromVICC(char** buffer) {
+    uint16_t size;
-    /* receive size of message on LENLEN bytes */
+
-    uint16_t *p = (uint16_t *) recvall(client_sock, sizeof *p);
+    /* send size of message on 2 bytes */
-    if (p == NULL) {
+    size = htons(length);
+    r = sendall(client_sock, (void *) &size, sizeof size);
+    if (r == sizeof size)
+        /* send message */
+        r = sendall(client_sock, buffer, length);
+
+    if (r < 0)
         vicc_eject();
+
+    return r;
+}
+
+ssize_t recvFromVICC(unsigned char **buffer)
+{
+    ssize_t r;
+    uint16_t size;
+    unsigned char *p = NULL;
+
+    if (!buffer) {
+        errno = EINVAL;
         return -1;
     }
-    uint16_t size = ntohs(*p);
+
-    free(p);
+    /* receive size of message on 2 bytes */
+    r = recvall(client_sock, &size, sizeof size);
+    if (r < sizeof size)
+        return r;
+
+    size = ntohs(size);
+
+    p = realloc(*buffer, size);
+    if (p == NULL) {
+        errno = ENOMEM;
+        return -1;
+    }
+    *buffer = p;
 
     /* receive message */
-    *buffer = recvall(client_sock, size);
+    return recvall(client_sock, *buffer, size);
-    if (*buffer == NULL) {
-        vicc_eject();
-        return -1;
-    }
-
-    return size;
 }
 
 int vicc_eject(void) {
@@ -203,22 +192,36 @@ int vicc_exit(void) {
     return 0;
 }
 
-int vicc_transmit(int apdu_len, const char *apdu, char **rapdu) {
+ssize_t vicc_transmit(size_t apdu_len,
-    if (sendToVICC(apdu_len, apdu) < 0) return -1;
+        const unsigned char *apdu, unsigned char **rapdu)
+{
+    ssize_t r;
 
-    return recvFromVICC(rapdu);
+    r = sendToVICC(apdu_len, apdu);
+
+    if (r > 0)
+        r = recvFromVICC(rapdu);
+
+    if (r <= 0)
+        vicc_eject();
+
+    return r;
 }
 
 int vicc_present(void) {
+    unsigned char *atr = NULL;
+
     if (client_sock > 0) {
-        char *atr = NULL;
+        if (vicc_getatr(&atr) <= 0)
-        if (vicc_getatr(&atr) < 0)
             return 0;
+
         free(atr);
+
         return 1;
     } else {
         /* Wait up to one microsecond. */
         client_sock = waitforclient(server_sock, 0, 1);
+
         if (client_sock < 0)
             return -1;
     }
@@ -226,7 +229,7 @@ int vicc_present(void) {
     return 0;
 }
 
-int vicc_getatr(char** atr) {
+ssize_t vicc_getatr(unsigned char **atr) {
     char i = VPCD_CTRL_ATR;
     return vicc_transmit(VPCD_CTRL_LEN, &i, atr);
 }

virtualsmartcard/src/vpcd/vpcd.h

@@ -19,25 +19,51 @@
 #ifndef _VPCD_H_
 #define _VPCD_H_
 
-#include <stdint.h>
+#include <unistd.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 
+/** Standard port of the virtual smart card reader */
 #define VPCDPORT 35963
 
-int vicc_eject(void);
 int vicc_init(unsigned short port);
 int vicc_exit(void);
-int vicc_transmit(int apdu_len, const char *apdu, char **rapdu);
+int vicc_eject(void);
-int vicc_getatr(char** atr);
+
 int vicc_present(void);
 int vicc_poweron(void);
 int vicc_poweroff(void);
 int vicc_reset(void);
 
+/**
+ * @brief Receive ATR from the virtual smart card.
+ *
+ * @param[in,out] atr ATR received. Memory will be reused (via \a realloc) and
+ *                    should be freed by the caller if no longer needed.
+ *
+ * @return On success, the call returns the number of bytes received.
+ *         On error, -1 is returned, and errno is set appropriately.
+ */
+ssize_t vicc_getatr(unsigned char** atr);
+
+/**
+ * @brief Send an APDU to the virtual smart card.
+ *
+ * @param[in]     apdu_len Number of bytes to send
+ * @param[in]     apdu     Data to be sent
+ * @param[in,out] rapdu    Data received. Memory will be reused (via \a
+ *                         realloc) and should be freed by the caller if no
+ *                         longer needed.
+ *
+ * @return On success, the call returns the number of bytes received.
+ *         On error, -1 is returned, and errno is set appropriately.
+ */
+ssize_t vicc_transmit(size_t apdu_len, const unsigned char *apdu,
+        unsigned char **rapdu);
+
 #ifdef  __cplusplus
 }
 #endif