4758_status.c

IBM的Linux上的PKCS#11实现

*/

/* (C) COPYRIGHT International Business Machines Corp. 2001          */


#include <stdio.h>
#include <stdlib.h>

#if (LINUX)
#include "unistd.h"
#endif

#include "4758_status.h"
#include "pkcs11types.h"
#include "defs.h"

#include "scc_host.h"

CK_ULONG long_reverse( CK_ULONG x )
{
   CK_ULONG rev;
   CK_BYTE  *p1 = (CK_BYTE *)&x;
   CK_BYTE  *p2 = (CK_BYTE *)&rev;

   p2[3] = p1[0];
   p2[2] = p1[1];
   p2[1] = p1[2];
   p2[0] = p1[3];

   return rev;
}
#if (AIX)
#define HTOCL(Z) long_reverse(Z)
#define CTOHL(Z) long_reverse(Z)
#elif (LINUX)
#define HTOCL(Z) (Z)
#define CTOHL(Z) (Z)
#endif

CK_RV 
communicate( CK_ULONG    slot_id, CK_ULONG cmd_id,
             CK_VOID_PTR pReq,   CK_ULONG     req_len,
             CK_VOID_PTR pRep,   CK_ULONG_PTR repl_len,
             CK_BYTE_PTR pOut,   CK_ULONG     out_len,
             CK_BYTE_PTR pIn,    CK_ULONG     in_len )
{
   union
   {
      double  d;
      CK_BYTE b[1024];
   } alignedBuffers[2];

   LEEDS_REQUEST  * send_packet = (LEEDS_REQUEST *)&(alignedBuffers[0]);
   LEEDS_REPLY    * recv_packet = (LEEDS_REPLY   *)&(alignedBuffers[1]);
   CK_BYTE        * ptr         = NULL;
   CK_BYTE        * in_buf      = pIn;
   CK_BYTE        * out_buf     = pOut;
   CK_ULONG         send_len, recv_len = 0;
   CK_ULONG         in_buf_len = in_len, out_buf_len = out_len;
   CK_RV            rc = CKR_OK;

   sccAdapterNumber_t num_adapters;
   sccAgentID_t       leeds_id;
   sccAdapterHandle_t adapter_handle;
   sccRB_t            request_block;

   memset( &leeds_id, 0, sizeof(leeds_id) );

   leeds_id.DeveloperID[0] = PKCS_11_DEVELOPER_ID;
   leeds_id.DeveloperID[1] = 0x00;

   memcpy( leeds_id.ProgramID,
           PKCS_11_PRG_ID,
           sizeof(leeds_id.ProgramID) );

   leeds_id.Version[0]  = PKCS_11_VERSION;
   leeds_id.Instance[0] = PKCS_11_INSTANCE;
   leeds_id.Queue[0]    = PKCS_11_QUEUE;

   rc = sccOpenAdapter( slot_id, &adapter_handle );
   if (rc)
      exit (SEG2_NOT_RUNABLE);


   if (repl_len == NULL)
      return CKR_GENERAL_ERROR;

   if (pReq == NULL && req_len != 0)
      return CKR_FUNCTION_FAILED;

   if (pRep == NULL && *repl_len != 0)
      return CKR_FUNCTION_FAILED;

   if (pOut == NULL && out_len != 0)
      return CKR_FUNCTION_FAILED;

   if (pIn == NULL && in_len != 0)
      return CKR_FUNCTION_FAILED;


   // ensure the buffer lengths are multiples of 4 and that the buffers we
   // have are big enough
   //
   send_len = (sizeof(LEEDS_REQUEST) + req_len + 3) & ~3;
   recv_len = (sizeof(LEEDS_REPLY) + *repl_len + 3) & ~3;

   if (send_len > sizeof(alignedBuffers[0]))
      send_packet = (LEEDS_REQUEST *)malloc( send_len );

   if (recv_len > sizeof(alignedBuffers[1]))
      recv_packet = (LEEDS_REPLY *)malloc( recv_len );

   if ((out_len & 3) != 0)
   {
      out_buf_len = (out_len + 3) & ~3;
      out_buf = (CK_BYTE *)malloc( out_buf_len );
      memcpy( out_buf, pOut, out_len );
   }

   if ((in_len & 3) != 0)
   {
      in_buf_len = (in_len + 3) & ~3;
      in_buf = (CK_BYTE *)malloc( in_buf_len );
   }

   // If we couldn't allocate something we needed, die
   //
   if (send_packet == NULL ||
       recv_packet == NULL ||
      (out_buf     == NULL && out_buf_len != 0) ||
      (in_buf      == NULL && in_buf_len  != 0))
   {
      if (send_len > sizeof(alignedBuffers[0]) && send_packet != NULL)
         free( send_packet );

      if (recv_len > sizeof(alignedBuffers[1]) && recv_packet != NULL)
         free( recv_packet );

      if (out_buf != NULL && out_buf != pOut)
         free( out_buf );

      if (in_buf != NULL && in_buf != pIn)
         free( in_buf );

      return CKR_HOST_MEMORY;
   }

   memset( send_packet, 0x0, send_len );
   memset( recv_packet, 0x0, recv_len );

   memset( &request_block,         0x00,      sizeof(request_block) );
   memcpy( &request_block.AgentID, &leeds_id, sizeof(leeds_id) );

   send_packet->pid     = HTOCL( 0);
   send_packet->req_len = HTOCL( req_len );

   send_packet->repl_max[0] = HTOCL( *repl_len );
   send_packet->repl_max[1] = HTOCL( in_len );
   send_packet->repl_max[2] = 0;      // we don't currently use these buffers
   send_packet->repl_max[3] = 0;      // but maybe in the future...

   // Skip request header
   //
   ptr = (CK_BYTE *)send_packet + sizeof(LEEDS_REQUEST);

   if (pReq != NULL)
      memcpy( ptr, pReq, req_len );

   request_block.pOutBuffer[0] = (unsigned char *)send_packet;
   request_block.pInBuffer [0] = (unsigned char *)recv_packet;
   request_block.pOutBuffer[1] = (unsigned char *)out_buf;
   request_block.pInBuffer [1] = (unsigned char *)in_buf;

   // I don't know if the following needs to be adjusted for endianness or not
   // (the device driver could in principle take care of the swapping)
   //
   request_block.UserDefined = cmd_id;

   request_block.OutBufferLength[0] = send_len;
   request_block.InBufferLength [0] = recv_len;
   request_block.OutBufferLength[1] = out_buf_len;
   request_block.InBufferLength [1] = in_buf_len;

   // send the request synchronously to the adapter
   //

   rc = sccRequest( adapter_handle, &request_block );


   if (rc != 0)
   {
      rc = CKR_FUNCTION_FAILED;
      goto error;
   }

   // handle the replies
   //
   if ((CTOHL(recv_packet->repl_len[0]) > *repl_len) ||
       (CTOHL(recv_packet->repl_len[1]) >  in_len))
   {
      rc = CKR_FUNCTION_FAILED;
      goto error;
   }

   *repl_len = CTOHL(recv_packet->repl_len[0]);

   // Skip reply header
   //
   ptr = (CK_BYTE *)recv_packet + sizeof(LEEDS_REPLY);

   if (pRep != NULL)
      memcpy( pRep, ptr, CTOHL(recv_packet->repl_len[0]) );

   if (in_buf != pIn)
      memcpy( pIn, in_buf, CTOHL(recv_packet->repl_len[1]) );

   // This may need to be swapped...
   //
   rc = request_block.Status;
printf("communicate rc in req block %x \n",rc);

error:
   if (send_len > sizeof(alignedBuffers[0])) free( send_packet );
   if (recv_len > sizeof(alignedBuffers[1])) free( recv_packet );
   if (in_buf  != pIn)  free( in_buf );
   if (out_buf != pOut) free( out_buf );

   return rc;
}

