void
LoadBlob_SYMMETRIC_KEY(UINT64 *offset, BYTE *blob, TCPA_SYMMETRIC_KEY *key)
{
LoadBlob_UINT32(offset, key->algId, blob);
LoadBlob_UINT16(offset, key->encScheme, blob);
LoadBlob_UINT16(offset, key->size, blob);
if (key->size > 0) {
LoadBlob(offset, key->size, blob, key->data);
} else {
key->data = NULL;
}
}
int
loadData(UINT64 *offset, TCSD_PACKET_TYPE data_type, void *data, int data_size, BYTE *blob)
{
switch (data_type) {
case TCSD_PACKET_TYPE_BYTE:
LoadBlob_BYTE(offset, *((BYTE *) (data)), blob);
break;
case TCSD_PACKET_TYPE_BOOL:
LoadBlob_BOOL(offset, *((TSS_BOOL *) (data)), blob);
break;
case TCSD_PACKET_TYPE_UINT16:
LoadBlob_UINT16(offset, *((UINT16 *) (data)), blob);
break;
case TCSD_PACKET_TYPE_UINT32:
LoadBlob_UINT32(offset, *((UINT32 *) (data)), blob);
break;
case TCSD_PACKET_TYPE_UINT64:
LoadBlob_UINT64(offset, *((UINT64 *) (data)), blob);
break;
case TCSD_PACKET_TYPE_PBYTE:
LoadBlob(offset, data_size, blob, data);
break;
case TCSD_PACKET_TYPE_NONCE:
LoadBlob(offset, sizeof(TCPA_NONCE), blob, ((TCPA_NONCE *)data)->nonce);
break;
case TCSD_PACKET_TYPE_DIGEST:
LoadBlob(offset, sizeof(TCPA_DIGEST), blob, ((TCPA_DIGEST *)data)->digest);
break;
case TCSD_PACKET_TYPE_AUTH:
LoadBlob_Auth_Special(offset, blob, ((TPM_AUTH *)data));
break;
#ifdef TSS_BUILD_PS
case TCSD_PACKET_TYPE_UUID:
LoadBlob_UUID(offset, blob, *((TSS_UUID *)data));
break;
case TCSD_PACKET_TYPE_KM_KEYINFO:
LoadBlob_KM_KEYINFO(offset, blob, ((TSS_KM_KEYINFO *)data));
break;
case TCSD_PACKET_TYPE_KM_KEYINFO2:
LoadBlob_KM_KEYINFO2(offset, blob, ((TSS_KM_KEYINFO2 *)data));
break;
case TCSD_PACKET_TYPE_LOADKEY_INFO:
LoadBlob_LOADKEY_INFO(offset, blob, ((TCS_LOADKEY_INFO *)data));
break;
#endif
case TCSD_PACKET_TYPE_ENCAUTH:
LoadBlob(offset, sizeof(TCPA_ENCAUTH), blob,
((TCPA_ENCAUTH *)data)->authdata);
break;
case TCSD_PACKET_TYPE_VERSION:
LoadBlob_VERSION(offset, blob, ((TPM_VERSION *)data));
break;
#ifdef TSS_BUILD_PCR_EVENTS
case TCSD_PACKET_TYPE_PCR_EVENT:
LoadBlob_PCR_EVENT(offset, blob, ((TSS_PCR_EVENT *)data));
break;
#endif
case TCSD_PACKET_TYPE_SECRET:
LoadBlob(offset, sizeof(TCPA_SECRET), blob,
((TCPA_SECRET *)data)->authdata);
break;
default:
LogError("TCSD packet type unknown! (0x%x)", data_type & 0xff);
return TCSERR(TSS_E_INTERNAL_ERROR);
}
return TSS_SUCCESS;
}
void *
tcsd_thread_run(void *v)
{
struct tcsd_thread_data *data = (struct tcsd_thread_data *)v;
BYTE buffer[TCSD_TXBUF_SIZE];
struct tcsd_packet_hdr *ret_buf = NULL;
TSS_RESULT result;
int sizeToSend, sent_total, sent;
UINT64 offset;
#ifndef TCSD_SINGLE_THREAD_DEBUG
int rc;
thread_signal_init();
#endif
if ((data->buf_size = recv(data->sock, buffer, TCSD_TXBUF_SIZE, 0)) < 0) {
LogError("Failed Receive: %s", strerror(errno));
goto done;
}
LogDebug("Rx'd packet");
data->buf = buffer;
while (1) {
sent_total = 0;
if (data->buf_size > TCSD_TXBUF_SIZE) {
LogError("Packet received from socket %d was too large (%u bytes)",
data->sock, data->buf_size);
goto done;
} else if (data->buf_size < (int)((2 * sizeof(UINT32)) + sizeof(UINT16))) {
LogError("Packet received from socket %d was too small (%u bytes)",
data->sock, data->buf_size);
goto done;
}
if ((result = getTCSDPacket(data, &ret_buf)) != TSS_SUCCESS) {
/* something internal to the TCSD went wrong in preparing the packet
* to return to the TSP. Use our already allocated buffer to return a
* TSS_E_INTERNAL_ERROR return code to the TSP. In the non-error path,
* these LoadBlob's are done in getTCSDPacket().
*/
offset = 0;
/* load result */
LoadBlob_UINT32(&offset, result, buffer);
/* load packet size */
LoadBlob_UINT32(&offset, sizeof(struct tcsd_packet_hdr), buffer);
/* load num parms */
LoadBlob_UINT16(&offset, 0, buffer);
sizeToSend = sizeof(struct tcsd_packet_hdr);
LogDebug("Sending 0x%X bytes back", sizeToSend);
while (sent_total < sizeToSend) {
if ((sent = send(data->sock,
&data->buf[sent_total],
sizeToSend - sent_total, 0)) < 0) {
LogError("Packet send to TSP failed: send: %s. Thread exiting.",
strerror(errno));
goto done;
}
sent_total += sent;
}
} else {
sizeToSend = Decode_UINT32((BYTE *)&(ret_buf->packet_size));
LogDebug("Sending 0x%X bytes back", sizeToSend);
while (sent_total < sizeToSend) {
if ((sent = send(data->sock,
&(((BYTE *)ret_buf)[sent_total]),
sizeToSend - sent_total, 0)) < 0) {
LogError("response to TSP failed: send: %s. Thread exiting.",
strerror(errno));
free(ret_buf);
ret_buf = NULL;
goto done;
}
sent_total += sent;
}
free(ret_buf);
ret_buf = NULL;
}
if (tm->shutdown) {
LogDebug("Thread %zd exiting via shutdown signal!", THREAD_ID);
break;
}
/* receive the next packet */
if ((data->buf_size = recv(data->sock, buffer, TCSD_TXBUF_SIZE, 0)) < 0) {
LogError("TSP has closed its connection: %s. Thread exiting.",
strerror(errno));
break;
} else if (data->buf_size == 0) {
LogDebug("The TSP has closed the socket's connection. Thread exiting.");
break;
}
}
done:
/* Closing connection to TSP */
close(data->sock);
data->sock = -1;
data->buf = NULL;
data->buf_size = -1;
/* If the connection was not shut down cleanly, free TCS resources here */
if (data->context != NULL_TCS_HANDLE) {
TCS_CloseContext_Internal(data->context);
data->context = NULL_TCS_HANDLE;
}
#ifndef TCSD_SINGLE_THREAD_DEBUG
MUTEX_LOCK(tm->lock);
tm->num_active_threads--;
/* if we're not in shutdown mode, then nobody is waiting to join this thread, so
* detach it so that its resources are free at THREAD_EXIT() time. */
if (!tm->shutdown) {
if ((rc = THREAD_DETACH(*(data->thread_id)))) {
LogError("Thread detach failed (errno %d)."
" Resources may not be properly released.", rc);
}
}
free(data->hostname);
data->hostname = NULL;
data->thread_id = THREAD_NULL;
MUTEX_UNLOCK(tm->lock);
THREAD_EXIT(NULL);
#else
return NULL;
#endif
}
