host_api.c

IBM的Linux上的PKCS#11实现

   printf("\n\n");
#endif


   // send the request synchronously to the adapter
   //

   rc = sccRequest( adapter_handle[slot_id - 1], &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))
   {
#if 0
      printf(" rep from card 0 %x \n rep from card 1 %x \n repl_len %x \n in_len %x \n",
            CTOHL(recv_packet->repl_len[0]),CTOHL(recv_packet->repl_len[1]),
               *repl_len, in_len);
#endif
      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;

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;
}

#else
// Socket
CK_RV communicate( CK_ULONG    cmd_id, CK_SLOT_ID   slot_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 )
{
   proxy_req_t  * send_packet = NULL;
   proxy_resp_t    * recv_packet = NULL;
   char          *rpkt = NULL;
   CK_BYTE        * ptr         = NULL;
   CK_BYTE        * in_buf      = NULL;
   CK_BYTE        * out_buf     = NULL;
   CK_ULONG         send_len, recv_len;
   CK_ULONG         in_buf_len, out_buf_len;
   CK_BBOOL         alloc_in = FALSE, alloc_out=FALSE;
   CK_RV            rc;
   long              rv;
   long              total_read = 0;
   sccRB_t          request_block;
      struct hostent  *hs,hst;
      struct sockaddr_in   saddr;
      struct sockaddr_in   caddr;
      int   sock;




   if (!repl_len)
      return CKR_GENERAL_ERROR;

   if (slot_id > MAX_SLOT_ID)
      return CKR_FUNCTION_FAILED;

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

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

#ifdef ALLSOCK
// Create the socket here.
//
  pthread_mutex_lock(&smtx);
   {
      int j;
      int count=0;
         j = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
         if (j) {
             sock = j; 
            hs = gethostbyname(HOSTNAME);
           if (! hs ) {
              exit(2 );
           }
            hst=*hs;
            saddr.sin_family = AF_INET;
            bcopy(hs->h_addr,(char *)&saddr.sin_addr,hs->h_length);
            //saddr.sin_addr.s_addr  =  htonl(0x0933510c);
            saddr.sin_port = htons(PORT);

            if ( connect (sock,(struct sockaddr *)&saddr,sizeof(struct sockaddr_in)) < 0 ){
               // XXX FIXME   just bail for now.

#ifdef DEBUGON
   logit(LOG_DEBUG, "%-25s: socket failed to connect errno %d \n","communicate",errno);
#endif
               pthread_mutex_unlock(&smtx);
               return CKR_FUNCTION_FAILED;
            } else {
                  rc = 0;
            }

         } else {
            pthread_mutex_unlock(&smtx);
            return CKR_FUNCTION_FAILED;
         }
   }
  pthread_mutex_unlock(&smtx);
#else
  sock = adapter_handle[slot_id-1];
#endif
   // end socket creation


   // ensure the buffer lengths are multiples of 4
   //  Allocate contiguous memory for both send and receive
   send_len = sizeof(proxy_req_t) + req_len + out_len;
   recv_len = sizeof(proxy_resp_t) + *repl_len + in_len;


#ifdef DEBUGON
   logit(LOG_DEBUG, "\t\t%-25s:  slot_id %d  %d, 0x%x \n","communicate",slot_id,slot_id-1,cmd_id);
#endif

   // this probably isn't guaranteed to be longword-aligned...
   //
#if 1
   send_packet = (proxy_req_t *)malloc( send_len );
   recv_packet = (proxy_resp_t   *)malloc( recv_len );
#endif

   if (!send_packet || !recv_packet)
      return CKR_HOST_MEMORY;

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

   ptr = (CK_BYTE *)send_packet + sizeof(proxy_req_t);

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

   ptr = (CK_BYTE *)send_packet + sizeof(proxy_req_t) + req_len;
   if (pOut != NULL)
      memcpy(ptr,pOut,out_len);


   send_packet->pid     = HTOCL( pid_list[slot_id - 1] );
   send_packet->cmd_id = HTOCL(cmd_id);
   send_packet->req_len = HTOCL( req_len );
   send_packet->repl_len = HTOCL((*repl_len)); // These have to be swapped
   send_packet->in_len = HTOCL(in_len);
   send_packet->out_len = HTOCL(out_len);



   // send the request synchronously to the adapter
   //
   // This is actualy send asynchronously to the remote hoset
// SAB XXX FIXME  this needs to be done...
//

  pthread_mutex_lock(&smtx);

#ifdef DEBUGON
   logit(LOG_DEBUG, "\t\t%-25s:  writing   \n","communicate");
#endif
   //rv = write(adapter_handle[slot_id -1 ],send_packet,send_len);
   rv = write(sock,send_packet,send_len);
#ifdef DEBUGON
   logit(LOG_DEBUG, "\t\t%-25s:  wrote  %d  \n","communicate",rv);
#endif

   if (rv == -1) {
#ifdef DEBUGON
   logit(LOG_DEBUG, "\t\t%-25s: write failed  %d  errno %d \n","communicate",rv,errno);
#endif
      rc = CKR_FUNCTION_FAILED; // socket failure
      close(sock);
      pthread_mutex_unlock(&smtx);
      goto error;
   }

   total_read = 0;
   rv = 1;
   //while ( (total_read < recv_len) && ( rv != -1)){ 

   rpkt = (char *)recv_packet;

   while ( (total_read < sizeof(proxy_resp_t)) && ( rv != -1)){ 
#ifdef DEBUGON
//   logit(LOG_DEBUG, "\t\t%-25s: reading  header  %d   \n","communicate",total_read);
//   logit(LOG_DEBUG, "\t\t%-25s: reading  into %x  \n","communicate", rpkt + total_read);
#endif
      // rv = read(sock,recv_packet + total_read,recv_len-total_read);
      rv = read(sock,rpkt + total_read,sizeof(proxy_resp_t)-total_read);
#ifdef DEBUGON
//   logit(LOG_DEBUG, "\t\t%-25s: reading   %d   \n","communicate",rv);
#endif
      if (rv > 0 )
         total_read += rv;

      if (rv == 0 && total_read < recv_len) {
         rv = 1;
         continue;
      }
   };

#ifdef DEBUGON
//   logit(LOG_DEBUG, "\t\t%-25s: second phase read   %d  resp %d %d  \n","communicate",
//         total_read,(CTOHL(recv_packet->repl_len)),(CTOHL(recv_packet->in_len)));
//   logit(LOG_DEBUG, "\t\t%-25s: rpkt %x %x  \n","communicate",
//         rpkt,rpkt + total_read);
#endif


   if (total_read == sizeof(proxy_resp_t)) {// && rv != -1){
      int  local_count=0;

      rpkt += total_read;

      while (total_read < 
               (sizeof(proxy_resp_t) + 
               (CTOHL(recv_packet->repl_len)) + 
               (CTOHL(recv_packet->in_len)))) {

#ifdef DEBUGON
//         logit(LOG_DEBUG, "\t\t%-25s: reading  rest  %d   \n","communicate", total_read);
//         logit(LOG_DEBUG, "\t\t%-25s: reading  into %x  \n","communicate", rpkt);
#endif
         rv = read(sock,rpkt,
          ((CTOHL(recv_packet->repl_len)) + (CTOHL(recv_packet->in_len)))-local_count);

         if (rv > 0 ) {
            total_read += rv;
            local_count += rv;
            rpkt += rv;
         }

#ifdef DEBUGON
//         logit(LOG_DEBUG, "\t\t%-25s: read  %d   \n","communicate", rv);
//         logit(LOG_DEBUG, "\t\t%-25s: total  %d   \n","communicate", total_read);
#endif

         if (rv == 0 && total_read < 
               (sizeof(proxy_resp_t) + 
               (CTOHL(recv_packet->repl_len)) + 
               (CTOHL(recv_packet->in_len)))) {
 
            rv = 1;
            continue;
         }
      }
   } else {
#ifdef DEBUGON
   logit(LOG_DEBUG, "\t\t%-25s: we are screwed  %d   \n","communicate",total_read);
#endif
      rc = CKR_FUNCTION_FAILED;
      pthread_mutex_unlock(&smtx);
#ifdef ALLSOCK
      close(sock);
#endif
      goto error;
   }



   if (rv == -1  && total_read == 0) {
#ifdef DEBUGON
   logit(LOG_DEBUG, "\t\t%-25s: eof on socket  %d  errno %d \n","communicate",rv,errno);
#endif
      rc = CKR_FUNCTION_FAILED;
   pthread_mutex_unlock(&smtx);
#ifdef ALLSOCK
   close(sock);
#endif
      goto error;

   }
#ifdef ALLSOCK
   close(sock);
#endif
   pthread_mutex_unlock(&smtx);


   if ( total_read < sizeof(proxy_resp_t)) {
      logit(LOG_DEBUG, "\t\t%-25s: Total read not enough    %d   \n","communicate",total_read);
      rc = CKR_FUNCTION_FAILED;
      goto error;
   }


// SAB end XXX FIXME

   // handle the replies
   //

   if ((CTOHL(recv_packet->repl_len) > *repl_len) ||
       (CTOHL(recv_packet->in_len) >  in_len))
   {
#ifdef DEBUGON
   logit(LOG_DEBUG, "\t\t%-25s: rep length delta %d a %d  \n","communicate",*repl_len,CTOHL(recv_packet->repl_len));
   logit(LOG_DEBUG, "\t\t%-25s: in length delta %d  %d \n","communicate",in_len,
         CTOHL(recv_packet->in_len));
#endif
      rc = CKR_FUNCTION_FAILED;
      goto error;
   }


   if (total_read < (CTOHL(recv_packet->repl_len) + CTOHL(recv_packet->in_len))){
      logit(LOG_DEBUG, "\t\t%-25s: Total read not enough    %d  expected %d  \n","communicate",
            total_read,(CTOHL(recv_packet->repl_len) + CTOHL(recv_packet->in_len)));
      rc = CKR_FUNCTION_FAILED;
      goto error;
   }


   ptr = (CK_BYTE *)recv_packet + sizeof(proxy_resp_t);

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

   ptr = (CK_BYTE *)recv_packet + sizeof(proxy_resp_t) + CTOHL(recv_packet->repl_len);
   if (pIn != NULL)
      memcpy( pIn, ptr,CTOHL( recv_packet->in_len) );

   rc = CTOHL(recv_packet->return_code);

#ifdef DEBUGON
   logit(LOG_DEBUG, "\t\t%-25s: Card returned  %d  \n","communicate",rc);
#endif

error:
   if (send_packet)  free( send_packet );
   if (recv_packet)  free( recv_packet );
   if (alloc_in)     free( in_buf );
   if (alloc_out)    free( out_buf );

   return rc;
}

#endif



//
//
CK_RV SC_Initialize( void **FunctionList,
                      CK_SLOT_ID SlotNumber,
                     char  *Correlator)
{
   int    i, j, bad, rc;
#ifdef SOCKET
      struct hostent  *hs,hst;
      struct sockaddr_in   saddr;
      struct sockaddr_in   caddr;
#endif

#ifdef BRKPT
   break_point();