src/Tizen.Security.TEEC/Interop/Interop.Libteec.cs

   1 /*
   2  *  Copyright (c) 2017 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   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
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  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
  15  */
  16
  17 using System;
  18 using System.Runtime.InteropServices;
  19 //using Interop.Liibteec.Types;
  20
  21 internal static partial class Interop
  22 {
  23     internal static partial class Libteec
  24     {
  25         /// <summary>
  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.
  31         /// </summary>
  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);
  35
  36         /// <summary>
  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.
  43         /// </summary>
  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);
  47
  48         /// <summary>
  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.
  54         /// </summary>
  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);
  58
  59         /// <summary>
  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.
  65         /// </summary>
  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);
  69
  70         /// <summary>
  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.
  80         /// </summary>
  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);
  84
  85         /// <summary>
  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.
  91         /// </summary>
  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);
  95
  96         /// <summary>
  97         /// This function closes a session which has been opened with a trusted application.
  98         /// All commands within the session must have completed before this function can be called.
  99         /// The implementation must do nothing if the input session parameter is null.
 100         /// The implementation of this function must not fail; after this function returns, the Client
 101         /// Application must be able to consider that the session has been closed.
 102         /// </summary>
 103         //void TEEC_CloseSession(TEEC_Session *session);
 104         [DllImport(Libraries.Libteec, EntryPoint = "TEEC_CloseSession", CallingConvention = CallingConvention.Cdecl)]
 105         static public extern void CloseSession(ref TEEC_Session session);
 106
 107         /// <summary>
 108         /// This function invokes a command within the specified session.
 109         /// The parameter session must point to a valid open session.
 110         /// The parameter commandID is an identifier that is used to indicate which of the exposed Trusted
 111         /// Application functions should be invoked. The supported command identifier values are defined by the
 112         /// trusted application's protocol.
 113         /// </summary>
 114         //TEEC_Result TEEC_InvokeCommand(TEEC_Session *session, uint commandID, TEEC_Operation *operation, uint *returnOrigin);
 115         [DllImport(Libraries.Libteec, EntryPoint = "TEEC_InvokeCommand", CallingConvention = CallingConvention.Cdecl)]
 116         static public extern int InvokeCommand(ref TEEC_Session session, uint commandID, ref TEEC_Operation operation, out uint returnOrigin);
 117
 118         /// <summary>
 119         /// This function requests the cancelation of a pending open session operation or a command invocation
 120         /// operation. As this is a synchronous API, this function must be called from a thread other than the one
 121         /// executing the OpenSession or InvokeCommand function.
 122         /// This function just sends a cancelation signal to the TEE and returns immediately; the operation is not
 123         /// guaranteed to have been canceled when this function returns. In addition, the cancelation request is just
 124         /// a hint; the TEE or the trusted application may ignore the cancelation request.
 125         /// </summary>
 126         //void TEEC_RequestCancellation(TEEC_Operation *operation);
 127         [DllImport(Libraries.Libteec, EntryPoint = "TEEC_RequestCancellation", CallingConvention = CallingConvention.Cdecl)]
 128         static public extern void RequestCancellation(ref TEEC_Operation operation);
 129     }
 130 }