← Back to branch summary

~ubuntu-branches/ubuntu/hardy/trousers/hardy-proposed

« back to all changes in this revision

Viewing changes to src/tspi/tsp_caps.c

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Baumann
  • Date: 2008-01-23 22:03:00 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20080123220300-fhtqja3c0oq0gp6z
Tags: 0.3.1-4
http://bugs.debian.org/457400
http://bugs.debian.org/459682
* Added patch from Aaron M. Ucko <ucko@debian.org> to allow trousers to
  build successfully on amd64, and presumably also other 64-bit
  architectures (Closes: #457400).
* Including udev rule for /dev/tpm from William Lima
  <wlima.amadeus@gmail.com> as suggested by David Smith <dds@google.com>
  (Closes: #459682).
* Added lintian overrides.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/tspi/tsp_caps.c
 
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-2006
 
8
 *
 
9
 */
 
10
 
 
11
 
 
12
#include <stdlib.h>
 
13
#include <stdio.h>
 
14
#include <string.h>
 
15
#include <unistd.h>
 
16
#include <sys/types.h>
 
17
#include <sys/mman.h>
 
18
#include <errno.h>
 
19
 
 
20
#include "trousers/tss.h"
 
21
#include "trousers/trousers.h"
 
22
#include "trousers_types.h"
 
23
#include "trousers_types.h"
 
24
#include "spi_utils.h"
 
25
#include "capabilities.h"
 
26
#include "tsplog.h"
 
27
#include "obj.h"
 
28
 
 
29
 
 
30
TSS_RESULT
 
31
internal_GetCap(TSS_HCONTEXT tspContext, TSS_FLAG capArea, UINT32 subCap,
 
32
                UINT32 * respSize, BYTE ** respData)
 
33
{
 
34
        UINT64 offset = 0;
 
35
        TSS_VERSION v = INTERNAL_CAP_VERSION;
 
36
        TSS_BOOL bValue = FALSE;
 
37
        UINT32 u32value = 0;
 
38
 
 
39
        switch (capArea) {
 
40
        case TSS_TSPCAP_VERSION:
 
41
                if ((*respData = calloc_tspi(tspContext, sizeof(TSS_VERSION))) == NULL) {
 
42
                        LogError("malloc of %zd bytes failed", sizeof(TSS_VERSION));
 
43
                        return TSPERR(TSS_E_OUTOFMEMORY);
 
44
                }
 
45
 
 
46
                Trspi_LoadBlob_TSS_VERSION(&offset, *respData, v);
 
47
                *respSize = offset;
 
48
                break;
 
49
        case TSS_TSPCAP_ALG:
 
50
                switch (subCap) {
 
51
                case TSS_ALG_RSA:
 
52
                        *respSize = sizeof(TSS_BOOL);
 
53
                        bValue = INTERNAL_CAP_TSP_ALG_RSA;
 
54
                        break;
 
55
                case TSS_ALG_AES:
 
56
                        *respSize = sizeof(TSS_BOOL);
 
57
                        bValue = INTERNAL_CAP_TSP_ALG_AES;
 
58
                        break;
 
59
                case TSS_ALG_SHA:
 
60
                        *respSize = sizeof(TSS_BOOL);
 
61
                        bValue = INTERNAL_CAP_TSP_ALG_SHA;
 
62
                        break;
 
63
                case TSS_ALG_HMAC:
 
64
                        *respSize = sizeof(TSS_BOOL);
 
65
                        bValue = INTERNAL_CAP_TSP_ALG_HMAC;
 
66
                        break;
 
67
                case TSS_ALG_DES:
 
68
                        *respSize = sizeof(TSS_BOOL);
 
69
                        bValue = INTERNAL_CAP_TSP_ALG_DES;
 
70
                        break;
 
71
                case TSS_ALG_3DES:
 
72
                        *respSize = sizeof(TSS_BOOL);
 
73
                        bValue = INTERNAL_CAP_TSP_ALG_3DES;
 
74
                        break;
 
75
                case TSS_ALG_DEFAULT:
 
76
                        *respSize = sizeof(UINT32);
 
77
                        u32value = INTERNAL_CAP_TSP_ALG_DEFAULT;
 
78
                        break;
 
79
                case TSS_ALG_DEFAULT_SIZE:
 
80
                        *respSize = sizeof(UINT32);
 
81
                        u32value = INTERNAL_CAP_TSP_ALG_DEFAULT_SIZE;
 
82
                        break;
 
83
                default:
 
84
                        LogError("Unknown TSP subCap: %u", subCap);
 
85
                        return TSPERR(TSS_E_BAD_PARAMETER);
 
86
                }
 
87
 
 
88
                if ((*respData = calloc_tspi(tspContext, *respSize)) == NULL) {
 
89
                        LogError("malloc of %u bytes failed", *respSize);
 
90
                        return TSPERR(TSS_E_OUTOFMEMORY);
 
91
                }
 
92
 
 
93
                if (*respSize == sizeof(TSS_BOOL))
 
94
                        *(TSS_BOOL *)respData = bValue;
 
95
                else
 
96
                        *(UINT32 *)respData = u32value;
 
97
                break;
 
98
        case TSS_TSPCAP_PERSSTORAGE:
 
99
                if ((*respData = calloc_tspi(tspContext, sizeof(TSS_BOOL))) == NULL) {
 
100
                        LogError("malloc of %zd bytes failed", sizeof(TSS_BOOL));
 
101
                        return TSPERR(TSS_E_OUTOFMEMORY);
 
102
                }
 
103
 
 
104
                *respSize = sizeof(TSS_BOOL);
 
105
                (*respData)[0] = INTERNAL_CAP_TSP_PERSSTORAGE;
 
106
                break;
 
107
        case TSS_TSPCAP_RETURNVALUE_INFO:
 
108
                if (subCap != TSS_TSPCAP_PROP_RETURNVALUE_INFO)
 
109
                        return TSPERR(TSS_E_BAD_PARAMETER);
 
110
 
 
111
                if ((*respData = calloc_tspi(tspContext, sizeof(UINT32))) == NULL) {
 
112
                        LogError("malloc of %zd bytes failed", sizeof(UINT32));
 
113
                        return TSPERR(TSS_E_OUTOFMEMORY);
 
114
                }
 
115
 
 
116
                *respSize = sizeof(UINT32);
 
117
                *(UINT32 *)(*respData) = INTERNAL_CAP_TSP_RETURNVALUE_INFO;
 
118
                break;
 
119
        case TSS_TSPCAP_PLATFORM_INFO:
 
120
                switch (subCap) {
 
121
                case TSS_TSPCAP_PLATFORM_TYPE:
 
122
                        if ((*respData = calloc_tspi(tspContext, sizeof(UINT32))) == NULL) {
 
123
                                LogError("malloc of %zd bytes failed", sizeof(UINT32));
 
124
                                return TSPERR(TSS_E_OUTOFMEMORY);
 
125
                        }
 
126
 
 
127
                        *respSize = sizeof(UINT32);
 
128
                        *(UINT32 *)(*respData) = INTERNAL_CAP_TSP_PLATFORM_TYPE;
 
129
                        break;
 
130
                case TSS_TSPCAP_PLATFORM_VERSION:
 
131
                        if ((*respData = calloc_tspi(tspContext, sizeof(UINT32))) == NULL) {
 
132
                                LogError("malloc of %zd bytes failed", sizeof(UINT32));
 
133
                                return TSPERR(TSS_E_OUTOFMEMORY);
 
134
                        }
 
135
 
 
136
                        *respSize = sizeof(UINT32);
 
137
                        *(UINT32 *)(*respData) = INTERNAL_CAP_TSP_PLATFORM_VERSION;
 
138
                        break;
 
139
                default:
 
140
                        return TSPERR(TSS_E_BAD_PARAMETER);
 
141
                }
 
142
        case TSS_TSPCAP_MANUFACTURER:
 
143
                switch (subCap) {
 
144
                case TSS_TSPCAP_PROP_MANUFACTURER_ID:
 
145
                        if ((*respData = calloc_tspi(tspContext, sizeof(UINT32))) == NULL) {
 
146
                                LogError("malloc of %zd bytes failed", sizeof(UINT32));
 
147
                                return TSPERR(TSS_E_OUTOFMEMORY);
 
148
                        }
 
149
 
 
150
                        *respSize = sizeof(UINT32);
 
151
                        *(UINT32 *)(*respData) = INTERNAL_CAP_MANUFACTURER_ID;
 
152
                        break;
 
153
                case TSS_TSPCAP_PROP_MANUFACTURER_STR:
 
154
                {
 
155
                        BYTE str[] = INTERNAL_CAP_MANUFACTURER_STR;
 
156
 
 
157
                        if ((*respData = calloc_tspi(tspContext,
 
158
                                                     INTERNAL_CAP_MANUFACTURER_STR_LEN)) == NULL) {
 
159
                                LogError("malloc of %d bytes failed",
 
160
                                         INTERNAL_CAP_MANUFACTURER_STR_LEN);
 
161
                                return TSPERR(TSS_E_OUTOFMEMORY);
 
162
                        }
 
163
 
 
164
                        *respSize = INTERNAL_CAP_MANUFACTURER_STR_LEN;
 
165
                        memcpy(*respData, str, INTERNAL_CAP_MANUFACTURER_STR_LEN);
 
166
                        break;
 
167
                }
 
168
                default:
 
169
                        return TSPERR(TSS_E_BAD_PARAMETER);
 
170
                }
 
171
        default:
 
172
                return TSPERR(TSS_E_BAD_PARAMETER);
 
173
        }
 
174
 
 
175
        return TSS_SUCCESS;
 
176
}