tor-browser

ckapi.perl (8797B)

---

#!perl
# 
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.

$copyright = '/* THIS IS A GENERATED FILE */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
';

$count = -1;
$i = 0;

open(INPUT, "<$ARGV[0]") || die "Can't open $ARGV[0]: $!";

while(<INPUT>) {
 s/^((?:[^"#]+|"[^"]*")*)(\s*#.*$)/$1/;
 next if (/^\s*$/);

#  print;

 /^([\S]+)\s+([^"][\S]*|"[^"]*")/;
 $name = $1;
 $value = $2;

 if( ($name =~ "FUNCTION") && !($name =~ "CK_FUNCTION") ) {
   $count++;
   $x[$count]{name} = $value;
   $i = 0;
 } else {
   if( $count < 0 ) {
     $value =~ s/"//g;
     $g{$name} = $value;
   } else {
     $x[$count]{args}[$i]{type} = $name;
     $x[$count]{args}[$i]{name} = $value;
     $i++;
     $x[$count]{nargs} = $i; # rewritten each time, oh well
   }
 }
}

close INPUT;

# dodump();
doprint();

sub dodump {
 for( $j = 0; $j <= $count; $j++ ) {
   print "CK_RV CK_ENTRY $x[$j]{name}\n";
   for( $i = 0; $i < $x[$j]{nargs}; $i++ ) {
     print "  $x[$j]{args}[$i]{type} $x[$j]{args}[$i]{name}";
     if( $i == ($x[$j]{nargs} - 1) ) {
       print "\n";
     } else {
       print ",\n";
     }
   }
 }
}

sub doprint {
open(PROTOTYPE, ">nssckg.h") || die "Can't open nssckg.h: $!";
open(TYPEDEF, ">nssckft.h") || die "Can't open nssckft.h: $!";
open(EPV, ">nssckepv.h") || die "Can't open nssckepv.h: $!";
open(API, ">nssck.api") || die "Can't open nssck.api: $!";

select PROTOTYPE;

print $copyright;
print <<EOD
#ifndef NSSCKG_H
#define NSSCKG_H

/*
* nssckg.h
*
* This automatically-generated header file prototypes the Cryptoki
* functions specified by PKCS#11.
*/

#ifndef NSSCKT_H
#include "nssckt.h"
#endif /* NSSCKT_H */

EOD
   ;

for( $j = 0; $j <= $count; $j++ ) {
 print "CK_RV CK_ENTRY $x[$j]{name}\n";
 print "(\n";
 for( $i = 0; $i < $x[$j]{nargs}; $i++ ) {
   print "  $x[$j]{args}[$i]{type} $x[$j]{args}[$i]{name}";
   if( $i == ($x[$j]{nargs} - 1) ) {
     print "\n";
   } else {
     print ",\n";
   }
 }
 print ");\n\n";
}

print <<EOD
#endif /* NSSCKG_H */
EOD
   ;

select TYPEDEF;

print $copyright;
print <<EOD
#ifndef NSSCKFT_H
#define NSSCKFT_H

/*
* nssckft.h
*
* The automatically-generated header file declares a typedef
* each of the Cryptoki functions specified by PKCS#11.
*/

#ifndef NSSCKT_H
#include "nssckt.h"
#endif /* NSSCKT_H */

EOD
   ;

for( $j = 0; $j <= $count; $j++ ) {
#  print "typedef CK_RV (CK_ENTRY *CK_$x[$j]{name})(\n";
 print "typedef CK_CALLBACK_FUNCTION(CK_RV, CK_$x[$j]{name})(\n";
 for( $i = 0; $i < $x[$j]{nargs}; $i++ ) {
   print "  $x[$j]{args}[$i]{type} $x[$j]{args}[$i]{name}";
   if( $i == ($x[$j]{nargs} - 1) ) {
     print "\n";
   } else {
     print ",\n";
   }
 }
 print ");\n\n";
}

print <<EOD
#endif /* NSSCKFT_H */
EOD
   ;

select EPV;

print $copyright;
print <<EOD
#ifndef NSSCKEPV_H
#define NSSCKEPV_H

/*
* nssckepv.h
*
* This automatically-generated header file defines the type
* CK_FUNCTION_LIST specified by PKCS#11.
*/

#ifndef NSSCKT_H
#include "nssckt.h"
#endif /* NSSCKT_H */

#ifndef NSSCKFT_H
#include "nssckft.h"
#endif /* NSSCKFT_H */

#include "nssckp.h"

struct CK_FUNCTION_LIST {
 CK_VERSION version;
EOD
   ;

for( $j = 0; $j <= $count; $j++ ) {
 print "  CK_$x[$j]{name} $x[$j]{name};\n";
}

print <<EOD
};

#include "nsscku.h"

#endif /* NSSCKEPV_H */
EOD
   ;

select API;

print $copyright;
print <<EOD

/*
* nssck.api
*
* This automatically-generated file is used to generate a set of
* Cryptoki entry points within the object space of a Module using
* the NSS Cryptoki Framework.
*
* The Module should have a .c file with the following:
*
*  #define MODULE_NAME name
*  #define INSTANCE_NAME instance
*  #include "nssck.api"
*
* where "name" is some module-specific name that can be used to
* disambiguate various modules.  This included file will then
* define the actual Cryptoki routines which pass through to the
* Framework calls.  All routines, except C_GetFunctionList, will
* be prefixed with the name; C_GetFunctionList will be generated
* to return an entry-point vector with these routines.  The
* instance specified should be the basic instance of NSSCKMDInstance.
*
* If, prior to including nssck.api, the .c file also specifies
*
*  #define DECLARE_STRICT_CRYTPOKI_NAMES
*
* Then a set of "stub" routines not prefixed with the name will
* be included.  This would allow the combined module and framework
* to be used in applications which are hard-coded to use the
* PKCS#11 names (instead of going through the EPV).  Please note
* that such applications should be careful resolving symbols when
* more than one PKCS#11 module is loaded.
*/

#ifndef MODULE_NAME
#error "Error: MODULE_NAME must be defined."
#endif /* MODULE_NAME */

#ifndef INSTANCE_NAME
#error "Error: INSTANCE_NAME must be defined."
#endif /* INSTANCE_NAME */

#ifndef NSSCKT_H
#include "nssckt.h"
#endif /* NSSCKT_H */

#ifndef NSSCKFWT_H
#include "nssckfwt.h"
#endif /* NSSCKFWT_H */

#ifndef NSSCKFWC_H
#include "nssckfwc.h"
#endif /* NSSCKFWC_H */

#ifndef NSSCKEPV_H
#include "nssckepv.h"
#endif /* NSSCKEPV_H */

#define ADJOIN(x,y) x##y

#define __ADJOIN(x,y) ADJOIN(x,y)

/*
* The anchor.  This object is used to store an "anchor" pointer in
* the Module's object space, so the wrapper functions can relate
* back to this instance.
*/

static NSSCKFWInstance *fwInstance = (NSSCKFWInstance *)0;

static CK_RV CK_ENTRY
__ADJOIN(MODULE_NAME,C_Initialize)
(
 CK_VOID_PTR pInitArgs
)
{
 return NSSCKFWC_Initialize(&fwInstance, INSTANCE_NAME, pInitArgs);
}

#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
CK_RV CK_ENTRY 
C_Initialize
(
 CK_VOID_PTR pInitArgs
)
{
 return __ADJOIN(MODULE_NAME,C_Initialize)(pInitArgs);
}
#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

static CK_RV CK_ENTRY
__ADJOIN(MODULE_NAME,C_Finalize)
(
 CK_VOID_PTR pReserved
)
{
 return NSSCKFWC_Finalize(&fwInstance);
}

#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
CK_RV CK_ENTRY
C_Finalize
(
 CK_VOID_PTR pReserved
)
{
 return __ADJOIN(MODULE_NAME,C_Finalize)(pReserved);
}
#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

static CK_RV CK_ENTRY
__ADJOIN(MODULE_NAME,C_GetInfo)
(
 CK_INFO_PTR pInfo
)
{
 return NSSCKFWC_GetInfo(fwInstance, pInfo);
}

#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
CK_RV CK_ENTRY
C_GetInfo
(
 CK_INFO_PTR pInfo
)
{
 return __ADJOIN(MODULE_NAME,C_GetInfo)(pInfo);
}
#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

/*
* C_GetFunctionList is defined at the end.
*/

EOD
   ;

for( $j = 4; $j <= $count; $j++ ) {
 print "static CK_RV CK_ENTRY\n";
 print "__ADJOIN(MODULE_NAME,$x[$j]{name})\n";
 print "(\n";
 for( $i = 0; $i < $x[$j]{nargs}; $i++ ) {
   print "  $x[$j]{args}[$i]{type} $x[$j]{args}[$i]{name}";
   if( $i == ($x[$j]{nargs} - 1) ) {
     print "\n";
   } else {
     print ",\n";
   }
 }
 print ")\n";
 print "{\n";
 print "  return NSSCKFW$x[$j]{name}(fwInstance, ";
 for( $i = 0; $i < $x[$j]{nargs}; $i++ ) {
   print "$x[$j]{args}[$i]{name}";
   if( $i == ($x[$j]{nargs} - 1) ) {
     print ");\n";
   } else {
     print ", ";
   }
 }
 print "}\n\n";

 print "#ifdef DECLARE_STRICT_CRYPTOKI_NAMES\n";
 print "CK_RV CK_ENTRY\n";
 print "$x[$j]{name}\n";
 print "(\n";
 for( $i = 0; $i < $x[$j]{nargs}; $i++ ) {
   print "  $x[$j]{args}[$i]{type} $x[$j]{args}[$i]{name}";
   if( $i == ($x[$j]{nargs} - 1) ) {
     print "\n";
   } else {
     print ",\n";
   }
 }
 print ")\n";
 print "{\n";
 print "  return __ADJOIN(MODULE_NAME,$x[$j]{name})(";
 for( $i = 0; $i < $x[$j]{nargs}; $i++ ) {
   print "$x[$j]{args}[$i]{name}";
   if( $i == ($x[$j]{nargs} - 1) ) {
     print ");\n";
   } else {
     print ", ";
   }
 }
 print "}\n";
 print "#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */\n\n";
}

print <<EOD
static CK_RV CK_ENTRY
__ADJOIN(MODULE_NAME,C_GetFunctionList)
(
 CK_FUNCTION_LIST_PTR_PTR ppFunctionList
);

static CK_FUNCTION_LIST FunctionList = {
 { 2, 1 },
EOD
   ;

for( $j = 0; $j <= $count; $j++ ) {
 print "__ADJOIN(MODULE_NAME,$x[$j]{name})";
 if( $j < $count ) {
   print ",\n";
 } else {
   print "\n};\n\n";
 }
}

print <<EOD
static CK_RV CK_ENTRY
__ADJOIN(MODULE_NAME,C_GetFunctionList)
(
 CK_FUNCTION_LIST_PTR_PTR ppFunctionList
)
{
 *ppFunctionList = &FunctionList;
 return CKR_OK;
}

/* This one is always present */
CK_RV CK_ENTRY
C_GetFunctionList
(
 CK_FUNCTION_LIST_PTR_PTR ppFunctionList
)
{
 return __ADJOIN(MODULE_NAME,C_GetFunctionList)(ppFunctionList);
}

#undef __ADJOIN

EOD
   ;

select STDOUT;

}