int
main (int argc, char *argv[]){
   CK_CHAR_PTR card, tempc;
   int dev_minor = 0;

   int c, errflag = 0;

   while ((c = getopt (argc, argv, "c:")) != (-1)) {
      switch (c){
         case 'c':  /* a specific card (slot) is specified */
            card = (CK_CHAR_PTR) malloc (strlen(optarg));
            memcpy(card, optarg, strlen(optarg));
         break;
         default:
            errflag++;
         break;
      }
   }

   if (errflag != 0)
      return INVALID_PARAMS;


   if (strlen(card) < 6) 
      return INVALID_PARAMS;
   else
      tempc = (char *)malloc(strlen(card));
   
#if !LINUX
   sscanf(card, "crypt%s", tempc);
#else
   sscanf(card, "crypto%s", tempc);
#endif
   dev_minor = atoi(tempc);
   free (tempc);
   

   {
      CK_ULONG data = 0;
      CK_ULONG req_len, repl_len = 0;

      int rc;

      req_len = sizeof(data);

      if (rc = communicate(dev_minor, CHECK_DEEP, &data, req_len, NULL, 
            &repl_len, NULL, 0, NULL, 0) != CKR_OK)
         if (rc = communicate(dev_minor, CHECK_SHALLOW, &data, req_len, NULL, 
            &repl_len, NULL, 0, NULL, 0) != CKR_OK)  {
	    printf("return from communicate 2 %x \n",rc);
            return PKCS11_NOT_LOADED;
         }else
            return LEEDS2_SHALLOW;
      else
         return LEEDS2_DEEP;
   }
}