pkcs11_luna 0.3.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b9e662b38a39e154d48fb1c480cbd3f40bd25c6bb0c8838ef5596725c89e049a
-  data.tar.gz: 4d0bc411d5254b34399ffbdc4ba7456f40b8ee233208d91bfe7d9bd8799b763f
+  metadata.gz: 6ab768035f9878757fd9c12ff2a34e35796800830da20742347d22cb14bde0fb
+  data.tar.gz: 87e8780aa05abcc0a4090fc82e3d8070d041cc34cfb44a6b63988cebc07b4a22
 SHA512:
-  metadata.gz: 54e81ec6e847d7909e41749af105b7c142a4033ab07473f1d6c6cae7b2f2221293737eb24f1caa00947f006873fb6faeb52d671f1b675e4be8a64b941730596f
-  data.tar.gz: 0b7297eed1872de0e302d72e335d15e15e2c7facc844d8fdf66c12a9c4f16089223ba88b14d1a17f0e92ca53bc0fad6e099dcd7debdb7d6860eda01c9ce51858
+  metadata.gz: 7e35a4208dddfab2d701895744291dab50219956af681d283bca92d538d880a1af965dde05fd8eaf742a504c2790f1b0be15a6ab7658d1963cd273331f487dee
+  data.tar.gz: dab50ef8b7edd8d5b330057d3a8c0470c94cb8e8e45450c4a2da0e5f50f496acf556ee778c84400d7965c1964259c8bd9ae1d624b0d1f98548e7eaddd19d9fb5

data/Manifest.txt

@@ -3,22 +3,22 @@
 Manifest.txt
 README_LUNA.rdoc
 Rakefile
-ext/extconf.rb
-ext/generate_constants.rb
-ext/generate_structs.rb
-ext/pk11l.c
-lib/pkcs11_luna.rb
-lib/pkcs11_luna/extensions.rb
-test/luna_helper.rb
-test/app_id_helper.rb
-test/test_pkcs11_luna.rb
-test/test_pkcs11_luna_crypt.rb
 examples/config.rb
 examples/derive_aes_ecdh_key.rb
-examples/sign_verify.rb
 examples/encrypt_decrypt_aes.rb
 examples/encrypt_decrypt_rsa.rb
 examples/mechanism_list.rb
 examples/multithread.rb
 examples/objects_list.rb
+examples/sign_verify.rb
 examples/slot_info.rb
+ext/extconf.rb
+ext/generate_luna_constants.rb
+ext/generate_luna_structs.rb
+ext/pk11l.c
+lib/pkcs11_luna.rb
+lib/pkcs11_luna/extensions.rb
+test/app_id_helper.rb
+test/luna_helper.rb
+test/test_pkcs11_luna.rb
+test/test_pkcs11_luna_crypt.rb

data/Rakefile

@@ -7,30 +7,38 @@ require 'rake/extensiontask'
 require 'rbconfig'
 
 LUNA_INCLUDE_DIR = ENV['LUNA_INCLUDE_DIR'] || '/usr/safenet/lunaclient/samples/include'
-RUBY_PKCS11_EXT_DIR = File.expand_path('../ext')
+RUBY_PKCS11_DIR = File.expand_path('..')
+$: << File.join(RUBY_PKCS11_DIR, "lib")
 
