2 * Copyright (c) 2017 Samsung Electronics Co., Ltd All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License
18 using System.Runtime.InteropServices;
19 //using Interop.Liibteec.Types;
21 internal static partial class Interop
23 internal static partial class Libteec
26 /// This function initializes a new TEE Context, forming a connection between this client application and the
27 /// TEE identified by the string identifier name.
28 /// The client application may pass a name with a value of null, which means that the implementation must
29 /// select a default TEE to connect to. The supported name strings, the mapping of these names to a specific
30 /// TEE, and the nature of the default TEE are implementation-defined.
32 //TEEC_Result TEEC_InitializeContext(const char *name, TEEC_Context *context);
33 [DllImport(Libraries.Libteec, EntryPoint = "TEEC_InitializeContext", CallingConvention = CallingConvention.Cdecl)]
34 static public extern int InitializeContext(string name, ref TEEC_Context context);
37 /// This function destroys an initialized TEE Context, closing the connection between the client application
38 /// and the TEE. The client application must only call this function when all sessions inside this TEE
39 /// context have been closed and all shared memory blocks have been released.
40 /// The implementation of this function must not fail; after this function returns, the client
41 /// application must be able to consider that the context has been closed.
42 /// The function implementation must do nothing if the value of the context pointer is null.
44 //void TEEC_FinalizeContext(TEEC_Context *context);
45 [DllImport(Libraries.Libteec, EntryPoint = "TEEC_FinalizeContext", CallingConvention = CallingConvention.Cdecl)]
46 static public extern void FinalizeContext(ref TEEC_Context context);
49 /// This function registers a block of existing client application memory as a block of shared memory within
50 /// the scope of the specified TEE Context, in accordance with the parameters which have been set by the
51 /// client application inside the shared memory structure.
52 /// The input context must point to an initialized TEE Context.
53 /// The input shared Memory must point to the shared memory structure defining the memory region to register.
55 //EEC_Result TEEC_RegisterSharedMemory(TEEC_Context *context, TEEC_SharedMemory *sharedMem);
56 [DllImport(Libraries.Libteec, EntryPoint = "TEEC_RegisterSharedMemory", CallingConvention = CallingConvention.Cdecl)]
57 static public extern int RegisterSharedMemory(ref TEEC_Context context, ref TEEC_SharedMemory sharedMem);
60 /// This function allocates a new block of memory as a block of shared memory within the scope of the
61 /// specified TEE Context, in accordance with the parameters which have been set by the client application
62 /// inside the shared memory structure.
63 /// The input context must point to an initialized TEE Context.
64 /// The input shared memory must point to the shared memory structure defining the region to allocate.
66 //TEEC_Result TEEC_AllocateSharedMemory(TEEC_Context *context, TEEC_SharedMemory *sharedMem);
67 [DllImport(Libraries.Libteec, EntryPoint = "TEEC_AllocateSharedMemory", CallingConvention = CallingConvention.Cdecl)]
68 static public extern int AllocateSharedMemory(ref TEEC_Context context, ref TEEC_SharedMemory sharedMem);
71 /// This function deregisters or deallocates a previously initialized block of the shared memory.
72 /// For a memory buffer allocated using AllocateSharedMemory, the implementation must free the
73 /// underlying memory and the client application must not access this region after this function has been
74 /// called. In this case, the implementation must set the buffer and size fields of the shared memory
75 /// structure to null and 0 respectively before returning.
76 /// For memory registered using RegisterSharedMemory, the implementation must deregister the
77 /// underlying memory from the TEE, but the memory region will stay available to the client application for
78 /// other purposes as the memory is owned by it.
79 /// The implementation must do nothing if the value of the shared memory parameter is null.
81 //void TEEC_ReleaseSharedMemory(TEEC_SharedMemory *sharedMem);
82 [DllImport(Libraries.Libteec, EntryPoint = "TEEC_ReleaseSharedMemory", CallingConvention = CallingConvention.Cdecl)]
83 static public extern void ReleaseSharedMemory(ref TEEC_SharedMemory sharedMem);
86 /// This function opens a new session between the client application and the specified trusted application.
87 /// The implementation must assume that all fields of this session structure are in an undefined state.
88 /// When this function returns TEEC_SUCCESS, the implementation must have populated this structure with
89 /// any information necessary for subsequent operations within the session.
90 /// The target trusted application is identified by the UUID passed in the parameter destination.
92 //TEEC_Result TEEC_OpenSession(TEEC_Context *context, TEEC_Session *session, const TEEC_UUID *destination, uint connectionMethod, const void *connectionData, TEEC_Operation *operation, uint *returnOrigin);
93 [DllImport(Libraries.Libteec, EntryPoint = "TEEC_OpenSession", CallingConvention = CallingConvention.Cdecl)]
94 static public extern int OpenSession(ref TEEC_Context context, ref TEEC_Session session, ref TEEC_UUID destination, uint connectionMethod, byte[] connectionData, ref TEEC_Operation operation, out uint returnOrigin);
96 [DllImport(Libraries.Libteec, EntryPoint = "TEEC_OpenSession", CallingConvention = CallingConvention.Cdecl)]
97 static public extern int OpenSession(ref TEEC_Context context, ref TEEC_Session session, ref TEEC_UUID destination, uint connectionMethod, byte[] connectionData, IntPtr operation, out uint returnOrigin);
100 /// This function closes a session which has been opened with a trusted application.
101 /// All commands within the session must have completed before this function can be called.
102 /// The implementation must do nothing if the input session parameter is null.
103 /// The implementation of this function must not fail; after this function returns, the Client
104 /// Application must be able to consider that the session has been closed.
106 //void TEEC_CloseSession(TEEC_Session *session);
107 [DllImport(Libraries.Libteec, EntryPoint = "TEEC_CloseSession", CallingConvention = CallingConvention.Cdecl)]
108 static public extern void CloseSession(ref TEEC_Session session);
111 /// This function invokes a command within the specified session.
112 /// The parameter session must point to a valid open session.
113 /// The parameter commandID is an identifier that is used to indicate which of the exposed Trusted
114 /// Application functions should be invoked. The supported command identifier values are defined by the
115 /// trusted application's protocol.
117 //TEEC_Result TEEC_InvokeCommand(TEEC_Session *session, uint commandID, TEEC_Operation *operation, uint *returnOrigin);
118 [DllImport(Libraries.Libteec, EntryPoint = "TEEC_InvokeCommand", CallingConvention = CallingConvention.Cdecl)]
119 static public extern int InvokeCommand(ref TEEC_Session session, uint commandID, ref TEEC_Operation operation, out uint returnOrigin);
121 [DllImport(Libraries.Libteec, EntryPoint = "TEEC_InvokeCommand", CallingConvention = CallingConvention.Cdecl)]
122 static public extern int InvokeCommand(ref TEEC_Session session, uint commandID, IntPtr operation, out uint returnOrigin);
125 /// This function requests the cancelation of a pending open session operation or a command invocation
126 /// operation. As this is a synchronous API, this function must be called from a thread other than the one
127 /// executing the OpenSession or InvokeCommand function.
128 /// This function just sends a cancelation signal to the TEE and returns immediately; the operation is not
129 /// guaranteed to have been canceled when this function returns. In addition, the cancelation request is just
130 /// a hint; the TEE or the trusted application may ignore the cancelation request.
132 //void TEEC_RequestCancellation(TEEC_Operation *operation);
133 [DllImport(Libraries.Libteec, EntryPoint = "TEEC_RequestCancellation", CallingConvention = CallingConvention.Cdecl)]
134 static public extern void RequestCancellation(ref TEEC_Operation operation);