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
30TSS_RESULT
31tcs_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);
53done:
54	initData(&data->comm, 0);
55	data->comm.hdr.u.result = result;
56
57	return TSS_SUCCESS;
58}
59
60TSS_RESULT
61tcs_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
90done:		initData(&data->comm, 0);
91
92	data->comm.hdr.u.result = result;
93	return TSS_SUCCESS;
94}
95
96TSS_RESULT
97tcs_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
119TSS_RESULT
120tcs_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
142TSS_RESULT
143tcs_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
165TSS_RESULT
166tcs_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);
188done:
189	initData(&data->comm, 0);
190	data->comm.hdr.u.result = result;
191
192	return TSS_SUCCESS;
193}
194
195TSS_RESULT
196tcs_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
229done:		initData(&data->comm, 0);
230	data->comm.hdr.u.result = result;
231
232	return TSS_SUCCESS;
233}
234
235TSS_RESULT
236tcs_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
258TSS_RESULT
259tcs_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);
281done:
282	initData(&data->comm, 0);
283	data->comm.hdr.u.result = result;
284
285	return TSS_SUCCESS;
286}
287
288TSS_RESULT
289tcs_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
312TSS_RESULT
313tcs_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
352done:		initData(&data->comm, 0);
353
354	data->comm.hdr.u.result = result;
355
356	return TSS_SUCCESS;
357}
358
359TSS_RESULT
360tcs_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
389done:		initData(&data->comm, 0);
390
391	data->comm.hdr.u.result = result;
392
393	return TSS_SUCCESS;
394}
395
396TSS_RESULT
397tcs_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);
422done:
423	initData(&data->comm, 0);
424	data->comm.hdr.u.result = result;
425
426	return TSS_SUCCESS;
427}
428#endif
429