-
-GENERATED_FILES = [
-  'ext/pk11l_struct_impl.inc',
-  'ext/pk11l_struct_def.inc',
-  'ext/pk11l_const_def.inc',
-  'ext/pk11l_struct.doc',
+SHARED_FILES = [
   'ext/pk11_struct_macros.h',
   'ext/pk11_const_macros.h',
   'ext/pk11_version.h',
+  'ext/generate_structs.rb',
+  'ext/generate_constants.rb',
+]
+GENERATED_FILES = [
+  "ext/std_structs.rb"
 ]
 
+CLEAN.include SHARED_FILES
 CLEAN.include GENERATED_FILES
 CLEAN.include 'lib/pkcs11_luna_ext.so'
 CLEAN.include 'tmp'
 CLEAN.include 'examples/output'
 
 def pkcs11_version
-  file = File.join(RUBY_PKCS11_EXT_DIR, 'pk11_version.h')
+  file = File.join(RUBY_PKCS11_DIR, 'ext/pk11_version.h')
   version_re = /VERSION += +([\"\'])([\d][\d\w\.]+)\1/
   File.read_utf(file)[version_re, 2]
 end
 
+# Ensure pkg is rebuilt
+task :remove_pkg do
+  rm_rf 'pkg'
+end
+task :gem => [:remove_pkg]
+
 hoe = Hoe.spec 'pkcs11_luna' do
   developer('SafeNet', 'support@safenet-inc.com')
   extra_deps << ['pkcs11', "= #{pkcs11_version}"]
@@ -46,7 +54,7 @@ hoe = Hoe.spec 'pkcs11_luna' do
   self.extra_rdoc_files << self.readme_file << 'ext/pk11l.c'
   spec_extras[:extensions] = 'ext/extconf.rb'
   spec_extras[:files] = File.read_utf("Manifest.txt").split(/\r?\n\r?/)
-  spec_extras[:files] += GENERATED_FILES
+  spec_extras[:files] += SHARED_FILES + GENERATED_FILES
   spec_extras[:required_ruby_version] = '>= 2.2.0'
 end
 
@@ -58,29 +66,20 @@ Rake::ExtensionTask.new('pkcs11_luna_ext', hoe.spec) do |ext|
   ext.config_options << "--with-luna-dir-include=\"#{LUNA_INCLUDE_DIR}\""
 end
 
-def copy_from_base_task(filename)
-  file File.join('ext', filename) => File.join(RUBY_PKCS11_EXT_DIR, filename) do |t|
+# Add shared file from base pkcs11 gem
+SHARED_FILES.each do |filename|
+  file filename => File.join(RUBY_PKCS11_DIR, filename) do |t|
     cp t.prerequisites.first, t.name, verbose: true
   end
+  file 'ext/extconf.rb' => filename
 end
 
-copy_from_base_task 'pk11_struct_macros.h'
-copy_from_base_task 'pk11_const_macros.h'
-copy_from_base_task 'pk11_version.h'
-
-HEADER_FILES = "#{LUNA_INCLUDE_DIR}/RSA/pkcs11t.h #{LUNA_INCLUDE_DIR}/cryptoki_v2.h"
-
-file 'ext/extconf.rb' => ['ext/pk11l_struct_def.inc', 'ext/pk11l_const_def.inc', 'ext/pk11_struct_macros.h', 'ext/pk11_const_macros.h', 'ext/pk11_version.h']
-file 'ext/pk11l_struct_def.inc' => 'ext/generate_structs.rb' do
-  sh "#{RbConfig::CONFIG['ruby_install_name']} -I../lib ext/generate_structs.rb --def ext/pk11l_struct_def.inc --impl ext/pk11l_struct_impl.inc --doc ext/pk11l_struct.doc #{HEADER_FILES}"
-end
-file 'ext/pk11l_struct_impl.inc' => 'ext/pk11l_struct_def.inc'
-file 'ext/pk11l_struct.doc' => 'ext/pk11l_struct_def.inc'
+file "ext/std_structs.rb" do |t|
+  require "pkcs11"
+  std_structs = PKCS11.constants.select{|c| PKCS11.const_get(c).respond_to?(:ancestors) && !(PKCS11.const_get(c).ancestors & [PKCS11::CStruct, PKCS11::CK_ATTRIBUTE]).empty? }
 
-file 'ext/pk11l_const_def.inc' => 'ext/generate_constants.rb' do
-  sh "#{RbConfig::CONFIG['ruby_install_name']} -I../lib ext/generate_constants.rb --const ext/pk11l_const_def.inc #{HEADER_FILES}"
+  File.write t.name, "PKCS11_STD_STRUCTS = #{std_structs.inspect}"
 end
-file 'ext/pk11l.c' => ['ext/pk11l_struct_def.inc', 'ext/pk11l_struct_impl.inc', 'ext/pk11l_const_def.inc']
 
 task doc_files:  'ext/pk11l_struct.doc'
 

data/ext/extconf.rb

@@ -4,6 +4,18 @@ require "rubygems"
 inc, lib = dir_config('luna-dir', '/usr/safenet/lunaclient/samples')
 puts "using Luna Client include:#{inc}"
 
+require_relative "generate_luna_constants"
+require_relative "generate_luna_structs"
+
+header_files = [File.join(inc, "RSA/pkcs11t.h"), File.join(inc, "cryptoki_v2.h")]
+
+args = ["--const", "pk11l_const_def.inc", *header_files]
+puts "running const parser with: #{args.join(" ")}"
+PKCS11::Luna::ConstantParser.run(args)
+
+args = ["--def", "pk11l_struct_def.inc", "--impl", "pk11l_struct_impl.inc", "--doc", "pk11l_struct.doc", *header_files]
+puts "running struct parser with: #{args.join(" ")}"
+PKCS11::Luna::StructParser.run(args)
 
 find_header('pk11_struct_macros.h')
 find_header('pk11_const_macros.h')

data/ext/generate_constants.rb

@@ -2,56 +2,56 @@
 # Quick and dirty parser for PKCS#11 constants and
 # generator for Ruby wrapper classes.
 
-require File.expand_path(File.join(File.dirname(__FILE__), '../../ext/generate_constants'))
+require 'optparse'
 
 module PKCS11
-module Luna
-class ConstantParser < PKCS11::ConstantParser
+class ConstantParser
+
+  attr_accessor :options
+
+  def self.run(argv)
+    s = self.new
+    options = Struct.new(:verbose, :const, :files).new
+    OptionParser.new do |opts|
+      opts.banner = "Usage: #{$0} [options] <header-file.h>*"
+
+      opts.on("-v", "--[no-]verbose", "Run verbosely", &options.method(:verbose=))
+      opts.on("--const FILE", "Write const implementations to this file", &options.method(:const=))
+      opts.on_tail("-h", "--help", "Show this message") do
+        puts opts
+        exit
+      end
+    end.parse!(argv)
+    options.files = argv
+    s.options = options
+    s.start!
+  end
+  
+  ConstTemplate = Struct.new :regexp, :def
   ConstGroups = [
-    ConstTemplate.new(/#define\s+(CKM_[A-Z_0-9]+)\s+(.+)/, 'PKCS11_DEFINE_MECHANISM'),
-    ConstTemplate.new(/#define\s+(CKA_[A-Z_0-9]+)\s+(.+)/, 'PKCS11_DEFINE_ATTRIBUTE'),
-    ConstTemplate.new(/#define\s+(CKO_[A-Z_0-9]+)\s+(.+)/, 'PKCS11_DEFINE_OBJECT_CLASS'),
-    ConstTemplate.new(/#define\s+(CKR_[A-Z_0-9]+)\s+([A-Za-z0-9_\(\)+ ]+)/, 'PKCS11_DEFINE_RETURN_VALUE'),
+    ConstTemplate.new(/#define\s+(CKM_[A-Z_0-9]+)\s+(\w+)/, 'PKCS11_DEFINE_MECHANISM'),
+    ConstTemplate.new(/#define\s+(CKA_[A-Z_0-9]+)\s+(\w+)/, 'PKCS11_DEFINE_ATTRIBUTE'),
+    ConstTemplate.new(/#define\s+(CKO_[A-Z_0-9]+)\s+(\w+)/, 'PKCS11_DEFINE_OBJECT_CLASS'),
+    ConstTemplate.new(/#define\s+(CKR_[A-Z_0-9]+)\s+(\w+)/, 'PKCS11_DEFINE_RETURN_VALUE'),
   ]
-  
-  ['CKD', 'CKU', 'CKF', 'CKDHP', 'CKES', 'CKMS', 'CAF', 'CKCAO', 'CKHSC'].each do |prefix|
-      ConstGroups << ConstTemplate.new(/#define\s+(#{prefix}_[A-Z_0-9]+)\s+([A-Za-z0-9_]+)/, 'PKCS11_DEFINE_CONST')
-  end
 
-  IgnoreConstants = %w[]  
-  
   def start!
-    
-    constants_hash = {}
-    constants = []
-    
-    options.files.each do |file_h|
-      c_src = IO.read(file_h)
-      ConstGroups.each do |const_group|
-        c_src.scan(const_group.regexp) do
-          const_name, const_value = $1, $2
-          next if IgnoreConstants.include?(const_name)
-          constants_hash[const_name] = [const_group.def, const_value]
-          constants.push(const_name)
-        end
-      end
-    end
-    
     File.open(options.const, "w") do |fd_const|
-      constants.each do |const_name|
-        next if constants_hash[const_name].nil?
-        const_group_def = constants_hash[const_name][0]
-        const_value = constants_hash[const_name][1]
-        fd_const.puts "#{const_group_def}(#{const_name}); // #{const_value} "
-        constants_hash[const_name] = nil
+      options.files.each do |file_h|
+        c_src = IO.read(file_h)
+        ConstGroups.each do |const_group|
+          c_src.scan(const_group.regexp) do
+            const_name, const_value = $1, $2
+            
+            fd_const.puts "#{const_group.def}(#{const_name}); /* #{const_value} */"
+          end
+        end
       end
     end
   end
 end
-
-end
 end
 
 if $0==__FILE__
-  PKCS11::Luna::ConstantParser.run(ARGV)
+  PKCS11::ConstantParser.run(ARGV)
 end

data/ext/generate_luna_constants.rb

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+# Quick and dirty parser for PKCS#11 constants and
+# generator for Ruby wrapper classes.
+
+require_relative "generate_constants"
+
+module PKCS11
+module Luna
+class ConstantParser < PKCS11::ConstantParser
+  ConstGroups = [
+    ConstTemplate.new(/#define\s+(CKM_[A-Z_0-9]+)\s+(.+)/, 'PKCS11_DEFINE_MECHANISM'),
+    ConstTemplate.new(/#define\s+(CKA_[A-Z_0-9]+)\s+(.+)/, 'PKCS11_DEFINE_ATTRIBUTE'),
+    ConstTemplate.new(/#define\s+(CKO_[A-Z_0-9]+)\s+(.+)/, 'PKCS11_DEFINE_OBJECT_CLASS'),
+    ConstTemplate.new(/#define\s+(CKR_[A-Z_0-9]+)\s+([A-Za-z0-9_\(\)+ ]+)/, 'PKCS11_DEFINE_RETURN_VALUE'),
+  ]
+
+  ['CKD', 'CKU', 'CKF', 'CKDHP', 'CKES', 'CKMS', 'CAF', 'CKCAO', 'CKHSC'].each do |prefix|
+      ConstGroups << ConstTemplate.new(/#define\s+(#{prefix}_[A-Z_0-9]+)\s+([A-Za-z0-9_]+)/, 'PKCS11_DEFINE_CONST')
+  end
+
+  IgnoreConstants = %w[]
+
+  def start!
+
+    constants_hash = {}
+    constants = []
+
+    options.files.each do |file_h|
+      c_src = File.binread(file_h)
+      ConstGroups.each do |const_group|
+        c_src.scan(const_group.regexp) do
+          const_name, const_value = $1, $2
+          next if IgnoreConstants.include?(const_name)
+          constants_hash[const_name] = [const_group.def, const_value]
+          constants.push(const_name)
+        end
+      end
+    end
+
+    File.open(options.const, "w") do |fd_const|
+      constants.each do |const_name|
+        next if constants_hash[const_name].nil?
+        const_group_def = constants_hash[const_name][0]
+        const_value = constants_hash[const_name][1]
+        fd_const.puts "#{const_group_def}(#{const_name}); // #{const_value} "
+        constants_hash[const_name] = nil
+      end
+    end
+  end
+end
+
+end
+end
+
+if $0==__FILE__
+  PKCS11::Luna::ConstantParser.run(ARGV)
+end

data/ext/generate_luna_structs.rb

@@ -0,0 +1,76 @@
+#!/usr/bin/env ruby
+# Quick and dirty parser for PKCS#11 structs and
+# generator for Ruby wrapper classes.
+
+require_relative "generate_structs"
+require_relative "std_structs"
+
+module PKCS11
+module Luna
+class StructParser < PKCS11::StructParser
+
+  SIZE_CONSTANTS = {
+    'CK_MANUFACTURER_SIZE' => 32,
+    'CK_SERIAL_NUMBER_SIZE' => 16,
+    'CK_TIME_SIZE' => 16,
+    'CK_LIB_DESC_SIZE' => 32,
+    'CK_SLOT_DESCRIPTION_SIZE' => 64,
+    'CK_SLOT_MANUFACTURER_SIZE' => 32,
+    'CK_MAX_PIN_LEN' => 32,
+    'CK_TOKEN_LABEL_SIZE' => 32,
+    'CK_TOKEN_MANUFACTURER_SIZE' => 32,
+    'CK_TOKEN_MODEL_SIZE' => 16,
+    'CK_TOKEN_SERIAL_NUMBER_SIZE' => 16,
+    'CK_TOKEN_TIME_SIZE' => 16,
+    'CK_MAX_PBE_IV_SIZE' =>	8,
+    'CK_MAX_PAD_SIZE' => 16,
+    'CK_HA_MAX_MEMBERS' => 32
+  }
+
+  ULONG_TYPES = %w[CK_EC_DH_PRIMITIVE CK_EC_ENC_SCHEME CK_EC_MAC_SCHEME CK_KDF_PRF_ENCODING_SCHEME CK_RV]
+  ULONG_PTR_TYPES = %w[]
+
+
+  def struct_module
+    'PKCS11::Luna'
+  end
+
+  def array_attribute_names; %w[attributes mechanism certAttr hCert]; end
+
+  def parse_files(files)
+    structs = []
+    files.each do |file_h|
+      c_src = File.binread(file_h)
+      c_src.scan(/struct\s+([A-Z_0-9]+)\s*\{(.*?)\}\s*([A-Z_0-9]+)\s*;/m) do |struct|
+        struct_text = $2
+        struct = PKCS11::StructParser::CStruct.new( $3, [] )
+
+        struct_text.scan(/^\s+([A-Z_0-9]+)([\*\s]+)([\w_]+)\s*(\[\s*(\w+)\s*\])?/) do |elem|
+          type, name = $1, $3
+          qual = SIZE_CONSTANTS[$5] || $5
+          ptr = $2.include?('*')
+          type = "CK_ULONG" if ULONG_TYPES.include?(type)
+          type = "CK_ULONG_PTR" if ULONG_PTR_TYPES.include?(type)
+          struct.attrs << Attribute.new(ptr ? type+"_PTR" : type, name, qual)
+        end
+        structs << struct
+      end
+    end
+    return structs
+  end
+
+  def start!
+    @structs = parse_files(options.files)
+    @structs_by_name = @structs.inject({}){|sum, v| sum[v.name]=v; sum }
+    @std_structs_by_name = PKCS11_STD_STRUCTS.inject({}){|sum, v| sum[v.to_s]=true; sum }
+
+    write_files
+  end
+end
+end
+end
+
+
+if $0==__FILE__
+  PKCS11::Luna::StructParser.run(ARGV)
+end

data/ext/generate_structs.rb

@@ -2,57 +2,67 @@
 # Quick and dirty parser for PKCS#11 structs and
 # generator for Ruby wrapper classes.
 
-require 'rubygems'
-require 'pkcs11'
-require File.expand_path(File.join(File.dirname(__FILE__), '../../ext/generate_structs'))
+require 'optparse'
 
 module PKCS11
-module Luna
-class StructParser < PKCS11::StructParser
-
-  SIZE_CONSTANTS = {
-    'CK_MANUFACTURER_SIZE' => 32,
-    'CK_SERIAL_NUMBER_SIZE' => 16,
-    'CK_TIME_SIZE' => 16,
-    'CK_LIB_DESC_SIZE' => 32,
-    'CK_SLOT_DESCRIPTION_SIZE' => 64,
-    'CK_SLOT_MANUFACTURER_SIZE' => 32,
-    'CK_MAX_PIN_LEN' => 32,
-    'CK_TOKEN_LABEL_SIZE' => 32,
-    'CK_TOKEN_MANUFACTURER_SIZE' => 32,
-    'CK_TOKEN_MODEL_SIZE' => 16,
-    'CK_TOKEN_SERIAL_NUMBER_SIZE' => 16,
-    'CK_TOKEN_TIME_SIZE' => 16,
-    'CK_MAX_PBE_IV_SIZE' =>	8,
-    'CK_MAX_PAD_SIZE' => 16,
-    'CK_HA_MAX_MEMBERS' => 32
-  }
-
-  ULONG_TYPES = %w[CK_EC_DH_PRIMITIVE CK_EC_ENC_SCHEME CK_EC_MAC_SCHEME CK_KDF_PRF_ENCODING_SCHEME CK_RV]
-  ULONG_PTR_TYPES = %w[]
-  
+class StructParser
+
+  attr_accessor :options
+  attr_accessor :structs
+  attr_accessor :structs_by_name
+  attr_accessor :std_structs_by_name
+
+  def self.run(argv)
+    s = self.new
+    options = Struct.new(:verbose, :def, :impl, :doc, :files).new
+    OptionParser.new do |opts|
+      opts.banner = "Usage: #{$0} [options] <header-file.h>*"
+
+      opts.on("-v", "--[no-]verbose", "Run verbosely", &options.method(:verbose=))
+      opts.on("--def FILE", "Write struct definitions to this file", &options.method(:def=))
+      opts.on("--impl FILE", "Write struct implementations to this file", &options.method(:impl=))
+      opts.on("--doc FILE", "Write documentation to this file", &options.method(:doc=))
+      opts.on_tail("-h", "--help", "Show this message") do
+        puts opts
+        exit
+      end
+    end.parse!(argv)
+    options.files = argv
+    s.options = options
+    s.start!
+  end
+
+  CStruct = Struct.new(:name, :attrs)
+  Attribute = Struct.new(:type, :name, :qual, :mark)
+  IgnoreStructs = %w[CK_ATTRIBUTE CK_MECHANISM]
+  OnlyAllocatorStructs = %w[CK_MECHANISM_INFO CK_C_INITIALIZE_ARGS CK_INFO CK_SLOT_INFO CK_TOKEN_INFO CK_SESSION_INFO]
 
   def struct_module
-    'PKCS11::Luna'
+    'PKCS11'
   end
 
-  def array_attribute_names; %w[attributes mechanism certAttr hCert]; end
+  class CStruct
+    def attr_by_sign(key)
+      attrs.find{|a| a.type+" "+a.name==key }
+    end
+  end
+
+  class Attribute
+    def type_noptr
+      type.gsub(/_PTR$/,'')
+    end
+  end
 
   def parse_files(files)
     structs = []
     files.each do |file_h|
       c_src = IO.read(file_h)
-      c_src.scan(/struct\s+([A-Z_0-9]+)\s*\{(.*?)\}\s*([A-Z_0-9]+)\s*;/m) do |struct|
+      c_src.scan(/struct\s+([A-Z_0-9]+)\s*\{(.*?)\}/m) do |struct|
         struct_text = $2
-        struct = PKCS11::StructParser::CStruct.new( $3, [] )
-
-        struct_text.scan(/^\s+([A-Z_0-9]+)([\*\s]+)([\w_]+)\s*(\[\s*(\w+)\s*\])?/) do |elem|
-          type, name = $1, $3
-          qual = SIZE_CONSTANTS[$5] || $5
-          ptr = $2.include?('*')
-          type = "CK_ULONG" if ULONG_TYPES.include?(type)
-          type = "CK_ULONG_PTR" if ULONG_PTR_TYPES.include?(type)
-          struct.attrs << Attribute.new(ptr ? type+"_PTR" : type, name, qual)
+        struct = CStruct.new( $1, [] )
+
+        struct_text.scan(/^\s+([A-Z_0-9]+)\s+([\w_]+)\s*(\[\s*(\d+)\s*\])?/) do |elem|
+          struct.attrs << Attribute.new($1, $2, $4)
         end
         structs << struct
       end
@@ -63,15 +73,145 @@ class StructParser < PKCS11::StructParser
   def start!
     @structs = parse_files(options.files)
     @structs_by_name = @structs.inject({}){|sum, v| sum[v.name]=v; sum }
-    @std_structs_by_name = PKCS11.constants.select{|c| PKCS11.const_get(c).respond_to?(:ancestors) && !(PKCS11.const_get(c).ancestors & [PKCS11::CStruct, PKCS11::CK_ATTRIBUTE]).empty? }.inject({}){|sum, v| sum[v.to_s]=true; sum }
+    @std_structs_by_name = @structs_by_name.dup
 
     write_files
   end
+
+  def array_attribute_names; ['pParams']; end
+
+  def write_files
+    File.open(options.def, "w") do |fd_def|
+    File.open(options.impl, "w") do |fd_impl|
+    File.open(options.doc, "w") do |fd_doc|
+    structs.each do |struct|
+      next if IgnoreStructs.include?(struct.name)
+
+      if OnlyAllocatorStructs.include?(struct.name)
+        fd_impl.puts "PKCS11_IMPLEMENT_ALLOCATOR(#{struct.name});"
+      else
+        fd_impl.puts "PKCS11_IMPLEMENT_STRUCT_WITH_ALLOCATOR(#{struct.name});"
+      end
+      fd_def.puts "PKCS11_DEFINE_STRUCT(#{struct.name});"
+      fd_doc.puts"class #{struct_module}::#{struct.name} < #{struct_module}::CStruct"
+      fd_doc.puts"# Size of corresponding C struct in bytes\nSIZEOF_STRUCT=Integer"
+      fd_doc.puts"# @return [String] Binary copy of the C struct\ndef to_s; end"
+      fd_doc.puts"# @return [Array<String>] Attributes of this struct\ndef members; end"
+
+      # find attributes belonging together for array of struct
+      struct.attrs.select{|attr| structs_by_name[attr.type_noptr] || std_structs_by_name[attr.type_noptr] }.each do |attr|
+        if array_attribute_names.include?(attr.name) && (len_attr = struct.attr_by_sign("CK_ULONG ulCount") || struct.attr_by_sign("CK_ULONG count") || struct.attr_by_sign("CK_ULONG #{attr.name}Count"))
+          std_struct = "PKCS11_" if std_structs_by_name[attr.type_noptr]
+          fd_impl.puts "PKCS11_IMPLEMENT_#{std_struct}STRUCT_PTR_ARRAY_ACCESSOR(#{struct.name}, #{attr.type_noptr}, #{attr.name}, #{len_attr.name});"
+          fd_def.puts "PKCS11_DEFINE_MEMBER(#{struct.name}, #{attr.name});"
+          fd_doc.puts"# @return [Array<PKCS11::#{attr.type_noptr}>] accessor for #{attr.name} and #{len_attr.name}\nattr_accessor :#{attr.name}"
+          len_attr.mark = true
+          attr.mark = true
+        end
+      end
+      # find string attributes belonging together
+      struct.attrs.select{|attr| ['CK_BYTE_PTR', 'CK_VOID_PTR', 'CK_UTF8CHAR_PTR', 'CK_CHAR_PTR'].include?(attr.type) }.each do |attr|
+        enco = case attr.type
+          when 'CK_UTF8CHAR_PTR' then 'utf8'
+          when 'CK_CHAR_PTR' then 'usascii'
+          when 'CK_BYTE_PTR', 'CK_VOID_PTR' then 'ascii8bit'
+          else raise "unexpected type #{attr.type.inspect}"
+        end
+        if len_attr=struct.attr_by_sign("CK_ULONG #{attr.name.gsub(/^p([A-Z])/){ "ul"+$1 }}Len")
+          fd_impl.puts "PKCS11_IMPLEMENT_STRING_PTR_LEN_ACCESSOR(#{struct.name}, #{attr.name}, #{len_attr.name}, #{enco});"
+          fd_def.puts "PKCS11_DEFINE_MEMBER(#{struct.name}, #{attr.name});"
+          fd_doc.puts"# @return [#{enco.upcase}-String, nil] accessor for #{attr.name} and #{len_attr.name}\nattr_accessor :#{attr.name}"
+          len_attr.mark = true
+        elsif attr.name=='pData' && (len_attr = struct.attr_by_sign("CK_ULONG length") || struct.attr_by_sign("CK_ULONG ulLen"))
+          fd_impl.puts "PKCS11_IMPLEMENT_STRING_PTR_LEN_ACCESSOR(#{struct.name}, #{attr.name}, #{len_attr.name}, #{enco});"
+          fd_def.puts "PKCS11_DEFINE_MEMBER(#{struct.name}, #{attr.name});"
+          fd_doc.puts"# @return [#{enco.upcase}-String, nil] accessor for #{attr.name} and #{len_attr.name}\nattr_accessor :#{attr.name}"
+          len_attr.mark = true
+        else
+          fd_impl.puts "PKCS11_IMPLEMENT_STRING_PTR_ACCESSOR(#{struct.name}, #{attr.name}, #{enco});"
+          fd_def.puts "PKCS11_DEFINE_MEMBER(#{struct.name}, #{attr.name});"
+          fd_doc.puts"# @return [#{enco.upcase}-String, nil] accessor for #{attr.name}\nattr_accessor :#{attr.name}"
+        end
+        attr.mark = true
+      end
+
+      # standalone attributes
+      struct.attrs.reject{|a| a.mark }.each do |attr|
+        if attr.qual
+          # Attributes with qualifier
+          enco = case attr.type
+            when 'CK_BYTE' then 'ascii8bit'
+            when 'CK_UTF8CHAR' then 'utf8'
+            when 'CK_CHAR' then 'usascii'
+          end
+          case attr.type
+          when 'CK_BYTE', 'CK_UTF8CHAR', 'CK_CHAR'
+            fd_impl.puts "PKCS11_IMPLEMENT_STRING_ACCESSOR(#{struct.name}, #{attr.name}, #{enco});"
+            fd_def.puts "PKCS11_DEFINE_MEMBER(#{struct.name}, #{attr.name});"
+            fd_doc.puts"# @return [#{enco.upcase}-String] accessor for #{attr.name} (max #{attr.qual} bytes)\nattr_accessor :#{attr.name}"
+          else
+            fd_impl.puts "/* unimplemented attr #{attr.type} #{attr.name} #{attr.qual} */"
+            fd_def.puts "/* unimplemented attr #{attr.type} #{attr.name} #{attr.qual} */"
+          end
+        else
+          case attr.type
+          when 'CK_BYTE'
+            fd_impl.puts "PKCS11_IMPLEMENT_BYTE_ACCESSOR(#{struct.name}, #{attr.name});"
+            fd_def.puts "PKCS11_DEFINE_MEMBER(#{struct.name}, #{attr.name});"
+            fd_doc.puts"# @return [Integer] accessor for #{attr.name} (CK_BYTE)\nattr_accessor :#{attr.name}"
+          when 'CK_ULONG', 'CK_FLAGS', 'CK_SLOT_ID', 'CK_STATE', /CK_[A-Z_0-9]+_TYPE/
+            fd_impl.puts "PKCS11_IMPLEMENT_ULONG_ACCESSOR(#{struct.name}, #{attr.name});"
+            fd_def.puts "PKCS11_DEFINE_MEMBER(#{struct.name}, #{attr.name});"
+            fd_doc.puts"# @return [Integer] accessor for #{attr.name} (CK_ULONG)\nattr_accessor :#{attr.name}"
+          when 'CK_OBJECT_HANDLE'
+            fd_impl.puts "PKCS11_IMPLEMENT_HANDLE_ACCESSOR(#{struct.name}, #{attr.name});"
+            fd_def.puts "PKCS11_DEFINE_MEMBER(#{struct.name}, #{attr.name});"
+            fd_doc.puts"# @return [Integer, PKCS11::Object] Object handle (CK_ULONG)\nattr_accessor :#{attr.name}"
+          when 'CK_BBOOL'
+            fd_impl.puts "PKCS11_IMPLEMENT_BOOL_ACCESSOR(#{struct.name}, #{attr.name});"
+            fd_def.puts "PKCS11_DEFINE_MEMBER(#{struct.name}, #{attr.name});"
+            fd_doc.puts"# @return [Boolean]  Bool value\nattr_accessor :#{attr.name}"
+          when 'CK_ULONG_PTR'
+            fd_impl.puts "PKCS11_IMPLEMENT_ULONG_PTR_ACCESSOR(#{struct.name}, #{attr.name});"
+            fd_def.puts "PKCS11_DEFINE_MEMBER(#{struct.name}, #{attr.name});"
+            fd_doc.puts"# @return [Integer, nil] accessor for #{attr.name} (CK_ULONG_PTR)\nattr_accessor :#{attr.name}"
+          else
+            # Struct attributes
+            if structs_by_name[attr.type]
+              fd_impl.puts "PKCS11_IMPLEMENT_STRUCT_ACCESSOR(#{struct.name}, #{attr.type}, #{attr.name});"
+              fd_def.puts "PKCS11_DEFINE_MEMBER(#{struct.name}, #{attr.name});"
+              fd_doc.puts"# @return [#{struct_module}::#{attr.type}] inline struct\nattr_accessor :#{attr.name}"
+            elsif structs_by_name[attr.type_noptr]
+              fd_impl.puts "PKCS11_IMPLEMENT_STRUCT_PTR_ACCESSOR(#{struct.name}, #{attr.type_noptr}, #{attr.name});"
+              fd_def.puts "PKCS11_DEFINE_MEMBER(#{struct.name}, #{attr.name});"
+              fd_doc.puts"# @return [#{struct_module}::#{attr.type_noptr}, nil] pointer to struct\nattr_accessor :#{attr.name}"
+            elsif std_structs_by_name[attr.type]
+              fd_impl.puts "PKCS11_IMPLEMENT_PKCS11_STRUCT_ACCESSOR(#{struct.name}, #{attr.type}, #{attr.name});"
+              fd_def.puts "PKCS11_DEFINE_MEMBER(#{struct.name}, #{attr.name});"
+              fd_doc.puts"# @return [PKCS11::#{attr.type}] inline struct (see pkcs11.gem)\nattr_accessor :#{attr.name}"
+            elsif std_structs_by_name[attr.type_noptr]
+              fd_impl.puts "PKCS11_IMPLEMENT_PKCS11_STRUCT_PTR_ACCESSOR(#{struct.name}, #{attr.type_noptr}, #{attr.name});"
+              fd_def.puts "PKCS11_DEFINE_MEMBER(#{struct.name}, #{attr.name});"
+              fd_doc.puts"# @return [PKCS11::#{attr.type_noptr}, nil] pointer to struct (see pkcs11.gem)\nattr_accessor :#{attr.name}"
+            else
+              fd_impl.puts "/* unimplemented attr #{attr.type} #{attr.name} #{attr.qual} */"
+              fd_def.puts "/* unimplemented attr #{attr.type} #{attr.name} #{attr.qual} */"
+            end
+          end
+        end
+      end
+
+      fd_impl.puts
+      fd_def.puts
+      fd_doc.puts "end"
+    end
+    end
+    end
+    end
+  end
 end
 end
-end
-
 
 if $0==__FILE__
-  PKCS11::Luna::StructParser.run(ARGV)
+  PKCS11::StructParser.run(ARGV)
 end