TSS_RESULT
tcs_wrap_CloseContext(struct tcsd_thread_data *data)
{
TCS_CONTEXT_HANDLE hContext;
TSS_RESULT result;
if (getData(TCSD_PACKET_TYPE_UINT32, 0, &hContext, 0, &data->comm))
return TCSERR(TSS_E_INTERNAL_ERROR);
LogDebugFn("thread %ld context %x", THREAD_ID, hContext);
result = TCS_CloseContext_Internal(hContext);
/* This will signal the thread that the connection has been closed cleanly */
if (result == TSS_SUCCESS)
data->context = NULL_TCS_HANDLE;
initData(&data->comm, 0);
data->comm.hdr.u.result = result;
return TSS_SUCCESS;
}
void *
tcsd_thread_run(void *v)
{
struct tcsd_thread_data *data = (struct tcsd_thread_data *)v;
BYTE *buffer;
int recv_size, send_size;
TSS_RESULT result;
UINT64 offset;
#ifndef TCSD_SINGLE_THREAD_DEBUG
int rc;
thread_signal_init();
#endif
data->comm.buf_size = TCSD_INIT_TXBUF_SIZE;
data->comm.buf = calloc(1, data->comm.buf_size);
while (data->comm.buf) {
/* get the packet header to get the size of the incoming packet */
buffer = data->comm.buf;
recv_size = sizeof(struct tcsd_packet_hdr);
if ((recv_size = recv_from_socket(data->sock, buffer, recv_size)) < 0)
break;
buffer += sizeof(struct tcsd_packet_hdr); /* increment the buffer pointer */
/* check the packet size */
recv_size = Decode_UINT32(data->comm.buf);
if (recv_size < (int)sizeof(struct tcsd_packet_hdr)) {
LogError("Packet to receive from socket %d is too small (%d bytes)",
data->sock, recv_size);
break;
}
if (recv_size > data->comm.buf_size ) {
BYTE *new_buffer;
LogDebug("Increasing communication buffer to %d bytes.", recv_size);
new_buffer = realloc(data->comm.buf, recv_size);
if (new_buffer == NULL) {
LogError("realloc of %d bytes failed.", recv_size);
break;
}
buffer = new_buffer + sizeof(struct tcsd_packet_hdr);
data->comm.buf_size = recv_size;
data->comm.buf = new_buffer;
}
/* get the rest of the packet */
recv_size -= sizeof(struct tcsd_packet_hdr); /* already received the header */
if ((recv_size = recv_from_socket(data->sock, buffer, recv_size)) < 0)
break;
LogDebug("Rx'd packet");
printf("recv data:\n");
player_print_hex(data->comm.buf, data->comm.hdr.packet_size);
/* create a platform version of the tcsd header */
offset = 0;
UnloadBlob_UINT32(&offset, &data->comm.hdr.packet_size, data->comm.buf);
UnloadBlob_UINT32(&offset, &data->comm.hdr.u.result, data->comm.buf);
UnloadBlob_UINT32(&offset, &data->comm.hdr.num_parms, data->comm.buf);
UnloadBlob_UINT32(&offset, &data->comm.hdr.type_size, data->comm.buf);
UnloadBlob_UINT32(&offset, &data->comm.hdr.type_offset, data->comm.buf);
UnloadBlob_UINT32(&offset, &data->comm.hdr.parm_size, data->comm.buf);
UnloadBlob_UINT32(&offset, &data->comm.hdr.parm_offset, data->comm.buf);
if ((result = getTCSDPacket(data)) != 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().
*/
/* set everything to zero, fill in what is non-zero */
memset(data->comm.buf, 0, data->comm.buf_size);
offset = 0;
/* load packet size */
LoadBlob_UINT32(&offset, sizeof(struct tcsd_packet_hdr), data->comm.buf);
/* load result */
LoadBlob_UINT32(&offset, result, data->comm.buf);
}
send_size = Decode_UINT32(data->comm.buf);
LogDebug("Sending 0x%X bytes back", send_size);
printf("send data:\n");
player_print_hex(data->comm.buf, send_size);
send_size = send_to_socket(data->sock, data->comm.buf, send_size);
if (send_size < 0)
break;
/* check for shutdown */
if (tm->shutdown) {
LogDebug("Thread %ld exiting via shutdown signal!", THREAD_ID);
break;
}
}
LogDebug("Thread exiting.");
/* Closing connection to TSP */
close(data->sock);
data->sock = -1;
free(data->comm.buf);
data->comm.buf = NULL;
data->comm.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;
}
if(data->hostname != NULL) {
free(data->hostname);
data->hostname = NULL;
}
#ifndef TCSD_SINGLE_THREAD_DEBUG
pthread_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 pthread_exit() time. */
if (!tm->shutdown) {
if ((rc = pthread_detach(*(data->thread_id)))) {
LogError("pthread_detach failed (errno %d)."
" Resources may not be properly released.", rc);
}
}
free(data->thread_id);
data->thread_id = THREAD_NULL;
pthread_mutex_unlock(&(tm->lock));
pthread_exit(NULL);
return NULL; /*never go into here,just for compiling ,add by xlyu*/
#else
return NULL;
#endif
}
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
}
