Home | History | Annotate | Line # | Download | only in tcstp 
      1 
      2 /*
      3  * Licensed Materials - Property of IBM
      4  *
      5  * trousers - An open source TCG Software Stack
      6  *
      7  * (C) Copyright International Business Machines Corp. 2004-2007
      8  *
      9  */
     10 
     11 #include <stdlib.h>
     12 #include <stdio.h>
     13 #include <syslog.h>
     14 #include <string.h>
     15 #include <netdb.h>
     16 
     17 #include "trousers/tss.h"
     18 #include "trousers_types.h"
     19 #include "tcs_tsp.h"
     20 #include "tcs_utils.h"
     21 #include "tcs_int_literals.h"
     22 #include "capabilities.h"
     23 #include "tcslog.h"
     24 #include "tcsd_wrap.h"
     25 #include "tcsd.h"
     26 #include "tcs_utils.h"
     27 #include "rpc_tcstp_tcs.h"
     28 
     29 
     30 TSS_RESULT
     31 tcs_wrap_PhysicalSetDeactivated(struct tcsd_thread_data *data)
     32 {
     33 	TCS_CONTEXT_HANDLE hContext;
     34 	TSS_BOOL state;
     35 	TSS_RESULT result;
     36 
     37 	if (getData(TCSD_PACKET_TYPE_UINT32, 0, &hContext, 0, &data->comm))
     38 		return TCSERR(TSS_E_INTERNAL_ERROR);
     39 
     40 	if ((result = ctx_verify_context(hContext)))
     41 		goto done;
     42 
     43 	LogDebugFn("thread %ld context %x", THREAD_ID, hContext);
     44 
     45 	if (getData(TCSD_PACKET_TYPE_BOOL, 1, &state, 0, &data->comm))
     46 		return TCSERR(TSS_E_INTERNAL_ERROR);
     47 
     48 	MUTEX_LOCK(tcsp_lock);
     49 
     50 	result = TCSP_PhysicalSetDeactivated_Internal(hContext, state);
     51 
     52 	MUTEX_UNLOCK(tcsp_lock);
     53 done:
     54 	initData(&data->comm, 0);
     55 	data->comm.hdr.u.result = result;
     56 
     57 	return TSS_SUCCESS;
     58 }
     59 
     60 TSS_RESULT
     61 tcs_wrap_DisableOwnerClear(struct tcsd_thread_data *data)
     62 {
     63 	TCS_CONTEXT_HANDLE hContext;
     64 	TSS_RESULT result;
     65 	TPM_AUTH auth;
     66 
     67 	if (getData(TCSD_PACKET_TYPE_UINT32, 0, &hContext, 0, &data->comm))
     68 		return TCSERR(TSS_E_INTERNAL_ERROR);
     69 
     70 	if ((result = ctx_verify_context(hContext)))
     71 		goto done;
     72 
     73 	LogDebugFn("thread %ld context %x", THREAD_ID, hContext);
     74 
     75 	if (getData(TCSD_PACKET_TYPE_AUTH, 1, &auth, 0, &data->comm))
     76 		return TCSERR(TSS_E_INTERNAL_ERROR);
     77 
     78 	MUTEX_LOCK(tcsp_lock);
     79 
     80 	result = TCSP_DisableOwnerClear_Internal(hContext, &auth);
     81 
     82 	MUTEX_UNLOCK(tcsp_lock);
     83 
     84 	if (result == TSS_SUCCESS) {
     85 		initData(&data->comm, 1);
     86 		if (setData(TCSD_PACKET_TYPE_AUTH, 0, &auth, 0, &data->comm)) {
     87 			return TCSERR(TSS_E_INTERNAL_ERROR);
     88 		}
     89 	} else
     90 done:		initData(&data->comm, 0);
     91 
     92 	data->comm.hdr.u.result = result;
     93 	return TSS_SUCCESS;
     94 }
     95 
     96 TSS_RESULT
     97 tcs_wrap_ForceClear(struct tcsd_thread_data *data)
     98 {
     99 	TCS_CONTEXT_HANDLE hContext;
    100 	TSS_RESULT result;
    101 
    102 	if (getData(TCSD_PACKET_TYPE_UINT32, 0, &hContext, 0, &data->comm))
    103 		return TCSERR(TSS_E_INTERNAL_ERROR);
    104 
    105 	LogDebugFn("thread %ld context %x", THREAD_ID, hContext);
    106 
    107 	MUTEX_LOCK(tcsp_lock);
    108 
    109 	result = TCSP_ForceClear_Internal(hContext);
    110 
    111 	MUTEX_UNLOCK(tcsp_lock);
    112 
    113 	initData(&data->comm, 0);
    114 	data->comm.hdr.u.result = result;
    115 
    116 	return TSS_SUCCESS;
    117 }
    118 
    119 TSS_RESULT
    120 tcs_wrap_DisableForceClear(struct tcsd_thread_data *data)
    121 {
    122 	TCS_CONTEXT_HANDLE hContext;
    123 	TSS_RESULT result;
    124 
    125 	if (getData(TCSD_PACKET_TYPE_UINT32, 0, &hContext, 0, &data->comm))
    126 		return TCSERR(TSS_E_INTERNAL_ERROR);
    127 
    128 	LogDebugFn("thread %ld context %x", THREAD_ID, hContext);
    129 
    130 	MUTEX_LOCK(tcsp_lock);
    131 
    132 	result = TCSP_DisableForceClear_Internal(hContext);
    133 
    134 	MUTEX_UNLOCK(tcsp_lock);
    135 
    136 	initData(&data->comm, 0);
    137 	data->comm.hdr.u.result = result;
    138 
    139 	return TSS_SUCCESS;
    140 }
    141 
    142 TSS_RESULT
    143 tcs_wrap_PhysicalEnable(struct tcsd_thread_data *data)
    144 {
    145 	TCS_CONTEXT_HANDLE hContext;
    146 	TSS_RESULT result;
    147 
    148 	if (getData(TCSD_PACKET_TYPE_UINT32, 0, &hContext, 0, &data->comm))
    149 		return TCSERR(TSS_E_INTERNAL_ERROR);
    150 
    151 	LogDebugFn("thread %ld context %x", THREAD_ID, hContext);
    152 
    153 	MUTEX_LOCK(tcsp_lock);
    154 
    155 	result = TCSP_PhysicalEnable_Internal(hContext);
    156 
    157 	MUTEX_UNLOCK(tcsp_lock);
    158 
    159 	initData(&data->comm, 0);
    160 	data->comm.hdr.u.result = result;
    161 
    162 	return TSS_SUCCESS;
    163 }
    164 
    165 TSS_RESULT
    166 tcs_wrap_SetOwnerInstall(struct tcsd_thread_data *data)
    167 {
    168 	TCS_CONTEXT_HANDLE hContext;
    169 	TSS_BOOL state;
    170 	TSS_RESULT result;
    171 
    172 	if (getData(TCSD_PACKET_TYPE_UINT32, 0, &hContext, 0, &data->comm))
    173 		return TCSERR(TSS_E_INTERNAL_ERROR);
    174 
    175 	if ((result = ctx_verify_context(hContext)))
    176 		goto done;
    177 
    178 	LogDebugFn("thread %ld context %x", THREAD_ID, hContext);
    179 
    180 	if (getData(TCSD_PACKET_TYPE_BOOL, 1, &state, 0, &data->comm))
    181 		return TCSERR(TSS_E_INTERNAL_ERROR);
    182 
    183 	MUTEX_LOCK(tcsp_lock);
    184 
    185 	result = TCSP_SetOwnerInstall_Internal(hContext, state);
    186 
    187 	MUTEX_UNLOCK(tcsp_lock);
    188 done:
    189 	initData(&data->comm, 0);
    190 	data->comm.hdr.u.result = result;
    191 
    192 	return TSS_SUCCESS;
    193 }
    194 
    195 TSS_RESULT
    196 tcs_wrap_OwnerSetDisable(struct tcsd_thread_data *data)
    197 {
    198 	TCS_CONTEXT_HANDLE hContext;
    199 	TSS_BOOL disableState;
    200 	TPM_AUTH ownerAuth;
    201 	TSS_RESULT result;
    202 
    203 	if (getData(TCSD_PACKET_TYPE_UINT32, 0, &hContext, 0, &data->comm))
    204 		return TCSERR(TSS_E_INTERNAL_ERROR);
    205 
    206 	if ((result = ctx_verify_context(hContext)))
    207 		goto done;
    208 
    209 	LogDebugFn("thread %ld context %x", THREAD_ID, hContext);
    210 
    211 	if (getData(TCSD_PACKET_TYPE_BOOL, 1, &disableState, 0, &data->comm))
    212 		return TCSERR(TSS_E_INTERNAL_ERROR);
    213 
    214 	if (getData(TCSD_PACKET_TYPE_AUTH, 2, &ownerAuth, 0, &data->comm))
    215 		return TCSERR(TSS_E_INTERNAL_ERROR);
    216 
    217 	MUTEX_LOCK(tcsp_lock);
    218 
    219 	result = TCSP_OwnerSetDisable_Internal(hContext, disableState, &ownerAuth);
    220 
    221 	MUTEX_UNLOCK(tcsp_lock);
    222 
    223 	if (result == TSS_SUCCESS) {
    224 		initData(&data->comm, 1);
    225 		if (setData(TCSD_PACKET_TYPE_AUTH, 0, &ownerAuth, 0, &data->comm)) {
    226 			return TCSERR(TSS_E_INTERNAL_ERROR);
    227 		}
    228 	} else
    229 done:		initData(&data->comm, 0);
    230 	data->comm.hdr.u.result = result;
    231 
    232 	return TSS_SUCCESS;
    233 }
    234 
    235 TSS_RESULT
    236 tcs_wrap_PhysicalDisable(struct tcsd_thread_data *data)
    237 {
    238 	TCS_CONTEXT_HANDLE hContext;
    239 	TSS_RESULT result;
    240 
    241 	if (getData(TCSD_PACKET_TYPE_UINT32, 0, &hContext, 0, &data->comm))
    242 		return TCSERR(TSS_E_INTERNAL_ERROR);
    243 
    244 	LogDebugFn("thread %ld context %x", THREAD_ID, hContext);
    245 
    246 	MUTEX_LOCK(tcsp_lock);
    247 
    248 	result = TCSP_PhysicalDisable_Internal(hContext);
    249 
    250 	MUTEX_UNLOCK(tcsp_lock);
    251 
    252 	initData(&data->comm, 0);
    253 	data->comm.hdr.u.result = result;
    254 
    255 	return TSS_SUCCESS;
    256 }
    257 
    258 TSS_RESULT
    259 tcs_wrap_PhysicalPresence(struct tcsd_thread_data *data)
    260 {
    261 	TCS_CONTEXT_HANDLE hContext;
    262 	TSS_RESULT result;
    263 	TCPA_PHYSICAL_PRESENCE phyPresFlags;
    264 
    265 	if (getData(TCSD_PACKET_TYPE_UINT32, 0, &hContext, 0, &data->comm))
    266 		return TCSERR(TSS_E_INTERNAL_ERROR);
    267 
    268 	if ((result = ctx_verify_context(hContext)))
    269 		goto done;
    270 
    271 	LogDebugFn("thread %ld context %x", THREAD_ID, hContext);
    272 
    273 	if (getData(TCSD_PACKET_TYPE_UINT16, 1, &phyPresFlags, 0, &data->comm))
    274 		return TCSERR(TSS_E_INTERNAL_ERROR);
    275 
    276 	MUTEX_LOCK(tcsp_lock);
    277 
    278 	result = TCSP_PhysicalPresence_Internal(hContext, phyPresFlags);
    279 
    280 	MUTEX_UNLOCK(tcsp_lock);
    281 done:
    282 	initData(&data->comm, 0);
    283 	data->comm.hdr.u.result = result;
    284 
    285 	return TSS_SUCCESS;
    286 }
    287 
    288 TSS_RESULT
    289 tcs_wrap_SetTempDeactivated(struct tcsd_thread_data *data)
    290 {
    291 	TCS_CONTEXT_HANDLE hContext;
    292 	TSS_RESULT result;
    293 
    294 	if (getData(TCSD_PACKET_TYPE_UINT32, 0, &hContext, 0, &data->comm))
    295 		return TCSERR(TSS_E_INTERNAL_ERROR);
    296 
    297 	LogDebugFn("thread %ld context %x", THREAD_ID, hContext);
    298 
    299 	MUTEX_LOCK(tcsp_lock);
    300 
    301 	result = TCSP_SetTempDeactivated_Internal(hContext);
    302 
    303 	MUTEX_UNLOCK(tcsp_lock);
    304 
    305 	initData(&data->comm, 0);
    306 	data->comm.hdr.u.result = result;
    307 
    308 	return TSS_SUCCESS;
    309 }
    310 
    311 #ifdef TSS_BUILD_TSS12
    312 TSS_RESULT
    313 tcs_wrap_SetTempDeactivated2(struct tcsd_thread_data *data)
    314 {
    315 	TCS_CONTEXT_HANDLE hContext;
    316 	TPM_AUTH operatorAuth, nullAuth, *pAuth;
    317 	TSS_RESULT result;
    318 
    319 	memset(&operatorAuth, 0, sizeof(TPM_AUTH));
    320 	memset(&nullAuth, 0, sizeof(TPM_AUTH));
    321 
    322 	if (getData(TCSD_PACKET_TYPE_UINT32, 0, &hContext, 0, &data->comm))
    323 		return TCSERR(TSS_E_INTERNAL_ERROR);
    324 
    325 	if ((result = ctx_verify_context(hContext)))
    326 		goto done;
    327 
    328 	LogDebugFn("thread %ld context %x", THREAD_ID, hContext);
    329 
    330 	if (getData(TCSD_PACKET_TYPE_AUTH, 1, &operatorAuth, 0, &data->comm))
    331 		return TCSERR(TSS_E_INTERNAL_ERROR);
    332 
    333 	if (memcmp(&nullAuth, &operatorAuth, sizeof(TPM_AUTH)))
    334 		pAuth = &operatorAuth;
    335 	else
    336 		pAuth = NULL;
    337 
    338 	MUTEX_LOCK(tcsp_lock);
    339 
    340 	result = TCSP_SetTempDeactivated2_Internal(hContext, pAuth);
    341 
    342 	MUTEX_UNLOCK(tcsp_lock);
    343 
    344 	if (result == TSS_SUCCESS) {
    345 		initData(&data->comm, 1);
    346 		if (pAuth) {
    347 			if (setData(TCSD_PACKET_TYPE_AUTH, 0, pAuth, 0, &data->comm)) {
    348 				return TCSERR(TSS_E_INTERNAL_ERROR);
    349 			}
    350 		}
    351 	} else
    352 done:		initData(&data->comm, 0);
    353 
    354 	data->comm.hdr.u.result = result;
    355 
    356 	return TSS_SUCCESS;
    357 }
    358 
    359 TSS_RESULT
    360 tcs_wrap_ResetLockValue(struct tcsd_thread_data *data)
    361 {
    362 	TCS_CONTEXT_HANDLE hContext;
    363 	TPM_AUTH ownerAuth;
    364 	TSS_RESULT result;
    365 
    366 	if (getData(TCSD_PACKET_TYPE_UINT32, 0, &hContext, 0, &data->comm))
    367 		return TCSERR(TSS_E_INTERNAL_ERROR);
    368 
    369 	if ((result = ctx_verify_context(hContext)))
    370 		goto done;
    371 
    372 	LogDebugFn("thread %ld context %x", THREAD_ID, hContext);
    373 
    374 	if (getData(TCSD_PACKET_TYPE_AUTH, 1, &ownerAuth, 0, &data->comm))
    375 		return TCSERR(TSS_E_INTERNAL_ERROR);
    376 
    377 	MUTEX_LOCK(tcsp_lock);
    378 
    379 	result = TCSP_ResetLockValue_Internal(hContext, &ownerAuth);
    380 
    381 	MUTEX_UNLOCK(tcsp_lock);
    382 
    383 	if (result == TSS_SUCCESS) {
    384 		initData(&data->comm, 1);
    385 		if (setData(TCSD_PACKET_TYPE_AUTH, 0, &ownerAuth, 0, &data->comm)) {
    386 			return TCSERR(TSS_E_INTERNAL_ERROR);
    387 		}
    388 	} else
    389 done:		initData(&data->comm, 0);
    390 
    391 	data->comm.hdr.u.result = result;
    392 
    393 	return TSS_SUCCESS;
    394 }
    395 
    396 TSS_RESULT
    397 tcs_wrap_FlushSpecific(struct tcsd_thread_data *data)
    398 {
    399 	TCS_CONTEXT_HANDLE hContext;
    400 	TCS_HANDLE hResHandle;
    401 	TPM_RESOURCE_TYPE resourceType;
    402 	TSS_RESULT result;
    403 
    404 	if (getData(TCSD_PACKET_TYPE_UINT32, 0, &hContext, 0, &data->comm))
    405 		return TCSERR(TSS_E_INTERNAL_ERROR);
    406 
    407 	if ((result = ctx_verify_context(hContext)))
    408 		goto done;
    409 
    410 	LogDebugFn("thread %ld context %x", THREAD_ID, hContext);
    411 
    412 	if (getData(TCSD_PACKET_TYPE_UINT32, 1, &hResHandle, 0, &data->comm))
    413 		return TCSERR(TSS_E_INTERNAL_ERROR);
    414 	if (getData(TCSD_PACKET_TYPE_UINT32, 2, &resourceType, 0, &data->comm))
    415 		return TCSERR(TSS_E_INTERNAL_ERROR);
    416 
    417 	MUTEX_LOCK(tcsp_lock);
    418 
    419 	result = TCSP_FlushSpecific_Internal(hContext, hResHandle, resourceType);
    420 
    421 	MUTEX_UNLOCK(tcsp_lock);
    422 done:
    423 	initData(&data->comm, 0);
    424 	data->comm.hdr.u.result = result;
    425 
    426 	return TSS_SUCCESS;
    427 }
    428 #endif
    429