obj_mgr.c

IBM的Linux上的PKCS#11实现

   if (rc != CKR_OK){
      st_err_log(146, __FILE__, __LINE__); 
      return FALSE;
   }
   node = priv_token_obj_list;
   while (priv_token_obj_list) {
      CK_OBJECT_HANDLE handle;
      CK_RV            rc;

      obj = (OBJECT *)node->data;

      rc = object_mgr_find_in_map2( obj, &handle );
      if (rc == CKR_OK){
         object_mgr_invalidate_handle1( handle );
      }
      else{
         st_err_log(110, __FILE__, __LINE__);
      }
      object_free( obj );

      next = node->next;
      priv_token_obj_list = dlist_remove_node( priv_token_obj_list, node );
      node = next;
   }

   MY_UnlockMutex( &obj_list_mutex );

   return TRUE;
}


// object_mgr_remove_from_map()
//
CK_RV
object_mgr_remove_from_map( CK_OBJECT_HANDLE  handle )
{
   DL_NODE  *node = NULL;

   //
   // no mutex stuff here.  the calling routine should have locked the mutex
   //

   node = object_map;
   while (node) {
      OBJECT_MAP *map = (OBJECT_MAP *)node->data;

      if (map->handle == handle) {
         object_map = dlist_remove_node( object_map, node );
         free( map );
         return CKR_OK;
      }

      node = node->next;
   }

   st_err_log(4, __FILE__, __LINE__, __FUNCTION__); 
   return CKR_FUNCTION_FAILED;
}


//
//
CK_RV
object_mgr_restore_obj( CK_BYTE *data, OBJECT *oldObj )
{
   OBJECT    * obj  = NULL;
   CK_BBOOL    priv;
   CK_RV       rc;

   if (!data){
      st_err_log(4, __FILE__, __LINE__, __FUNCTION__); 
      return CKR_FUNCTION_FAILED;
   }
   // The calling stack MUST have the mutex
   // to many grab it now.
#if 0
   rc = MY_LockMutex( &obj_list_mutex );
   if (rc != CKR_OK)
      return rc;
#endif

   if (oldObj != NULL) {
      obj = oldObj;
      rc = object_restore( data, &obj, TRUE );
   }
   else {
      rc = object_restore( data, &obj, FALSE );
      if (rc == CKR_OK) {
         priv = object_is_private( obj );

         if (priv)
            priv_token_obj_list = dlist_add_as_last( priv_token_obj_list, obj );
         else
            publ_token_obj_list = dlist_add_as_last( publ_token_obj_list, obj );

         XProcLock( xproclock );
           
         if (priv) {
            if (global_shm->priv_loaded == FALSE){
               if (global_shm->num_priv_tok_obj < MAX_TOK_OBJS) 
                  object_mgr_add_to_shm( obj );
               else{
                  st_err_log(1, __FILE__, __LINE__); 
                  rc = CKR_HOST_MEMORY;
               }
            }
         } else {
            if (global_shm->publ_loaded == FALSE){
               if (global_shm->num_publ_tok_obj < MAX_TOK_OBJS) 
                  object_mgr_add_to_shm( obj );
               else{
                  st_err_log(1, __FILE__, __LINE__); 
                  rc = CKR_HOST_MEMORY;
               }
            }
         }

         XProcUnLock( xproclock );
      } else {
         st_err_log(160, __FILE__, __LINE__); 
      }
   }

   // make the callers have to have the mutes
   // to many grab it now.
#if 0
   MY_UnlockMutex( &obj_list_mutex );
#endif
   return rc;
}


