LCOV - code coverage report
Current view: top level - pkcs11/wrap-layer - gkm-wrap-layer.c (source / functions) Coverage Total Hit
Test: coverage.info Lines: 49.0 % 604 296
Test Date: 2024-05-07 18:02:03 Functions: 42.7 % 89 38

            Line data    Source code
       1              : /*
       2              :  * gnome-keyring
       3              :  *
       4              :  * Copyright (C) 2010 Stefan Walter
       5              :  *
       6              :  * This program is free software; you can redistribute it and/or modify
       7              :  * it under the terms of the GNU Lesser General Public License as
       8              :  * published by the Free Software Foundation; either version 2.1 of
       9              :  * the License, or (at your option) any later version.
      10              :  *
      11              :  * This program is distributed in the hope that it will be useful, but
      12              :  * WITHOUT ANY WARRANTY; without even the implied warranty of
      13              :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      14              :  * Lesser General Public License for more details.
      15              :  *
      16              :  * You should have received a copy of the GNU Lesser General Public
      17              :  * License along with this program; if not, see
      18              :  * <http://www.gnu.org/licenses/>.
      19              :  */
      20              : 
      21              : #include "config.h"
      22              : 
      23              : #include "gkm-wrap-layer.h"
      24              : #include "gkm-wrap-prompt.h"
      25              : 
      26              : #include "pkcs11/pkcs11.h"
      27              : #include "pkcs11/pkcs11i.h"
      28              : 
      29              : #include <glib.h>
      30              : 
      31              : #include <string.h>
      32              : 
      33              : typedef struct _Mapping {
      34              :         CK_SLOT_ID wrap_slot;
      35              :         CK_SLOT_ID real_slot;
      36              :         CK_FUNCTION_LIST_PTR funcs;
      37              : } Mapping;
      38              : 
      39              : typedef struct _Session {
      40              :         gint wrap_session;
      41              :         CK_SESSION_HANDLE real_session;
      42              :         CK_G_APPLICATION_ID app_id;
      43              :         CK_SLOT_ID wrap_slot;
      44              :         CK_OBJECT_HANDLE specific;
      45              : } Session;
      46              : 
      47              : G_LOCK_DEFINE_STATIC (wrap_layer);
      48              : 
      49              : static GList *wrap_modules = NULL;
      50              : static Mapping *wrap_mappings = NULL;
      51              : static guint n_wrap_mappings = 0;
      52              : static GHashTable *wrap_sessions = NULL;
      53              : static gint last_handle = 16;
      54              : 
      55              : #define MANUFACTURER_ID         "GNOME Keyring                   "
      56              : #define LIBRARY_DESCRIPTION     "GNOME Keyring Daemon Core       "
      57              : #define LIBRARY_VERSION_MAJOR   1
      58              : #define LIBRARY_VERSION_MINOR   1
      59              : 
      60              : /* Start wrap slots slightly higher for testing */
      61              : #define PLEX_MAPPING_OFFSET 0x10
      62              : 
      63              : static CK_RV
      64         2311 : map_slot_unlocked (CK_SLOT_ID slot, Mapping *mapping)
      65              : {
      66         2311 :         if (!wrap_mappings)
      67            0 :                 return CKR_CRYPTOKI_NOT_INITIALIZED;
      68              : 
      69         2311 :         if (slot < PLEX_MAPPING_OFFSET)
      70            0 :                 return CKR_SLOT_ID_INVALID;
      71         2311 :         slot -= PLEX_MAPPING_OFFSET;
      72              : 
      73         2311 :         g_assert (mapping);
      74              : 
      75         2311 :         if (slot > n_wrap_mappings) {
      76            0 :                 return CKR_SLOT_ID_INVALID;
      77              :         } else {
      78         2311 :                 memcpy (mapping, &wrap_mappings[slot], sizeof (Mapping));
      79         2311 :                 return CKR_OK;
      80              :         }
      81              : }
      82              : 
      83              : static CK_RV
      84          255 : map_slot_to_real (CK_SLOT_ID_PTR slot, Mapping *mapping)
      85              : {
      86              :         CK_RV rv;
      87              : 
      88          255 :         g_assert (mapping);
      89              : 
      90          255 :         G_LOCK (wrap_layer);
      91              : 
      92          255 :                 rv = map_slot_unlocked (*slot, mapping);
      93          255 :                 if (rv == CKR_OK)
      94          255 :                         *slot = mapping->real_slot;
      95              : 
      96          255 :         G_UNLOCK (wrap_layer);
      97              : 
      98          255 :         return rv;
      99              : }
     100              : 
     101              : static CK_RV
     102         2056 : map_session_to_real (CK_SESSION_HANDLE_PTR handle, Mapping *mapping, Session *session)
     103              : {
     104         2056 :         CK_RV rv = CKR_OK;
     105              :         Session *sess;
     106              : 
     107         2056 :         g_assert (handle);
     108         2056 :         g_assert (mapping);
     109              : 
     110         2056 :         G_LOCK (wrap_layer);
     111              : 
     112         2056 :                 if (!wrap_sessions) {
     113            0 :                         rv = CKR_CRYPTOKI_NOT_INITIALIZED;
     114              :                 } else {
     115         2056 :                         sess = g_hash_table_lookup (wrap_sessions, GINT_TO_POINTER ((gint)*handle));
     116         2056 :                         if (sess != NULL) {
     117         2056 :                                 *handle = sess->real_session;
     118         2056 :                                 rv = map_slot_unlocked (sess->wrap_slot, mapping);
     119         2056 :                                 if (session != NULL)
     120            0 :                                         memcpy (session, sess, sizeof (Session));
     121              :                         } else {
     122            0 :                                 rv = CKR_SESSION_HANDLE_INVALID;
     123              :                         }
     124              :                 }
     125              : 
     126         2056 :         G_UNLOCK (wrap_layer);
     127              : 
     128         2056 :         return rv;
     129              : }
     130              : 
     131              : static void
     132           59 : lookup_session_specific (CK_SESSION_HANDLE handle, CK_OBJECT_HANDLE_PTR key)
     133              : {
     134              :         Session *sess;
     135              : 
     136           59 :         g_assert (key);
     137           59 :         *key = 0;
     138              : 
     139           59 :         G_LOCK (wrap_layer);
     140              : 
     141           59 :                 if (wrap_sessions) {
     142           59 :                         sess = g_hash_table_lookup (wrap_sessions, GINT_TO_POINTER ((gint)handle));
     143           59 :                         if (sess == NULL)
     144            0 :                                 g_warning ("sessions out of sync with lower layer");
     145              :                         else
     146           59 :                                 *key = sess->specific;
     147              :                 }
     148              : 
     149           59 :         G_UNLOCK (wrap_layer);
     150           59 : }
     151              : 
     152              : static void
     153            8 : store_session_specific (CK_SESSION_HANDLE handle, CK_OBJECT_HANDLE key)
     154              : {
     155              :         Session *sess;
     156              : 
     157            8 :         G_LOCK (wrap_layer);
     158              : 
     159            8 :                 if (wrap_sessions) {
     160            8 :                         sess = g_hash_table_lookup (wrap_sessions, GINT_TO_POINTER ((gint)handle));
     161            8 :                         if (sess == NULL)
     162            0 :                                 g_warning ("sessions out of sync with lower layer");
     163              :                         else
     164            8 :                                 sess->specific = key;
     165              :                 }
     166              : 
     167            8 :         G_UNLOCK (wrap_layer);
     168            8 : }
     169              : 
     170              : static CK_RV
     171           57 : wrap_C_Initialize (CK_VOID_PTR init_args)
     172              : {
     173              :         CK_FUNCTION_LIST_PTR funcs;
     174           57 :         GArray *mappings = NULL;
     175              :         CK_SLOT_ID_PTR slots;
     176              :         Mapping mapping;
     177              :         CK_ULONG i, count;
     178           57 :         CK_RV rv = CKR_OK;
     179              :         GList *l;
     180              : 
     181           57 :         mappings = g_array_new (FALSE, TRUE, sizeof (Mapping));
     182              : 
     183           57 :         G_LOCK (wrap_layer);
     184              : 
     185           57 :                 if (wrap_mappings)
     186            0 :                         rv = CKR_CRYPTOKI_ALREADY_INITIALIZED;
     187              : 
     188          195 :                 for (l = wrap_modules; rv == CKR_OK && l != NULL; l = g_list_next (l)) {
     189          138 :                         funcs = l->data;
     190              : 
     191              :                         /* Initialize each module */
     192          138 :                         rv = (funcs->C_Initialize) (init_args);
     193          138 :                         if (rv == CKR_CRYPTOKI_ALREADY_INITIALIZED)
     194            0 :                                 rv = CKR_OK;
     195          138 :                         if (rv != CKR_OK)
     196            0 :                                 break;
     197              : 
     198              :                         /* And then ask it for its slots */
     199          138 :                         rv = (funcs->C_GetSlotList) (FALSE, NULL, &count);
     200          138 :                         if (rv != CKR_OK)
     201            0 :                                 break;
     202          138 :                         if (!count)
     203            0 :                                 continue;
     204          138 :                         slots = g_new0 (CK_SLOT_ID, count);
     205          138 :                         rv = (funcs->C_GetSlotList) (FALSE, slots, &count);
     206          138 :                         if (rv != CKR_OK) {
     207            0 :                                  g_free (slots);
     208            0 :                                  break;
     209              :                         }
     210              : 
     211              :                         /* And now add a mapping for each of those slots */
     212          306 :                         for (i = 0; i < count; ++i) {
     213          168 :                                 memset (&mapping, 0, sizeof (mapping));
     214          168 :                                 mapping.wrap_slot = mappings->len + PLEX_MAPPING_OFFSET;
     215          168 :                                 mapping.real_slot = slots[i];
     216          168 :                                 mapping.funcs = funcs;
     217          168 :                                 g_array_append_val (mappings, mapping);
     218              :                         }
     219              : 
     220          138 :                         g_free (slots);
     221              :                 }
     222              : 
     223              :                 /* If failed, then finalize all the ones that succeeded */
     224           57 :                 if (rv != CKR_OK && l != NULL) {
     225            0 :                         for (l = g_list_previous (l); l; l = g_list_previous (l)) {
     226            0 :                                 funcs = l->data;
     227            0 :                                 (funcs->C_Finalize) (NULL);
     228              :                         }
     229              :                 }
     230              : 
     231              :                 /* If succeeded then swap in mappings */
     232           57 :                 if (rv == CKR_OK) {
     233           57 :                         g_assert (!wrap_mappings);
     234           57 :                         n_wrap_mappings = mappings->len;
     235           57 :                         wrap_mappings = (Mapping*)g_array_free (mappings, FALSE);
     236           57 :                         mappings = NULL;
     237           57 :                         wrap_sessions = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, g_free);
     238              :                 }
     239              : 
     240           57 :         G_UNLOCK (wrap_layer);
     241              : 
     242              :         /* If failed or somehow unused then free */
     243           57 :         if (mappings)
     244            0 :                 g_array_free (mappings, TRUE);
     245              : 
     246           57 :         return rv;
     247              : }
     248              : 
     249              : static CK_RV
     250           57 : wrap_C_Finalize (CK_VOID_PTR reserved)
     251              : {
     252              :         CK_FUNCTION_LIST_PTR funcs;
     253              :         GList *l;
     254              : 
     255           57 :         G_LOCK (wrap_layer);
     256              : 
     257          195 :                 for (l = wrap_modules; l != NULL; l = g_list_next (l)) {
     258          138 :                         funcs = l->data;
     259          138 :                         (funcs->C_Finalize) (NULL);
     260              :                 }
     261           57 :                 g_free (wrap_mappings);
     262           57 :                 wrap_mappings = NULL;
     263              : 
     264           57 :                 g_hash_table_destroy (wrap_sessions);
     265           57 :                 wrap_sessions = NULL;
     266              : 
     267           57 :         G_UNLOCK (wrap_layer);
     268              : 
     269           57 :         return CKR_OK;
     270              : }
     271              : 
     272              : static CK_RV
     273           29 : wrap_C_GetInfo (CK_INFO_PTR info)
     274              : {
     275           29 :         if (info == NULL)
     276            0 :                 return CKR_ARGUMENTS_BAD;
     277              : 
     278           29 :         info->cryptokiVersion.major = CRYPTOKI_VERSION_MAJOR;
     279           29 :         info->cryptokiVersion.minor = CRYPTOKI_VERSION_MINOR;
     280           29 :         info->libraryVersion.major = LIBRARY_VERSION_MAJOR;
     281           29 :         info->libraryVersion.minor = LIBRARY_VERSION_MINOR;
     282           29 :         info->flags = 0;
     283           29 :         memcpy ((char*)info->manufacturerID, MANUFACTURER_ID, 32);
     284           29 :         memcpy ((char*)info->libraryDescription, LIBRARY_DESCRIPTION, 32);
     285           29 :         return CKR_OK;
     286              : }
     287              : 
     288              : static CK_RV
     289            0 : wrap_C_GetFunctionList (CK_FUNCTION_LIST_PTR_PTR list)
     290              : {
     291            0 :         if (!list)
     292            0 :                 return CKR_ARGUMENTS_BAD;
     293            0 :         *list = gkm_wrap_layer_get_functions_no_prompts ();
     294            0 :         return CKR_OK;
     295              : }
     296              : 
     297              : static CK_RV
     298            0 : auth_C_GetFunctionList (CK_FUNCTION_LIST_PTR_PTR list)
     299              : {
     300            0 :         if (!list)
     301            0 :                 return CKR_ARGUMENTS_BAD;
     302            0 :         *list = gkm_wrap_layer_get_functions ();
     303            0 :         return CKR_OK;
     304              : }
     305              : 
     306              : static CK_RV
     307          202 : wrap_C_GetSlotList (CK_BBOOL token_present, CK_SLOT_ID_PTR slot_list, CK_ULONG_PTR count)
     308              : {
     309              :         CK_SLOT_INFO info;
     310              :         Mapping *mapping;
     311              :         CK_ULONG index;
     312              :         CK_RV rv;
     313              : 
     314              :         guint i;
     315              : 
     316          202 :         if (!count)
     317            0 :                 return CKR_ARGUMENTS_BAD;
     318              : 
     319          202 :         G_LOCK (wrap_layer);
     320              : 
     321          202 :                 rv = CKR_OK;
     322          202 :                 index = 0;
     323              : 
     324              :                 /* Go through and build up a map */
     325          738 :                 for (i = 0; i < n_wrap_mappings; ++i) {
     326          536 :                         mapping = &wrap_mappings[i];
     327              : 
     328              :                         /* Skip ones without a token if requested */
     329          536 :                         if (token_present) {
     330          536 :                                 rv = (mapping->funcs->C_GetSlotInfo) (mapping->real_slot, &info);
     331          536 :                                 if (rv != CKR_OK)
     332            0 :                                         break;
     333          536 :                                 if (!(info.flags & CKF_TOKEN_PRESENT))
     334          136 :                                         continue;
     335              :                         }
     336              : 
     337              :                         /* Fill in the slot if we can */
     338          400 :                         if (slot_list && *count > index)
     339          209 :                                 slot_list[index] = mapping->wrap_slot;
     340              : 
     341          400 :                         ++index;
     342              :                 }
     343              : 
     344          202 :                 if (slot_list && *count < index)
     345            0 :                         rv = CKR_BUFFER_TOO_SMALL;
     346              : 
     347          202 :                 *count = index;
     348              : 
     349          202 :         G_UNLOCK (wrap_layer);
     350              : 
     351          202 :         return rv;
     352              : }
     353              : 
     354              : static CK_RV
     355            0 : wrap_C_GetSlotInfo (CK_SLOT_ID id, CK_SLOT_INFO_PTR info)
     356              : {
     357              :         Mapping map;
     358              :         CK_RV rv;
     359              : 
     360            0 :         rv = map_slot_to_real (&id, &map);
     361            0 :         if (rv != CKR_OK)
     362            0 :                 return rv;
     363            0 :         return (map.funcs->C_GetSlotInfo) (id, info);
     364              : }
     365              : 
     366              : static CK_RV
     367          115 : wrap_C_GetTokenInfo (CK_SLOT_ID id, CK_TOKEN_INFO_PTR info)
     368              : {
     369              :         Mapping map;
     370              :         CK_RV rv;
     371              : 
     372          115 :         rv = map_slot_to_real (&id, &map);
     373          115 :         if (rv != CKR_OK)
     374            0 :                 return rv;
     375          115 :         return (map.funcs->C_GetTokenInfo) (id, info);
     376              : }
     377              : 
     378              : static CK_RV
     379           91 : auth_C_GetTokenInfo (CK_SLOT_ID id, CK_TOKEN_INFO_PTR info)
     380              : {
     381           91 :         CK_RV rv = wrap_C_GetTokenInfo (id, info);
     382           91 :         if (rv == CKR_OK)
     383           91 :                 info->flags |= CKF_PROTECTED_AUTHENTICATION_PATH;
     384           91 :         return rv;
     385              : }
     386              : 
     387              : static CK_RV
     388            0 : wrap_C_GetMechanismList (CK_SLOT_ID id, CK_MECHANISM_TYPE_PTR mechanism_list, CK_ULONG_PTR count)
     389              : {
     390              :         Mapping map;
     391              :         CK_RV rv;
     392              : 
     393            0 :         rv = map_slot_to_real (&id, &map);
     394            0 :         if (rv != CKR_OK)
     395            0 :                 return rv;
     396            0 :         return (map.funcs->C_GetMechanismList) (id, mechanism_list, count);
     397              : }
     398              : 
     399              : static CK_RV
     400            0 : wrap_C_GetMechanismInfo (CK_SLOT_ID id, CK_MECHANISM_TYPE type, CK_MECHANISM_INFO_PTR info)
     401              : {
     402              :         Mapping map;
     403              :         CK_RV rv;
     404              : 
     405            0 :         rv = map_slot_to_real (&id, &map);
     406            0 :         if (rv != CKR_OK)
     407            0 :                 return rv;
     408            0 :         return (map.funcs->C_GetMechanismInfo) (id, type, info);
     409              : }
     410              : 
     411              : static CK_RV
     412            0 : wrap_C_InitToken (CK_SLOT_ID id, CK_UTF8CHAR_PTR pin, CK_ULONG pin_len, CK_UTF8CHAR_PTR label)
     413              : {
     414              :         Mapping map;
     415              :         CK_RV rv;
     416              : 
     417            0 :         rv = map_slot_to_real (&id, &map);
     418            0 :         if (rv != CKR_OK)
     419            0 :                 return rv;
     420            0 :         return (map.funcs->C_InitToken) (id, pin, pin_len, label);
     421              : }
     422              : 
     423              : static CK_RV
     424            0 : wrap_C_WaitForSlotEvent (CK_FLAGS flags, CK_SLOT_ID_PTR slot, CK_VOID_PTR reserved)
     425              : {
     426              :         /* TODO: We could implement this by polling, esp. the nonblock case. */
     427            0 :         return CKR_NO_EVENT;
     428              : }
     429              : 
     430              : static CK_RV
     431          140 : wrap_C_OpenSession (CK_SLOT_ID id, CK_FLAGS flags, CK_VOID_PTR user_data, CK_NOTIFY callback, CK_SESSION_HANDLE_PTR handle)
     432              : {
     433              :         Session *sess;
     434              :         Mapping map;
     435              :         CK_RV rv;
     436              : 
     437          140 :         if (handle == NULL)
     438            0 :                 return CKR_ARGUMENTS_BAD;
     439              : 
     440          140 :         rv = map_slot_to_real (&id, &map);
     441          140 :         if (rv != CKR_OK)
     442            0 :                 return rv;
     443              : 
     444          140 :         rv = (map.funcs->C_OpenSession) (id, flags, user_data, callback, handle);
     445              : 
     446          140 :         if (rv == CKR_OK) {
     447          139 :                 G_LOCK (wrap_layer);
     448              : 
     449          139 :                         sess = g_new (Session, 1);
     450          139 :                         if (flags & CKF_G_APPLICATION_SESSION)
     451           16 :                                 sess->app_id = ((CK_G_APPLICATION_PTR)user_data)->applicationId;
     452          139 :                         sess->wrap_slot = map.wrap_slot;
     453          139 :                         sess->real_session = *handle;
     454          139 :                         sess->wrap_session = ++last_handle; /* TODO: Handle wrapping, and then collisions */
     455          139 :                         g_hash_table_replace (wrap_sessions, GINT_TO_POINTER (sess->wrap_session), sess);
     456              : 
     457          139 :                         *handle = (CK_ULONG)sess->wrap_session;
     458              : 
     459          139 :                 G_UNLOCK (wrap_layer);
     460              :         }
     461              : 
     462          140 :         return rv;
     463              : }
     464              : 
     465              : static CK_RV
     466          136 : wrap_C_CloseSession (CK_SESSION_HANDLE handle)
     467              : {
     468          136 :         gint key = (gint)handle;
     469              :         Mapping map;
     470              :         CK_RV rv;
     471              : 
     472          136 :         rv = map_session_to_real (&handle, &map, NULL);
     473          136 :         if (rv != CKR_OK)
     474            0 :                 return rv;
     475          136 :         rv = (map.funcs->C_CloseSession) (handle);
     476              : 
     477          136 :         if (rv == CKR_OK) {
     478          136 :                 G_LOCK (wrap_layer);
     479              : 
     480          136 :                         g_hash_table_remove (wrap_sessions, GINT_TO_POINTER (key));
     481              : 
     482          136 :                 G_UNLOCK (wrap_layer);
     483              :         }
     484              : 
     485          136 :         return rv;
     486              : }
     487              : 
     488              : static CK_RV
     489            0 : wrap_C_CloseAllSessions (CK_SLOT_ID id)
     490              : {
     491              :         GHashTableIter iter;
     492              :         CK_SESSION_HANDLE handle;
     493              :         gpointer key, value;
     494              :         Session *sess;
     495              :         GArray *to_close;
     496              :         gint i;
     497              : 
     498            0 :         to_close = g_array_new (FALSE, FALSE, sizeof (CK_SESSION_HANDLE));
     499              : 
     500            0 :         G_LOCK (wrap_layer);
     501              : 
     502            0 :                 g_hash_table_iter_init (&iter, wrap_sessions);
     503            0 :                 while (g_hash_table_iter_next (&iter, &key, &value)) {
     504            0 :                         sess = value;
     505            0 :                         if ((sess->app_id | sess->wrap_slot) == id) {
     506            0 :                                 handle = (CK_SESSION_HANDLE)sess->wrap_session;
     507            0 :                                 g_array_append_val (to_close, handle);
     508              :                         }
     509              :                 }
     510              : 
     511            0 :         G_UNLOCK (wrap_layer);
     512              : 
     513            0 :         for (i = 0; i < to_close->len; ++i)
     514            0 :                 wrap_C_CloseSession (g_array_index (to_close, CK_SESSION_HANDLE, i));
     515              : 
     516            0 :         g_array_free (to_close, TRUE);
     517            0 :         return CKR_OK;
     518              : }
     519              : 
     520              : static CK_RV
     521            0 : wrap_C_GetFunctionStatus (CK_SESSION_HANDLE handle)
     522              : {
     523              :         Mapping map;
     524              :         CK_RV rv;
     525              : 
     526            0 :         rv = map_session_to_real (&handle, &map, NULL);
     527            0 :         if (rv != CKR_OK)
     528            0 :                 return rv;
     529            0 :         return (map.funcs->C_GetFunctionStatus) (handle);
     530              : }
     531              : 
     532              : static CK_RV
     533            0 : wrap_C_CancelFunction (CK_SESSION_HANDLE handle)
     534              : {
     535              :         Mapping map;
     536              :         CK_RV rv;
     537              : 
     538            0 :         rv = map_session_to_real (&handle, &map, NULL);
     539            0 :         if (rv != CKR_OK)
     540            0 :                 return rv;
     541            0 :         return (map.funcs->C_CancelFunction) (handle);
     542              : }
     543              : 
     544              : static CK_RV
     545          128 : wrap_C_GetSessionInfo (CK_SESSION_HANDLE handle, CK_SESSION_INFO_PTR info)
     546              : {
     547              :         Mapping map;
     548              :         CK_RV rv;
     549              : 
     550          128 :         if (info == NULL)
     551            0 :                 return CKR_ARGUMENTS_BAD;
     552              : 
     553          128 :         rv = map_session_to_real (&handle, &map, NULL);
     554          128 :         if (rv != CKR_OK)
     555            0 :                 return rv;
     556              : 
     557          128 :         rv = (map.funcs->C_GetSessionInfo) (handle, info);
     558          128 :         if (rv == CKR_OK)
     559          127 :                 info->slotID = map.wrap_slot;
     560              : 
     561          128 :         return rv;
     562              : }
     563              : 
     564              : static CK_RV
     565            5 : wrap_C_InitPIN (CK_SESSION_HANDLE handle, CK_UTF8CHAR_PTR pin, CK_ULONG pin_len)
     566              : {
     567              :         Mapping map;
     568              :         CK_RV rv;
     569              : 
     570            5 :         rv = map_session_to_real (&handle, &map, NULL);
     571            5 :         if (rv != CKR_OK)
     572            0 :                 return rv;
     573              : 
     574            5 :         return (map.funcs->C_InitPIN) (handle, pin, pin_len);
     575              : }
     576              : 
     577              : static CK_RV
     578            1 : auth_C_InitPIN (CK_SESSION_HANDLE handle, CK_UTF8CHAR_PTR pin, CK_ULONG pin_len)
     579              : {
     580              :         GkmWrapPrompt *prompt;
     581            1 :         CK_RV rv = CKR_OK;
     582              : 
     583            1 :         prompt = gkm_wrap_prompt_for_init_pin (gkm_wrap_layer_get_functions_no_prompts(),
     584              :                                                handle, pin, pin_len);
     585              : 
     586              :         for (;;) {
     587            1 :                 if (prompt && !gkm_wrap_prompt_do_init_pin (prompt, rv, &pin, &pin_len))
     588            0 :                         break;
     589              : 
     590            1 :                 rv = wrap_C_InitPIN (handle, pin, pin_len);
     591              : 
     592            1 :                 if (!prompt || rv != CKR_PIN_INVALID || rv != CKR_PIN_LEN_RANGE)
     593              :                         break;
     594              :         }
     595              : 
     596            1 :         if (prompt) {
     597            1 :                 gkm_wrap_prompt_done_init_pin (prompt, rv);
     598            1 :                 g_object_unref (prompt);
     599              :         }
     600              : 
     601            1 :         return rv;
     602              : }
     603              : 
     604              : static CK_RV
     605            1 : wrap_C_SetPIN (CK_SESSION_HANDLE handle, CK_UTF8CHAR_PTR old_pin, CK_ULONG old_pin_len,
     606              :                CK_UTF8CHAR_PTR new_pin, CK_ULONG new_pin_len)
     607              : {
     608              :         Mapping map;
     609              :         CK_RV rv;
     610              : 
     611            1 :         rv = map_session_to_real (&handle, &map, NULL);
     612            1 :         if (rv != CKR_OK)
     613            0 :                 return rv;
     614              : 
     615            1 :         return (map.funcs->C_SetPIN) (handle, old_pin, old_pin_len, new_pin, new_pin_len);
     616              : }
     617              : 
     618              : static CK_RV
     619            1 : auth_C_SetPIN (CK_SESSION_HANDLE handle, CK_UTF8CHAR_PTR old_pin, CK_ULONG old_pin_len,
     620              :                CK_UTF8CHAR_PTR new_pin, CK_ULONG new_pin_len)
     621              : {
     622              :         GkmWrapPrompt *prompt;
     623            1 :         CK_RV rv = CKR_OK;
     624              : 
     625            1 :         prompt = gkm_wrap_prompt_for_set_pin (gkm_wrap_layer_get_functions_no_prompts(),
     626              :                                               handle, old_pin, old_pin_len, new_pin, new_pin_len);
     627              : 
     628              :         for (;;) {
     629            1 :                 if (prompt && !gkm_wrap_prompt_do_set_pin (prompt, rv, &old_pin, &old_pin_len,
     630              :                                                            &new_pin, &new_pin_len))
     631            0 :                         break;
     632              : 
     633            1 :                 rv = wrap_C_SetPIN (handle, old_pin, old_pin_len, new_pin, new_pin_len);
     634              : 
     635            1 :                 if (!prompt || rv != CKR_PIN_INCORRECT ||
     636            0 :                     rv != CKR_PIN_INVALID || rv != CKR_PIN_LEN_RANGE)
     637              :                         break;
     638              :         }
     639              : 
     640            1 :         if (prompt) {
     641            1 :                 gkm_wrap_prompt_done_set_pin (prompt, rv);
     642            1 :                 g_object_unref (prompt);
     643              :         }
     644              : 
     645            1 :         return rv;
     646              : }
     647              : 
     648              : static CK_RV
     649            0 : wrap_C_GetOperationState (CK_SESSION_HANDLE handle, CK_BYTE_PTR operation_state, CK_ULONG_PTR operation_state_len)
     650              : {
     651              :         Mapping map;
     652              :         CK_RV rv;
     653              : 
     654            0 :         rv = map_session_to_real (&handle, &map, NULL);
     655            0 :         if (rv != CKR_OK)
     656            0 :                 return rv;
     657            0 :         return (map.funcs->C_GetOperationState) (handle, operation_state, operation_state_len);
     658              : }
     659              : 
     660              : static CK_RV
     661            0 : wrap_C_SetOperationState (CK_SESSION_HANDLE handle, CK_BYTE_PTR operation_state,
     662              :                           CK_ULONG operation_state_len, CK_OBJECT_HANDLE encryption_key,
     663              :                           CK_OBJECT_HANDLE authentication_key)
     664              : {
     665              :         Mapping map;
     666              :         CK_RV rv;
     667              : 
     668            0 :         rv = map_session_to_real (&handle, &map, NULL);
     669            0 :         if (rv != CKR_OK)
     670            0 :                 return rv;
     671            0 :         return (map.funcs->C_SetOperationState) (handle, operation_state, operation_state_len, encryption_key, authentication_key);
     672              : }
     673              : 
     674              : static CK_RV
     675          146 : wrap_C_Login (CK_SESSION_HANDLE handle, CK_USER_TYPE user_type,
     676              :               CK_UTF8CHAR_PTR pin, CK_ULONG pin_len)
     677              : {
     678              :         Mapping map;
     679              :         CK_RV rv;
     680              : 
     681          146 :         rv = map_session_to_real (&handle, &map, NULL);
     682          146 :         if (rv != CKR_OK)
     683            0 :                 return rv;
     684              : 
     685          146 :         return (map.funcs->C_Login) (handle, user_type, pin, pin_len);
     686              : }
     687              : 
     688              : static CK_RV
     689           59 : auth_C_Login (CK_SESSION_HANDLE handle, CK_USER_TYPE user_type,
     690              :               CK_UTF8CHAR_PTR pin, CK_ULONG pin_len)
     691              : {
     692              :         GkmWrapPrompt *prompt;
     693              :         CK_OBJECT_HANDLE specific;
     694              :         CK_RV rv;
     695              : 
     696           59 :         lookup_session_specific (handle, &specific);
     697           59 :         prompt = gkm_wrap_prompt_for_login (gkm_wrap_layer_get_functions_no_prompts(),
     698              :                                             user_type, handle, specific, pin, pin_len);
     699              : 
     700              :         for (;;) {
     701           71 :                 rv = wrap_C_Login (handle, user_type, pin, pin_len);
     702              : 
     703           71 :                 if (!prompt || rv != CKR_PIN_INCORRECT)
     704              :                         break;
     705              : 
     706           18 :                 if (!gkm_wrap_prompt_do_login (prompt, user_type, rv, &pin, &pin_len))
     707            6 :                         break;
     708              :         }
     709              : 
     710           59 :         if (prompt) {
     711           55 :                 gkm_wrap_prompt_done_login (prompt, user_type, rv);
     712           55 :                 g_object_unref (prompt);
     713              :         }
     714              : 
     715           59 :         return rv;
     716              : }
     717              : 
     718              : static CK_RV
     719            2 : wrap_C_Logout (CK_SESSION_HANDLE handle)
     720              : {
     721              :         Mapping map;
     722              :         CK_RV rv;
     723              : 
     724            2 :         rv = map_session_to_real (&handle, &map, NULL);
     725            2 :         if (rv != CKR_OK)
     726            0 :                 return rv;
     727            2 :         return (map.funcs->C_Logout) (handle);
     728              : }
     729              : 
     730              : static CK_RV
     731           78 : wrap_C_CreateObject (CK_SESSION_HANDLE handle, CK_ATTRIBUTE_PTR template,
     732              :                      CK_ULONG count, CK_OBJECT_HANDLE_PTR new_object)
     733              : {
     734              :         Mapping map;
     735              :         CK_RV rv;
     736              : 
     737           78 :         rv = map_session_to_real (&handle, &map, NULL);
     738           78 :         if (rv != CKR_OK)
     739            0 :                 return rv;
     740              : 
     741           78 :         return (map.funcs->C_CreateObject) (handle, template, count, new_object);
     742              : }
     743              : 
     744              : static CK_RV
     745           37 : auth_C_CreateObject (CK_SESSION_HANDLE handle, CK_ATTRIBUTE_PTR template,
     746              :                      CK_ULONG count, CK_OBJECT_HANDLE_PTR new_object)
     747              : {
     748           37 :         GkmWrapPrompt *prompt = NULL;
     749              :         CK_RV rv;
     750              : 
     751              :         for (;;) {
     752           45 :                 rv = wrap_C_CreateObject (handle, template, count, new_object);
     753              : 
     754           45 :                 if (rv != CKR_PIN_INCORRECT)
     755           34 :                         break;
     756              : 
     757           11 :                 if (!prompt) {
     758            9 :                         prompt = gkm_wrap_prompt_for_credential (gkm_wrap_layer_get_functions_no_prompts(),
     759              :                                                                  handle, template, count);
     760            9 :                         if (prompt == NULL)
     761            1 :                                 break;
     762              :                 }
     763              : 
     764           10 :                 if (!gkm_wrap_prompt_do_credential (prompt, &template, &count))
     765            2 :                         break;
     766              :         }
     767              : 
     768              : 
     769           37 :         if (prompt) {
     770            8 :                 gkm_wrap_prompt_done_credential (prompt, rv);
     771            8 :                 g_object_unref (prompt);
     772              :         }
     773              : 
     774           37 :         return rv;
     775              : }
     776              : 
     777              : static CK_RV
     778            0 : wrap_C_CopyObject (CK_SESSION_HANDLE handle, CK_OBJECT_HANDLE object,
     779              :                    CK_ATTRIBUTE_PTR template, CK_ULONG count,
     780              :                    CK_OBJECT_HANDLE_PTR new_object)
     781              : {
     782              :         Mapping map;
     783              :         CK_RV rv;
     784              : 
     785            0 :         rv = map_session_to_real (&handle, &map, NULL);
     786            0 :         if (rv != CKR_OK)
     787            0 :                 return rv;
     788            0 :         return (map.funcs->C_CopyObject) (handle, object, template, count, new_object);
     789              : }
     790              : 
     791              : static CK_RV
     792           41 : wrap_C_DestroyObject (CK_SESSION_HANDLE handle, CK_OBJECT_HANDLE object)
     793              : {
     794              :         Mapping map;
     795              :         CK_RV rv;
     796              : 
     797           41 :         rv = map_session_to_real (&handle, &map, NULL);
     798           41 :         if (rv != CKR_OK)
     799            0 :                 return rv;
     800           41 :         return (map.funcs->C_DestroyObject) (handle, object);
     801              : }
     802              : 
     803              : static CK_RV
     804            0 : wrap_C_GetObjectSize (CK_SESSION_HANDLE handle, CK_OBJECT_HANDLE object,
     805              :                       CK_ULONG_PTR size)
     806              : {
     807              :         Mapping map;
     808              :         CK_RV rv;
     809              : 
     810            0 :         rv = map_session_to_real (&handle, &map, NULL);
     811            0 :         if (rv != CKR_OK)
     812            0 :                 return rv;
     813            0 :         return (map.funcs->C_GetObjectSize) (handle, object, size);
     814              : }
     815              : 
     816              : static CK_RV
     817          650 : wrap_C_GetAttributeValue (CK_SESSION_HANDLE handle, CK_OBJECT_HANDLE object,
     818              :                           CK_ATTRIBUTE_PTR template, CK_ULONG count)
     819              : {
     820              :         Mapping map;
     821              :         CK_RV rv;
     822              : 
     823          650 :         rv = map_session_to_real (&handle, &map, NULL);
     824          650 :         if (rv != CKR_OK)
     825            0 :                 return rv;
     826          650 :         return (map.funcs->C_GetAttributeValue) (handle, object, template, count);
     827              : }
     828              : 
     829              : static CK_RV
     830            8 : wrap_C_SetAttributeValue (CK_SESSION_HANDLE handle, CK_OBJECT_HANDLE object,
     831              :                          CK_ATTRIBUTE_PTR template, CK_ULONG count)
     832              : {
     833              :         Mapping map;
     834              :         CK_RV rv;
     835              : 
     836            8 :         rv = map_session_to_real (&handle, &map, NULL);
     837            8 :         if (rv != CKR_OK)
     838            0 :                 return rv;
     839            8 :         return (map.funcs->C_SetAttributeValue) (handle, object, template, count);
     840              : }
     841              : 
     842              : static CK_RV
     843          237 : wrap_C_FindObjectsInit (CK_SESSION_HANDLE handle, CK_ATTRIBUTE_PTR template,
     844              :                         CK_ULONG count)
     845              : {
     846              :         Mapping map;
     847              :         CK_RV rv;
     848              : 
     849          237 :         rv = map_session_to_real (&handle, &map, NULL);
     850          237 :         if (rv != CKR_OK)
     851            0 :                 return rv;
     852          237 :         return (map.funcs->C_FindObjectsInit) (handle, template, count);
     853              : }
     854              : 
     855              : static CK_RV
     856          357 : wrap_C_FindObjects (CK_SESSION_HANDLE handle, CK_OBJECT_HANDLE_PTR objects,
     857              :                     CK_ULONG max_count, CK_ULONG_PTR count)
     858              : {
     859              :         Mapping map;
     860              :         CK_RV rv;
     861              : 
     862          357 :         rv = map_session_to_real (&handle, &map, NULL);
     863          357 :         if (rv != CKR_OK)
     864            0 :                 return rv;
     865          357 :         return (map.funcs->C_FindObjects) (handle, objects, max_count, count);
     866              : }
     867              : 
     868              : static CK_RV
     869          237 : wrap_C_FindObjectsFinal (CK_SESSION_HANDLE handle)
     870              : {
     871              :         Mapping map;
     872              :         CK_RV rv;
     873              : 
     874          237 :         rv = map_session_to_real (&handle, &map, NULL);
     875          237 :         if (rv != CKR_OK)
     876            0 :                 return rv;
     877          237 :         return (map.funcs->C_FindObjectsFinal) (handle);
     878              : }
     879              : 
     880              : static CK_RV
     881            0 : wrap_C_EncryptInit (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism,
     882              :                     CK_OBJECT_HANDLE key)
     883              : {
     884              :         Mapping map;
     885              :         CK_RV rv;
     886              : 
     887            0 :         rv = map_session_to_real (&handle, &map, NULL);
     888            0 :         if (rv != CKR_OK)
     889            0 :                 return rv;
     890            0 :         return (map.funcs->C_EncryptInit) (handle, mechanism, key);
     891              : }
     892              : 
     893              : static CK_RV
     894            0 : auth_C_EncryptInit (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism,
     895              :                     CK_OBJECT_HANDLE key)
     896              : {
     897            0 :         CK_RV rv = wrap_C_EncryptInit (handle, mechanism, key);
     898            0 :         if (rv == CKR_OK)
     899            0 :                 store_session_specific (handle, key);
     900            0 :         return rv;
     901              : }
     902              : 
     903              : static CK_RV
     904            0 : wrap_C_Encrypt (CK_SESSION_HANDLE handle, CK_BYTE_PTR data, CK_ULONG data_len,
     905              :                 CK_BYTE_PTR encrypted_data, CK_ULONG_PTR encrypted_data_len)
     906              : {
     907              :         Mapping map;
     908              :         CK_RV rv;
     909              : 
     910            0 :         rv = map_session_to_real (&handle, &map, NULL);
     911            0 :         if (rv != CKR_OK)
     912            0 :                 return rv;
     913            0 :         return (map.funcs->C_Encrypt) (handle, data, data_len, encrypted_data, encrypted_data_len);
     914              : }
     915              : 
     916              : static CK_RV
     917            0 : wrap_C_EncryptUpdate (CK_SESSION_HANDLE handle, CK_BYTE_PTR part,
     918              :                       CK_ULONG part_len, CK_BYTE_PTR encrypted_part,
     919              :                       CK_ULONG_PTR encrypted_part_len)
     920              : {
     921              :         Mapping map;
     922              :         CK_RV rv;
     923              : 
     924            0 :         rv = map_session_to_real (&handle, &map, NULL);
     925            0 :         if (rv != CKR_OK)
     926            0 :                 return rv;
     927            0 :         return (map.funcs->C_EncryptUpdate) (handle, part, part_len, encrypted_part, encrypted_part_len);
     928              : }
     929              : 
     930              : static CK_RV
     931            0 : wrap_C_EncryptFinal (CK_SESSION_HANDLE handle, CK_BYTE_PTR last_part,
     932              :                      CK_ULONG_PTR last_part_len)
     933              : {
     934              :         Mapping map;
     935              :         CK_RV rv;
     936              : 
     937            0 :         rv = map_session_to_real (&handle, &map, NULL);
     938            0 :         if (rv != CKR_OK)
     939            0 :                 return rv;
     940            0 :         return (map.funcs->C_EncryptFinal) (handle, last_part, last_part_len);
     941              : }
     942              : 
     943              : static CK_RV
     944            0 : wrap_C_DecryptInit (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism,
     945              :                     CK_OBJECT_HANDLE key)
     946              : {
     947              :         Mapping map;
     948              :         CK_RV rv;
     949              : 
     950            0 :         rv = map_session_to_real (&handle, &map, NULL);
     951            0 :         if (rv != CKR_OK)
     952            0 :                 return rv;
     953            0 :         return (map.funcs->C_DecryptInit) (handle, mechanism, key);
     954              : }
     955              : 
     956              : static CK_RV
     957            0 : auth_C_DecryptInit (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism,
     958              :                     CK_OBJECT_HANDLE key)
     959              : {
     960            0 :         CK_RV rv = wrap_C_DecryptInit (handle, mechanism, key);
     961            0 :         if (rv == CKR_OK)
     962            0 :                 store_session_specific (handle, key);
     963            0 :         return rv;
     964              : }
     965              : 
     966              : static CK_RV
     967            0 : wrap_C_Decrypt (CK_SESSION_HANDLE handle, CK_BYTE_PTR enc_data,
     968              :                 CK_ULONG enc_data_len, CK_BYTE_PTR data, CK_ULONG_PTR data_len)
     969              : {
     970              :         Mapping map;
     971              :         CK_RV rv;
     972              : 
     973            0 :         rv = map_session_to_real (&handle, &map, NULL);
     974            0 :         if (rv != CKR_OK)
     975            0 :                 return rv;
     976            0 :         return (map.funcs->C_Decrypt) (handle, enc_data, enc_data_len, data, data_len);
     977              : }
     978              : 
     979              : static CK_RV
     980            0 : wrap_C_DecryptUpdate (CK_SESSION_HANDLE handle, CK_BYTE_PTR enc_part,
     981              :                      CK_ULONG enc_part_len, CK_BYTE_PTR part, CK_ULONG_PTR part_len)
     982              : {
     983              :         Mapping map;
     984              :         CK_RV rv;
     985              : 
     986            0 :         rv = map_session_to_real (&handle, &map, NULL);
     987            0 :         if (rv != CKR_OK)
     988            0 :                 return rv;
     989            0 :         return (map.funcs->C_DecryptUpdate) (handle, enc_part, enc_part_len, part, part_len);
     990              : }
     991              : 
     992              : static CK_RV
     993            0 : wrap_C_DecryptFinal (CK_SESSION_HANDLE handle, CK_BYTE_PTR last_part,
     994              :                      CK_ULONG_PTR last_part_len)
     995              : {
     996              :         Mapping map;
     997              :         CK_RV rv;
     998              : 
     999            0 :         rv = map_session_to_real (&handle, &map, NULL);
    1000            0 :         if (rv != CKR_OK)
    1001            0 :                 return rv;
    1002            0 :         return (map.funcs->C_DecryptFinal) (handle, last_part, last_part_len);
    1003              : }
    1004              : 
    1005              : static CK_RV
    1006            0 : wrap_C_DigestInit (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism)
    1007              : {
    1008              :         Mapping map;
    1009              :         CK_RV rv;
    1010              : 
    1011            0 :         rv = map_session_to_real (&handle, &map, NULL);
    1012            0 :         if (rv != CKR_OK)
    1013            0 :                 return rv;
    1014            0 :         return (map.funcs->C_DigestInit) (handle, mechanism);
    1015              : }
    1016              : 
    1017              : static CK_RV
    1018            0 : wrap_C_Digest (CK_SESSION_HANDLE handle, CK_BYTE_PTR data, CK_ULONG data_len,
    1019              :                CK_BYTE_PTR digest, CK_ULONG_PTR digest_len)
    1020              : {
    1021              :         Mapping map;
    1022              :         CK_RV rv;
    1023              : 
    1024            0 :         rv = map_session_to_real (&handle, &map, NULL);
    1025            0 :         if (rv != CKR_OK)
    1026            0 :                 return rv;
    1027            0 :         return (map.funcs->C_Digest) (handle, data, data_len, digest, digest_len);
    1028              : }
    1029              : 
    1030              : static CK_RV
    1031            0 : wrap_C_DigestUpdate (CK_SESSION_HANDLE handle, CK_BYTE_PTR part, CK_ULONG part_len)
    1032              : {
    1033              :         Mapping map;
    1034              :         CK_RV rv;
    1035              : 
    1036            0 :         rv = map_session_to_real (&handle, &map, NULL);
    1037            0 :         if (rv != CKR_OK)
    1038            0 :                 return rv;
    1039            0 :         return (map.funcs->C_DigestUpdate) (handle, part, part_len);
    1040              : }
    1041              : 
    1042              : static CK_RV
    1043            0 : wrap_C_DigestKey (CK_SESSION_HANDLE handle, CK_OBJECT_HANDLE key)
    1044              : {
    1045              :         Mapping map;
    1046              :         CK_RV rv;
    1047              : 
    1048            0 :         rv = map_session_to_real (&handle, &map, NULL);
    1049            0 :         if (rv != CKR_OK)
    1050            0 :                 return rv;
    1051            0 :         return (map.funcs->C_DigestKey) (handle, key);
    1052              : }
    1053              : 
    1054              : static CK_RV
    1055            0 : wrap_C_DigestFinal (CK_SESSION_HANDLE handle, CK_BYTE_PTR digest,
    1056              :                     CK_ULONG_PTR digest_len)
    1057              : {
    1058              :         Mapping map;
    1059              :         CK_RV rv;
    1060              : 
    1061            0 :         rv = map_session_to_real (&handle, &map, NULL);
    1062            0 :         if (rv != CKR_OK)
    1063            0 :                 return rv;
    1064            0 :         return (map.funcs->C_DigestFinal) (handle, digest, digest_len);
    1065              : }
    1066              : 
    1067              : static CK_RV
    1068            8 : wrap_C_SignInit (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism,
    1069              :                  CK_OBJECT_HANDLE key)
    1070              : {
    1071              :         Mapping map;
    1072              :         CK_RV rv;
    1073              : 
    1074            8 :         rv = map_session_to_real (&handle, &map, NULL);
    1075            8 :         if (rv != CKR_OK)
    1076            0 :                 return rv;
    1077            8 :         return (map.funcs->C_SignInit) (handle, mechanism, key);
    1078              : }
    1079              : 
    1080              : static CK_RV
    1081            8 : auth_C_SignInit (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism,
    1082              :                  CK_OBJECT_HANDLE key)
    1083              : {
    1084            8 :         CK_RV rv = wrap_C_SignInit (handle, mechanism, key);
    1085            8 :         if (rv == CKR_OK)
    1086            8 :                 store_session_specific (handle, key);
    1087            8 :         return rv;
    1088              : }
    1089              : 
    1090              : static CK_RV
    1091            0 : wrap_C_Sign (CK_SESSION_HANDLE handle, CK_BYTE_PTR data, CK_ULONG data_len,
    1092              :              CK_BYTE_PTR signature, CK_ULONG_PTR signature_len)
    1093              : {
    1094              :         Mapping map;
    1095              :         CK_RV rv;
    1096              : 
    1097            0 :         rv = map_session_to_real (&handle, &map, NULL);
    1098            0 :         if (rv != CKR_OK)
    1099            0 :                 return rv;
    1100            0 :         return (map.funcs->C_Sign) (handle, data, data_len, signature, signature_len);
    1101              : }
    1102              : 
    1103              : static CK_RV
    1104            0 : wrap_C_SignUpdate (CK_SESSION_HANDLE handle, CK_BYTE_PTR part, CK_ULONG part_len)
    1105              : {
    1106              :         Mapping map;
    1107              :         CK_RV rv;
    1108              : 
    1109            0 :         rv = map_session_to_real (&handle, &map, NULL);
    1110            0 :         if (rv != CKR_OK)
    1111            0 :                 return rv;
    1112            0 :         return (map.funcs->C_SignUpdate) (handle, part, part_len);
    1113              : }
    1114              : 
    1115              : static CK_RV
    1116            0 : wrap_C_SignFinal (CK_SESSION_HANDLE handle, CK_BYTE_PTR signature,
    1117              :                   CK_ULONG_PTR signature_len)
    1118              : {
    1119              :         Mapping map;
    1120              :         CK_RV rv;
    1121              : 
    1122            0 :         rv = map_session_to_real (&handle, &map, NULL);
    1123            0 :         if (rv != CKR_OK)
    1124            0 :                 return rv;
    1125            0 :         return (map.funcs->C_SignFinal) (handle, signature, signature_len);
    1126              : }
    1127              : 
    1128              : static CK_RV
    1129            0 : wrap_C_SignRecoverInit (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism,
    1130              :                         CK_OBJECT_HANDLE key)
    1131              : {
    1132              :         Mapping map;
    1133              :         CK_RV rv;
    1134              : 
    1135            0 :         rv = map_session_to_real (&handle, &map, NULL);
    1136            0 :         if (rv != CKR_OK)
    1137            0 :                 return rv;
    1138            0 :         return (map.funcs->C_SignRecoverInit) (handle, mechanism, key);
    1139              : }
    1140              : 
    1141              : static CK_RV
    1142            0 : auth_C_SignRecoverInit (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism,
    1143              :                         CK_OBJECT_HANDLE key)
    1144              : {
    1145            0 :         CK_RV rv = wrap_C_SignRecoverInit (handle, mechanism, key);
    1146            0 :         if (rv == CKR_OK)
    1147            0 :                 store_session_specific (handle, key);
    1148            0 :         return rv;
    1149              : }
    1150              : 
    1151              : static CK_RV
    1152            0 : wrap_C_SignRecover (CK_SESSION_HANDLE handle, CK_BYTE_PTR data, CK_ULONG data_len,
    1153              :                     CK_BYTE_PTR signature, CK_ULONG_PTR signature_len)
    1154              : {
    1155              :         Mapping map;
    1156              :         CK_RV rv;
    1157              : 
    1158            0 :         rv = map_session_to_real (&handle, &map, NULL);
    1159            0 :         if (rv != CKR_OK)
    1160            0 :                 return rv;
    1161            0 :         return (map.funcs->C_SignRecover) (handle, data, data_len, signature, signature_len);
    1162              : }
    1163              : 
    1164              : static CK_RV
    1165            0 : wrap_C_VerifyInit (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism,
    1166              :                    CK_OBJECT_HANDLE key)
    1167              : {
    1168              :         Mapping map;
    1169              :         CK_RV rv;
    1170              : 
    1171            0 :         rv = map_session_to_real (&handle, &map, NULL);
    1172            0 :         if (rv != CKR_OK)
    1173            0 :                 return rv;
    1174            0 :         return (map.funcs->C_VerifyInit) (handle, mechanism, key);
    1175              : }
    1176              : 
    1177              : static CK_RV
    1178            0 : auth_C_VerifyInit (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism,
    1179              :                    CK_OBJECT_HANDLE key)
    1180              : {
    1181            0 :         CK_RV rv = wrap_C_VerifyInit (handle, mechanism, key);
    1182            0 :         if (rv == CKR_OK)
    1183            0 :                 store_session_specific (handle, key);
    1184            0 :         return rv;
    1185              : }
    1186              : 
    1187              : static CK_RV
    1188            0 : wrap_C_Verify (CK_SESSION_HANDLE handle, CK_BYTE_PTR data, CK_ULONG data_len,
    1189              :                CK_BYTE_PTR signature, CK_ULONG signature_len)
    1190              : {
    1191              :         Mapping map;
    1192              :         CK_RV rv;
    1193              : 
    1194            0 :         rv = map_session_to_real (&handle, &map, NULL);
    1195            0 :         if (rv != CKR_OK)
    1196            0 :                 return rv;
    1197            0 :         return (map.funcs->C_Verify) (handle, data, data_len, signature, signature_len);
    1198              : }
    1199              : 
    1200              : static CK_RV
    1201            0 : wrap_C_VerifyUpdate (CK_SESSION_HANDLE handle, CK_BYTE_PTR part, CK_ULONG part_len)
    1202              : {
    1203              :         Mapping map;
    1204              :         CK_RV rv;
    1205              : 
    1206            0 :         rv = map_session_to_real (&handle, &map, NULL);
    1207            0 :         if (rv != CKR_OK)
    1208            0 :                 return rv;
    1209            0 :         return (map.funcs->C_VerifyUpdate) (handle, part, part_len);
    1210              : }
    1211              : 
    1212              : static CK_RV
    1213            0 : wrap_C_VerifyFinal (CK_SESSION_HANDLE handle, CK_BYTE_PTR signature,
    1214              :                     CK_ULONG signature_len)
    1215              : {
    1216              :         Mapping map;
    1217              :         CK_RV rv;
    1218              : 
    1219            0 :         rv = map_session_to_real (&handle, &map, NULL);
    1220            0 :         if (rv != CKR_OK)
    1221            0 :                 return rv;
    1222            0 :         return (map.funcs->C_VerifyFinal) (handle, signature, signature_len);
    1223              : }
    1224              : 
    1225              : static CK_RV
    1226            0 : wrap_C_VerifyRecoverInit (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism,
    1227              :                           CK_OBJECT_HANDLE key)
    1228              : {
    1229              :         Mapping map;
    1230              :         CK_RV rv;
    1231              : 
    1232            0 :         rv = map_session_to_real (&handle, &map, NULL);
    1233            0 :         if (rv != CKR_OK)
    1234            0 :                 return rv;
    1235            0 :         return (map.funcs->C_VerifyRecoverInit) (handle, mechanism, key);
    1236              : }
    1237              : 
    1238              : static CK_RV
    1239            0 : auth_C_VerifyRecoverInit (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism,
    1240              :                           CK_OBJECT_HANDLE key)
    1241              : {
    1242            0 :         CK_RV rv = wrap_C_VerifyInit (handle, mechanism, key);
    1243            0 :         if (rv == CKR_OK)
    1244            0 :                 store_session_specific (handle, key);
    1245            0 :         return rv;
    1246              : }
    1247              : 
    1248              : static CK_RV
    1249            0 : wrap_C_VerifyRecover (CK_SESSION_HANDLE handle, CK_BYTE_PTR signature,
    1250              :                      CK_ULONG signature_len, CK_BYTE_PTR data, CK_ULONG_PTR data_len)
    1251              : {
    1252              :         Mapping map;
    1253              :         CK_RV rv;
    1254              : 
    1255            0 :         rv = map_session_to_real (&handle, &map, NULL);
    1256            0 :         if (rv != CKR_OK)
    1257            0 :                 return rv;
    1258            0 :         return (map.funcs->C_VerifyRecover) (handle, signature, signature_len, data, data_len);
    1259              : }
    1260              : 
    1261              : static CK_RV
    1262            0 : wrap_C_DigestEncryptUpdate (CK_SESSION_HANDLE handle, CK_BYTE_PTR part,
    1263              :                             CK_ULONG part_len, CK_BYTE_PTR enc_part,
    1264              :                             CK_ULONG_PTR enc_part_len)
    1265              : {
    1266              :         Mapping map;
    1267              :         CK_RV rv;
    1268              : 
    1269            0 :         rv = map_session_to_real (&handle, &map, NULL);
    1270            0 :         if (rv != CKR_OK)
    1271            0 :                 return rv;
    1272            0 :         return (map.funcs->C_DigestEncryptUpdate) (handle, part, part_len, enc_part, enc_part_len);
    1273              : }
    1274              : 
    1275              : static CK_RV
    1276            0 : wrap_C_DecryptDigestUpdate (CK_SESSION_HANDLE handle, CK_BYTE_PTR enc_part,
    1277              :                             CK_ULONG enc_part_len, CK_BYTE_PTR part,
    1278              :                             CK_ULONG_PTR part_len)
    1279              : {
    1280              :         Mapping map;
    1281              :         CK_RV rv;
    1282              : 
    1283            0 :         rv = map_session_to_real (&handle, &map, NULL);
    1284            0 :         if (rv != CKR_OK)
    1285            0 :                 return rv;
    1286            0 :         return (map.funcs->C_DecryptDigestUpdate) (handle, enc_part, enc_part_len, part, part_len);
    1287              : }
    1288              : 
    1289              : static CK_RV
    1290            0 : wrap_C_SignEncryptUpdate (CK_SESSION_HANDLE handle, CK_BYTE_PTR part,
    1291              :                           CK_ULONG part_len, CK_BYTE_PTR enc_part,
    1292              :                           CK_ULONG_PTR enc_part_len)
    1293              : {
    1294              :         Mapping map;
    1295              :         CK_RV rv;
    1296              : 
    1297            0 :         rv = map_session_to_real (&handle, &map, NULL);
    1298            0 :         if (rv != CKR_OK)
    1299            0 :                 return rv;
    1300            0 :         return (map.funcs->C_SignEncryptUpdate) (handle, part, part_len, enc_part, enc_part_len);
    1301              : }
    1302              : 
    1303              : static CK_RV
    1304            0 : wrap_C_DecryptVerifyUpdate (CK_SESSION_HANDLE handle, CK_BYTE_PTR enc_part,
    1305              :                             CK_ULONG enc_part_len, CK_BYTE_PTR part,
    1306              :                             CK_ULONG_PTR part_len)
    1307              : {
    1308              :         Mapping map;
    1309              :         CK_RV rv;
    1310              : 
    1311            0 :         rv = map_session_to_real (&handle, &map, NULL);
    1312            0 :         if (rv != CKR_OK)
    1313            0 :                 return rv;
    1314            0 :         return (map.funcs->C_DecryptVerifyUpdate) (handle, enc_part, enc_part_len, part, part_len);
    1315              : }
    1316              : 
    1317              : static CK_RV
    1318            0 : wrap_C_GenerateKey (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism,
    1319              :                     CK_ATTRIBUTE_PTR template, CK_ULONG count,
    1320              :                     CK_OBJECT_HANDLE_PTR key)
    1321              : {
    1322              :         Mapping map;
    1323              :         CK_RV rv;
    1324              : 
    1325            0 :         rv = map_session_to_real (&handle, &map, NULL);
    1326            0 :         if (rv != CKR_OK)
    1327            0 :                 return rv;
    1328            0 :         return (map.funcs->C_GenerateKey) (handle, mechanism, template, count, key);
    1329              : }
    1330              : 
    1331              : static CK_RV
    1332            1 : wrap_C_GenerateKeyPair (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism,
    1333              :                         CK_ATTRIBUTE_PTR pub_template, CK_ULONG pub_count,
    1334              :                         CK_ATTRIBUTE_PTR priv_template, CK_ULONG priv_count,
    1335              :                         CK_OBJECT_HANDLE_PTR pub_key, CK_OBJECT_HANDLE_PTR priv_key)
    1336              : {
    1337              :         Mapping map;
    1338              :         CK_RV rv;
    1339              : 
    1340            1 :         rv = map_session_to_real (&handle, &map, NULL);
    1341            1 :         if (rv != CKR_OK)
    1342            0 :                 return rv;
    1343            1 :         return (map.funcs->C_GenerateKeyPair) (handle, mechanism, pub_template, pub_count, priv_template, priv_count, pub_key, priv_key);
    1344              : }
    1345              : 
    1346              : static CK_RV
    1347            0 : wrap_C_WrapKey (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism,
    1348              :                 CK_OBJECT_HANDLE wrapping_key, CK_OBJECT_HANDLE key,
    1349              :                 CK_BYTE_PTR wrapped_key, CK_ULONG_PTR wrapped_key_len)
    1350              : {
    1351              :         Mapping map;
    1352              :         CK_RV rv;
    1353              : 
    1354            0 :         rv = map_session_to_real (&handle, &map, NULL);
    1355            0 :         if (rv != CKR_OK)
    1356            0 :                 return rv;
    1357            0 :         return (map.funcs->C_WrapKey) (handle, mechanism, wrapping_key, key, wrapped_key, wrapped_key_len);
    1358              : }
    1359              : 
    1360              : static CK_RV
    1361           19 : wrap_C_UnwrapKey (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism,
    1362              :                   CK_OBJECT_HANDLE unwrapping_key, CK_BYTE_PTR wrapped_key,
    1363              :                   CK_ULONG wrapped_key_len, CK_ATTRIBUTE_PTR template,
    1364              :                   CK_ULONG count, CK_OBJECT_HANDLE_PTR key)
    1365              : {
    1366              :         Mapping map;
    1367              :         CK_RV rv;
    1368              : 
    1369           19 :         rv = map_session_to_real (&handle, &map, NULL);
    1370           19 :         if (rv != CKR_OK)
    1371            0 :                 return rv;
    1372           19 :         return (map.funcs->C_UnwrapKey) (handle, mechanism, unwrapping_key, wrapped_key, wrapped_key_len, template, count, key);
    1373              : }
    1374              : 
    1375              : static CK_RV
    1376            2 : wrap_C_DeriveKey (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism,
    1377              :                   CK_OBJECT_HANDLE base_key, CK_ATTRIBUTE_PTR template,
    1378              :                   CK_ULONG count, CK_OBJECT_HANDLE_PTR key)
    1379              : {
    1380              :         Mapping map;
    1381              :         CK_RV rv;
    1382              : 
    1383            2 :         rv = map_session_to_real (&handle, &map, NULL);
    1384            2 :         if (rv != CKR_OK)
    1385            0 :                 return rv;
    1386            2 :         return (map.funcs->C_DeriveKey) (handle, mechanism, base_key, template, count, key);
    1387              : }
    1388              : 
    1389              : static CK_RV
    1390            0 : wrap_C_SeedRandom (CK_SESSION_HANDLE handle, CK_BYTE_PTR seed, CK_ULONG seed_len)
    1391              : {
    1392              :         Mapping map;
    1393              :         CK_RV rv;
    1394              : 
    1395            0 :         rv = map_session_to_real (&handle, &map, NULL);
    1396            0 :         if (rv != CKR_OK)
    1397            0 :                 return rv;
    1398            0 :         return (map.funcs->C_SeedRandom) (handle, seed, seed_len);
    1399              : }
    1400              : 
    1401              : static CK_RV
    1402            0 : wrap_C_GenerateRandom (CK_SESSION_HANDLE handle, CK_BYTE_PTR random_data,
    1403              :                       CK_ULONG random_len)
    1404              : {
    1405              :         Mapping map;
    1406              :         CK_RV rv;
    1407              : 
    1408            0 :         rv = map_session_to_real (&handle, &map, NULL);
    1409            0 :         if (rv != CKR_OK)
    1410            0 :                 return rv;
    1411            0 :         return (map.funcs->C_GenerateRandom) (handle, random_data, random_len);
    1412              : }
    1413              : 
    1414              : /* --------------------------------------------------------------------
    1415              :  * MODULE ENTRY POINT
    1416              :  */
    1417              : 
    1418              : static CK_FUNCTION_LIST wrap_function_list = {
    1419              :         { CRYPTOKI_VERSION_MAJOR, CRYPTOKI_VERSION_MINOR },  /* version */
    1420              :         wrap_C_Initialize,
    1421              :         wrap_C_Finalize,
    1422              :         wrap_C_GetInfo,
    1423              :         wrap_C_GetFunctionList,
    1424              :         wrap_C_GetSlotList,
    1425              :         wrap_C_GetSlotInfo,
    1426              :         wrap_C_GetTokenInfo,
    1427              :         wrap_C_GetMechanismList,
    1428              :         wrap_C_GetMechanismInfo,
    1429              :         wrap_C_InitToken,
    1430              :         wrap_C_InitPIN,
    1431              :         wrap_C_SetPIN,
    1432              :         wrap_C_OpenSession,
    1433              :         wrap_C_CloseSession,
    1434              :         wrap_C_CloseAllSessions,
    1435              :         wrap_C_GetSessionInfo,
    1436              :         wrap_C_GetOperationState,
    1437              :         wrap_C_SetOperationState,
    1438              :         wrap_C_Login,
    1439              :         wrap_C_Logout,
    1440              :         wrap_C_CreateObject,
    1441              :         wrap_C_CopyObject,
    1442              :         wrap_C_DestroyObject,
    1443              :         wrap_C_GetObjectSize,
    1444              :         wrap_C_GetAttributeValue,
    1445              :         wrap_C_SetAttributeValue,
    1446              :         wrap_C_FindObjectsInit,
    1447              :         wrap_C_FindObjects,
    1448              :         wrap_C_FindObjectsFinal,
    1449              :         wrap_C_EncryptInit,
    1450              :         wrap_C_Encrypt,
    1451              :         wrap_C_EncryptUpdate,
    1452              :         wrap_C_EncryptFinal,
    1453              :         wrap_C_DecryptInit,
    1454              :         wrap_C_Decrypt,
    1455              :         wrap_C_DecryptUpdate,
    1456              :         wrap_C_DecryptFinal,
    1457              :         wrap_C_DigestInit,
    1458              :         wrap_C_Digest,
    1459              :         wrap_C_DigestUpdate,
    1460              :         wrap_C_DigestKey,
    1461              :         wrap_C_DigestFinal,
    1462              :         wrap_C_SignInit,
    1463              :         wrap_C_Sign,
    1464              :         wrap_C_SignUpdate,
    1465              :         wrap_C_SignFinal,
    1466              :         wrap_C_SignRecoverInit,
    1467              :         wrap_C_SignRecover,
    1468              :         wrap_C_VerifyInit,
    1469              :         wrap_C_Verify,
    1470              :         wrap_C_VerifyUpdate,
    1471              :         wrap_C_VerifyFinal,
    1472              :         wrap_C_VerifyRecoverInit,
    1473              :         wrap_C_VerifyRecover,
    1474              :         wrap_C_DigestEncryptUpdate,
    1475              :         wrap_C_DecryptDigestUpdate,
    1476              :         wrap_C_SignEncryptUpdate,
    1477              :         wrap_C_DecryptVerifyUpdate,
    1478              :         wrap_C_GenerateKey,
    1479              :         wrap_C_GenerateKeyPair,
    1480              :         wrap_C_WrapKey,
    1481              :         wrap_C_UnwrapKey,
    1482              :         wrap_C_DeriveKey,
    1483              :         wrap_C_SeedRandom,
    1484              :         wrap_C_GenerateRandom,
    1485              :         wrap_C_GetFunctionStatus,
    1486              :         wrap_C_CancelFunction,
    1487              :         wrap_C_WaitForSlotEvent
    1488              : };
    1489              : 
    1490              : static CK_FUNCTION_LIST auth_function_list = {
    1491              :         { CRYPTOKI_VERSION_MAJOR, CRYPTOKI_VERSION_MINOR },  /* version */
    1492              :         wrap_C_Initialize,
    1493              :         wrap_C_Finalize,
    1494              :         wrap_C_GetInfo,
    1495              :         auth_C_GetFunctionList,
    1496              :         wrap_C_GetSlotList,
    1497              :         wrap_C_GetSlotInfo,
    1498              :         auth_C_GetTokenInfo,
    1499              :         wrap_C_GetMechanismList,
    1500              :         wrap_C_GetMechanismInfo,
    1501              :         wrap_C_InitToken,
    1502              :         auth_C_InitPIN,
    1503              :         auth_C_SetPIN,
    1504              :         wrap_C_OpenSession,
    1505              :         wrap_C_CloseSession,
    1506              :         wrap_C_CloseAllSessions,
    1507              :         wrap_C_GetSessionInfo,
    1508              :         wrap_C_GetOperationState,
    1509              :         wrap_C_SetOperationState,
    1510              :         auth_C_Login,
    1511              :         wrap_C_Logout,
    1512              :         auth_C_CreateObject,
    1513              :         wrap_C_CopyObject,
    1514              :         wrap_C_DestroyObject,
    1515              :         wrap_C_GetObjectSize,
    1516              :         wrap_C_GetAttributeValue,
    1517              :         wrap_C_SetAttributeValue,
    1518              :         wrap_C_FindObjectsInit,
    1519              :         wrap_C_FindObjects,
    1520              :         wrap_C_FindObjectsFinal,
    1521              :         auth_C_EncryptInit,
    1522              :         wrap_C_Encrypt,
    1523              :         wrap_C_EncryptUpdate,
    1524              :         wrap_C_EncryptFinal,
    1525              :         auth_C_DecryptInit,
    1526              :         wrap_C_Decrypt,
    1527              :         wrap_C_DecryptUpdate,
    1528              :         wrap_C_DecryptFinal,
    1529              :         wrap_C_DigestInit,
    1530              :         wrap_C_Digest,
    1531              :         wrap_C_DigestUpdate,
    1532              :         wrap_C_DigestKey,
    1533              :         wrap_C_DigestFinal,
    1534              :         auth_C_SignInit,
    1535              :         wrap_C_Sign,
    1536              :         wrap_C_SignUpdate,
    1537              :         wrap_C_SignFinal,
    1538              :         auth_C_SignRecoverInit,
    1539              :         wrap_C_SignRecover,
    1540              :         auth_C_VerifyInit,
    1541              :         wrap_C_Verify,
    1542              :         wrap_C_VerifyUpdate,
    1543              :         wrap_C_VerifyFinal,
    1544              :         auth_C_VerifyRecoverInit,
    1545              :         wrap_C_VerifyRecover,
    1546              :         wrap_C_DigestEncryptUpdate,
    1547              :         wrap_C_DecryptDigestUpdate,
    1548              :         wrap_C_SignEncryptUpdate,
    1549              :         wrap_C_DecryptVerifyUpdate,
    1550              :         wrap_C_GenerateKey,
    1551              :         wrap_C_GenerateKeyPair,
    1552              :         wrap_C_WrapKey,
    1553              :         wrap_C_UnwrapKey,
    1554              :         wrap_C_DeriveKey,
    1555              :         wrap_C_SeedRandom,
    1556              :         wrap_C_GenerateRandom,
    1557              :         wrap_C_GetFunctionStatus,
    1558              :         wrap_C_CancelFunction,
    1559              :         wrap_C_WaitForSlotEvent
    1560              : };
    1561              : 
    1562              : /* -----------------------------------------------------------------------------------------
    1563              :  * PUBLIC FUNCTIONS
    1564              :  */
    1565              : 
    1566              : CK_FUNCTION_LIST_PTR
    1567           57 : gkm_wrap_layer_get_functions (void)
    1568              : {
    1569           57 :         return &auth_function_list;
    1570              : }
    1571              : 
    1572              : CK_FUNCTION_LIST_PTR
    1573          160 : gkm_wrap_layer_get_functions_no_prompts (void)
    1574              : {
    1575          160 :         return &wrap_function_list;
    1576              : }
    1577              : 
    1578              : void
    1579           30 : gkm_wrap_layer_reset_modules (void)
    1580              : {
    1581           30 :         G_LOCK (wrap_layer);
    1582              : 
    1583           30 :                 g_assert (!wrap_mappings);
    1584           30 :                 g_assert (!wrap_sessions);
    1585           30 :                 g_list_free (wrap_modules);
    1586           30 :                 wrap_modules = NULL;
    1587              : 
    1588           30 :         G_UNLOCK (wrap_layer);
    1589           30 : }
    1590              : 
    1591              : void
    1592          138 : gkm_wrap_layer_add_module (CK_FUNCTION_LIST_PTR funcs)
    1593              : {
    1594          138 :         g_assert (funcs);
    1595              : 
    1596          138 :         G_LOCK (wrap_layer);
    1597              : 
    1598          138 :                 g_assert (!wrap_mappings);
    1599          138 :                 g_assert (!wrap_sessions);
    1600          138 :                 wrap_modules = g_list_append (wrap_modules, funcs);
    1601              : 
    1602          138 :         G_UNLOCK (wrap_layer);
    1603          138 : }
        

Generated by: LCOV version 2.0-1