//
//
CK_RV
object_mgr_set_attribute_values( SESSION           * sess,
                                 CK_OBJECT_HANDLE    handle,
                                 CK_ATTRIBUTE      * pTemplate,
                                 CK_ULONG            ulCount )
{
   OBJECT    * obj;
   CK_BBOOL    sess_obj, priv_obj;
   CK_BBOOL    modifiable;
   CK_RV       rc;


   if (!pTemplate){
      st_err_log(4, __FILE__, __LINE__, __FUNCTION__); 
      return CKR_FUNCTION_FAILED;
   }
   rc = MY_LockMutex( &obj_list_mutex );
   if (rc != CKR_OK){
      st_err_log(146, __FILE__, __LINE__); 
      return rc;
   }
   rc = object_mgr_find_in_map1( handle, &obj );
   MY_UnlockMutex( &obj_list_mutex );

   if (rc != CKR_OK) {
      st_err_log(110, __FILE__, __LINE__);
      return CKR_OBJECT_HANDLE_INVALID;
   }


   // determine whether the session is allowed to modify the object
   //
   modifiable = object_is_modifiable( obj );
   sess_obj   = object_is_session_object( obj );
   priv_obj   = object_is_private( obj );

   // if object is not modifiable, it doesn't matter what kind of session
   // is issuing the request...
   //
   if (!modifiable){
      st_err_log(7, __FILE__, __LINE__); 
      return CKR_ATTRIBUTE_READ_ONLY;
   }
   if (sess->session_info.state == CKS_RO_PUBLIC_SESSION) {
      if (priv_obj){
         st_err_log(57, __FILE__, __LINE__); 
         return CKR_USER_NOT_LOGGED_IN;
      }
      if (!sess_obj){
         st_err_log(42, __FILE__, __LINE__); 
         return CKR_SESSION_READ_ONLY;
      }
   }

   if (sess->session_info.state == CKS_RO_USER_FUNCTIONS) {
      if (!sess_obj){
         st_err_log(42, __FILE__, __LINE__); 
         return CKR_SESSION_READ_ONLY;
      }
   }

   if (sess->session_info.state == CKS_RW_PUBLIC_SESSION) {
      if (priv_obj){
         st_err_log(57, __FILE__, __LINE__); 
         return CKR_USER_NOT_LOGGED_IN;
      }
   }

   if (sess->session_info.state == CKS_RW_SO_FUNCTIONS) {
      if (priv_obj){
         st_err_log(57, __FILE__, __LINE__); 
         return CKR_USER_NOT_LOGGED_IN;
      }
   }


   rc = object_set_attribute_values( obj, pTemplate, ulCount );
   if (rc != CKR_OK){
      st_err_log(161, __FILE__, __LINE__); 
      return rc;
   }
   // okay.  the object has been updated.  if it's a session object,
   // we're finished.  if it's a token object, we need to update
   // non-volatile storage.
   //
   if (!sess_obj) {
      TOK_OBJ_ENTRY  *entry = NULL;
      CK_ULONG        index;

      // I still think there's a race condition here if two processes are
      // updating the same token object at the same time.  I don't know how
      // to solve this short of assigning each token object it's own mutex...
      //
      obj->count_lo++;
      if (obj->count_lo == 0)
         obj->count_hi++;

      save_token_object( obj );

      rc = XProcLock( xproclock );
      if (rc != CKR_OK){
         st_err_log(150, __FILE__, __LINE__); 
         return rc;
      }
      if (priv_obj) {
         rc = object_mgr_search_shm_for_obj( global_shm->priv_tok_objs,
                                             0, global_shm->num_priv_tok_obj-1,
                                             obj, &index );

         if (rc != CKR_OK) {
            st_err_log(162, __FILE__, __LINE__); 
            XProcUnLock(xproclock);
            return rc;
         }

         entry = &global_shm->priv_tok_objs[index];
      }
      else {
         rc = object_mgr_search_shm_for_obj( global_shm->publ_tok_objs,
                                             0, global_shm->num_publ_tok_obj-1,
                                             obj, &index );
         if (rc != CKR_OK) {
            st_err_log(162, __FILE__, __LINE__); 
            XProcUnLock(xproclock);
            return rc;
         }

         entry = &global_shm->publ_tok_objs[index];
      }

      entry->count_lo = obj->count_lo;
      entry->count_hi = obj->count_hi;

      XProcUnLock( xproclock );
   }

   return rc;
}


//
//
CK_RV
object_mgr_add_to_shm( OBJECT *obj )
{
   TOK_OBJ_ENTRY  * entry  = NULL;
   CK_BBOOL         priv;

   // the calling routine is responsible for locking the global_shm mutex
   //

   priv = object_is_private( obj );

   if (priv)
      entry = &global_shm->priv_tok_objs[global_shm->num_priv_tok_obj];
   else
      entry = &global_shm->publ_tok_objs[global_shm->num_publ_tok_obj];

   entry->deleted  = FALSE;
   entry->count_lo = 0;
   entry->count_hi = 0;
   memcpy( entry->name, obj->name, 8 );

   if (priv) {
      global_shm->num_priv_tok_obj++;
      object_mgr_sort_priv_shm();
   }
   else {
      global_shm->num_publ_tok_obj++;
      object_mgr_sort_publ_shm();
   }

   return CKR_OK;
}


//
//
CK_RV
object_mgr_del_from_shm( OBJECT *obj )
{
   TOK_OBJ_ENTRY   * entry = NULL;
   CK_BYTE         * ptr;
   CK_ULONG          index, count;
   CK_BBOOL          priv;
   CK_RV             rc;


   // the calling routine is responsible for locking the global_shm mutex
   //

   priv = object_is_private( obj );

   if (priv) {
      rc = object_mgr_search_shm_for_obj( global_shm->priv_tok_objs,
                                          0, global_shm->num_priv_tok_obj-1,
                                          obj, &index );
      if (rc != CKR_OK){
         st_err_log(4, __FILE__, __LINE__, __FUNCTION__); 
         return CKR_FUNCTION_FAILED;
      }
      // Since the number of objects starts at 1 and index starts at zero, we
      // decrement before we get count.  This eliminates the need to perform
      // this operation later as well as decrementing the number of objects.
      // (i.e. If we have 10 objects, num will be 10 but the last index is 9.
      // If we want to delete the last object we need to subtract 9 from 9 not
      // 10 from 9.)
      //
      global_shm->num_priv_tok_obj--;
      count = global_shm->num_priv_tok_obj - index;

      if (count > 0) {  // If we are not deleting the last element in the list
         // Move up count number of elements effectively deleting the index
         bcopy((char *)&global_shm->priv_tok_objs[index+1],
               (char *)&global_shm->priv_tok_objs[index],
               sizeof(TOK_OBJ_ENTRY) * count );
         // We need to zero out the last entry... Since the memcopy
         // does not zero it out...
         bzero((char *)&global_shm->priv_tok_objs[global_shm->num_priv_tok_obj+1],
                sizeof(TOK_OBJ_ENTRY));
      }
      else { // We are deleting the last element which is in num_priv_tok_obj
         bzero((char *)&global_shm->priv_tok_objs[global_shm->num_priv_tok_obj],
                sizeof(TOK_OBJ_ENTRY));
      }
   }
   else {
      rc = object_mgr_search_shm_for_obj( global_shm->publ_tok_objs,
                                          0, global_shm->num_publ_tok_obj-1,
                                          obj, &index );
      if (rc != CKR_OK){
         st_err_log(4, __FILE__, __LINE__, __FUNCTION__); 
         return CKR_FUNCTION_FAILED;
      }
      global_shm->num_publ_tok_obj--;
      count = global_shm->num_publ_tok_obj - index;

      if (count > 0) {
         bcopy((char *)&global_shm->publ_tok_objs[index+1],
               (char *)&global_shm->publ_tok_objs[index],
               sizeof(TOK_OBJ_ENTRY) * count);
         // We need to zero out the last entry... Since the memcopy
         // does not zero it out...
         bzero((char *)&global_shm->publ_tok_objs[global_shm->num_publ_tok_obj+1],
                sizeof(TOK_OBJ_ENTRY));
      }
      else {
         bzero((char *)&global_shm->publ_tok_objs[global_shm->num_publ_tok_obj],
                sizeof(TOK_OBJ_ENTRY));
      }
   }

   //
   // object list is still sorted...so no need to re-sort
   //

   return CKR_OK;
}


//
//
CK_RV
object_mgr_check_shm( OBJECT *obj )
{
   TOK_OBJ_ENTRY   * entry = NULL;
   CK_BBOOL          priv;
   CK_ULONG          index;
   CK_RV             rc;


   // the calling routine is responsible for locking the global_shm mutex
   //

   priv = object_is_private( obj );

   if (priv) {
      rc = object_mgr_search_shm_for_obj( global_shm->priv_tok_objs,
                                          0, global_shm->num_priv_tok_obj-1,
                                          obj, &index );
      if (rc != CKR_OK){
         st_err_log(4, __FILE__, __LINE__, __FUNCTION__); 
         return CKR_FUNCTION_FAILED;
      }
      entry = &global_shm->priv_tok_objs[index];
   }
   else {
      rc = object_mgr_search_shm_for_obj( global_shm->publ_tok_objs,
                                          0, global_shm->num_publ_tok_obj-1,
                                          obj, &index );
      if (rc != CKR_OK){
         st_err_log(4, __FILE__, __LINE__, __FUNCTION__); 
         return CKR_FUNCTION_FAILED;
      }
      entry = &global_shm->publ_tok_objs[index];
   }

   if ((obj->count_hi == entry->count_hi) && (obj->count_lo == entry->count_lo))
      return CKR_OK;

   rc = reload_token_object( obj );
   return rc;
}


// I'd use the standard bsearc