pkcs11_protect_server 0.3.0 → 0.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a5fe3b3e7e2b4371955d63d571b32a889cb5cc4ded9c5f4407c7e248a77e373
-  data.tar.gz: 152bcff476fe55a9a288eff56341d1013492d2aad40b48283d6629ca06bb2bb2
+  metadata.gz: a32c10aee9fff33158a9b116e5f0ff38ea63fcc35fd2cacfb101a7590c559d3d
+  data.tar.gz: 9b79ec015cd975b50b228dcc2a22bbd2f205efd627ee0046cfbb97ebd970a761
 SHA512:
-  metadata.gz: 260fdae7245c78b951906b3e586e64cbf038540f15833c376c49f1fa3f895fa51169aa30b63c1e7e2fafa8feb5701a68056362553cb0cec1ddddbf791130b168
-  data.tar.gz: da7604086b3b6145add4f76290c016bc959a8a18ed4f9dbdbbd82a60d589998271f1654d68f5fba780b3958a4d05cfa5fc37c912f6b4adba19ddae4f2aecb887
+  metadata.gz: 59b8a225918d25bf1850e3980ab732536b146635af84dd9dd02bdf53a7c7d431f4bd31aa00b189d873c446fb7da485e0823128971a44b64be6727fd3e9def8a1
+  data.tar.gz: 977af0e528e329cd483561230f1b2770b1c2b7987720d71c7606ef490480f4a77ff0b30dae829ad65147460fad2a5798f6a28dda44efba2b7c0eeed9a8df94d4

checksums.yaml.gz.sig

@@ -1 +1,2 @@
-�����5���"����(V}2T�j��%�5�^W���|ַ=�z�p�if@Dk#7�.��;�*��n�����~��?5o�5Ǹ�vB:��F3�i��X�(Zn��m�&J5V�b�/u�6v�S
+F�?5<�a���#sÉ��?��{��#�f��SkϘ���
+tխ�R�x���)�1aO�;����Շ=<�).L��Z�

data/Manifest.txt

@@ -4,8 +4,8 @@ Manifest.txt
 README_PROTECT_SERVER.rdoc
 Rakefile
 ext/extconf.rb
-ext/generate_constants.rb
-ext/generate_structs.rb
+ext/generate_protect_server_constants.rb
+ext/generate_protect_server_structs.rb
 ext/pk11s.c
 lib/pkcs11_protect_server.rb
 lib/pkcs11_protect_server/extensions.rb

data/Rakefile

@@ -7,28 +7,44 @@ require 'rake/extensiontask'
 require 'rbconfig'
 
 PROTECT_SERVER_SDK_DIR = ENV['PROTECT_SERVER_SDK_DIR'] || '/opt/ETcpsdk'
-RUBY_PKCS11_EXT_DIR = File.expand_path('../ext')
+RUBY_PKCS11_DIR = File.expand_path('..')
+$: << File.join(RUBY_PKCS11_DIR, "lib")
 
-GENERATED_FILES = [
-  'ext/pk11s_struct_impl.inc',
-  'ext/pk11s_struct_def.inc',
-  'ext/pk11s_const_def.inc',
-  'ext/pk11s_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 [
+    'ext/pk11s_struct_impl.inc',
+    'ext/pk11s_struct_def.inc',
+    'ext/pk11s_const_def.inc',
+    'ext/pk11s_struct.doc',
+  ]
+CLEAN.include SHARED_FILES
 CLEAN.include GENERATED_FILES
 CLEAN.include 'lib/pkcs11_protect_server_ext.so'
 CLEAN.include 'tmp'
 
 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]
+task :compile => GENERATED_FILES
+
 hoe = Hoe.spec 'pkcs11_protect_server' do
   developer('Lars Kanis', 'kanis@comcard.de')
   extra_deps << ['pkcs11', "= #{pkcs11_version}"]
@@ -44,7 +60,7 @@ hoe = Hoe.spec 'pkcs11_protect_server' do
   self.extra_rdoc_files << self.readme_file << 'ext/pk11s.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
 
@@ -56,27 +72,20 @@ Rake::ExtensionTask.new('pkcs11_protect_server_ext', hoe.spec) do |ext|
   ext.config_options << "--with-protect-server-sdk-dir=#{PROTECT_SERVER_SDK_DIR.inspect}"
 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'
-
-file 'ext/extconf.rb' => ['ext/pk11s_struct_def.inc', 'ext/pk11s_const_def.inc', 'ext/pk11_struct_macros.h', 'ext/pk11_const_macros.h', 'ext/pk11_version.h']
-file 'ext/pk11s_struct_def.inc' => 'ext/generate_structs.rb' do
-  sh "#{RbConfig::CONFIG['ruby_install_name']} -I../lib ext/generate_structs.rb --def ext/pk11s_struct_def.inc --impl ext/pk11s_struct_impl.inc --doc ext/pk11s_struct.doc #{File.join(PROTECT_SERVER_SDK_DIR, 'include/ctvdef.h').inspect}"
-end
-file 'ext/pk11s_struct_impl.inc' => 'ext/pk11s_struct_def.inc'
-file 'ext/pk11s_struct.doc' => 'ext/pk11s_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/pk11s_const_def.inc' => 'ext/generate_constants.rb' do
-  sh "#{RbConfig::CONFIG['ruby_install_name']} -I../lib ext/generate_constants.rb --const ext/pk11s_const_def.inc #{File.join(PROTECT_SERVER_SDK_DIR, 'include/ctvdef.h').inspect}"
+  File.write t.name, "PKCS11_STD_STRUCTS = #{std_structs.inspect}"
 end
-file 'ext/pk11s.c' => ['ext/pk11s_struct_def.inc', 'ext/pk11s_struct_impl.inc', 'ext/pk11s_const_def.inc']
 
 task doc_files:  'ext/pk11s_struct.doc'
 

data/ext/extconf.rb

@@ -4,11 +4,16 @@ require "rubygems"
 inc, lib = dir_config('protect-server-sdk', '/opt/ETcpsdk/include', '/opt/ETcpsdk/lib')
 puts "using ProtectServer-SDK include:#{inc} lib:#{lib}"
 
-# inc, lib = dir_config('ruby-pkcs11')
-# inc ||= Gem.required_location('pkcs11', '../ext')
-# puts "using ruby-pkcs11 include:#{inc} lib:#{lib}"
-# raise "path to ruby-pkcs11/ext could not be found (use --with-ruby-pkcs11-include=my_path)" unless inc
-# $INCFLAGS << " -I"+inc
+require_relative "generate_protect_server_constants"
+require_relative "generate_protect_server_structs"
+
+args = ["--const", "pk11s_const_def.inc", File.join(inc, 'ctvdef.h')]
+puts "running const parser with: #{args.join(" ")}"
+PKCS11::ProtectServer::ConstantParser.run(args)
+
+args = ["--def", "pk11s_struct_def.inc", "--impl", "pk11s_struct_impl.inc", "--doc", "pk11s_struct.doc", File.join(inc, 'ctvdef.h')]
+puts "running struct parser with: #{args.join(" ")}"
+PKCS11::ProtectServer::StructParser.run(args)
 
 find_header('pk11_struct_macros.h')
 find_header('pk11_const_macros.h')

data/ext/generate_constants.rb

@@ -2,20 +2,39 @@
 # 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 ProtectServer
-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+(.+)/, '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'),
   ]
 
-  IgnoreConstants = %w[CKR_CERTIFICATE_NOT_YET_ACTIVE CKR_CERTIFICATE_EXPIRED]
-
   def start!
     File.open(options.const, "w") do |fd_const|
       options.files.each do |file_h|
@@ -23,8 +42,7 @@ class ConstantParser < PKCS11::ConstantParser
         ConstGroups.each do |const_group|
           c_src.scan(const_group.regexp) do
             const_name, const_value = $1, $2
-            next if IgnoreConstants.include?(const_name)
-
+            
             fd_const.puts "#{const_group.def}(#{const_name}); /* #{const_value} */"
           end
         end
@@ -33,9 +51,7 @@ class ConstantParser < PKCS11::ConstantParser
   end
 end
 end
-end
-
 
 if $0==__FILE__
-  PKCS11::ProtectServer::ConstantParser.run(ARGV)
+  PKCS11::ConstantParser.run(ARGV)
 end

data/ext/generate_protect_server_constants.rb

@@ -0,0 +1,41 @@
+#!/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 ProtectServer
+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+(.+)/, 'PKCS11_DEFINE_RETURN_VALUE'),
+  ]
+
+  IgnoreConstants = %w[CKR_CERTIFICATE_NOT_YET_ACTIVE CKR_CERTIFICATE_EXPIRED]
+
+  def start!
+    File.open(options.const, "w") do |fd_const|
+      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)
+
+            fd_const.puts "#{const_group.def}(#{const_name}); /* #{const_value} */"
+          end
+        end
+      end
+    end
+  end
+end
+end
+end
+
+
+if $0==__FILE__
+  PKCS11::ProtectServer::ConstantParser.run(ARGV)
+end

data/ext/generate_protect_server_structs.rb

@@ -0,0 +1,74 @@
+#!/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 ProtectServer
+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,
+  }
+
+  ULONG_TYPES = %w[CK_COUNT CK_SIZE CK_TIMESTAMP_FORMAT]
+  ULONG_PTR_TYPES = %w[CK_COUNT_PTR]
+
+  def struct_module
+    'PKCS11::ProtectServer'
+  end
+
+  def array_attribute_names; %w[attributes mechanism certAttr hCert]; 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*\{(.*?)\}/m) do |struct|
+        struct_text = $2
+        struct = PKCS11::StructParser::CStruct.new( $1, [] )
+
+        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::ProtectServer::StructParser.run(ARGV)
+end

data/ext/generate_structs.rb

@@ -2,39 +2,56 @@
 # 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 ProtectServer
-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,
-  }
-
-  ULONG_TYPES = %w[CK_COUNT CK_SIZE CK_TIMESTAMP_FORMAT]
-  ULONG_PTR_TYPES = %w[CK_COUNT_PTR]
+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::ProtectServer'
+    '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 = []
@@ -42,15 +59,10 @@ class StructParser < PKCS11::StructParser
       c_src = IO.read(file_h)
       c_src.scan(/struct\s+([A-Z_0-9]+)\s*\{(.*?)\}/m) do |struct|
         struct_text = $2
-        struct = PKCS11::StructParser::CStruct.new( $1, [] )
-
-        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
@@ -61,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::ProtectServer::StructParser.run(ARGV)
+  PKCS11::StructParser.run(ARGV)
 end

data/ext/pk11_const_macros.h

@@ -6,7 +6,7 @@
 /**************************************************/
 
 #define PKCS11_DEFINE_CONST(constant) \
-  rb_define_const(MODULE_FOR_CONSTS, #constant, INT2NUM(constant))
+  rb_define_const(MODULE_FOR_CONSTS, #constant, LONG2NUM(constant))
 
 #define PKCS11_DEFINE_CONST_GROUP(group, name, value) \
   do { \
@@ -17,6 +17,7 @@
     old = rb_hash_aref(group, rvalue); \
     if (!NIL_P(old)) rb_warning("%s is equal to %s", RSTRING_PTR(old), name); \
     rb_hash_aset(group, rvalue, str); \
+    RB_GC_GUARD(str); \
   } while(0)
 
 #define PKCS11_DEFINE_OBJECT_CLASS(constant) \

data/ext/pk11_struct_macros.h

@@ -86,7 +86,7 @@ set_ulong_ptr(VALUE obj, VALUE value, const char *name, off_t offset)
     *ptr = NULL_PTR;
     return value;
   }
-  new_obj = Data_Make_Struct(rb_cData, CK_ULONG, 0, -1, *ptr);
+  new_obj = Data_Make_Struct(rb_cObject, CK_ULONG, 0, -1, *ptr);
   rb_iv_set(obj, name, new_obj);
   **ptr = NUM2ULONG(value);
   return value;
@@ -416,6 +416,7 @@ static VALUE c##s##_set_##f(VALUE o, VALUE v){ \
 #define PKCS11_DEFINE_STRUCT(s) \
   do { \
     c##s = rb_define_class_under(MODULE_FOR_STRUCTS, #s, BASECLASS_FOR_STRUCTS); \
+    rb_global_variable(&a##s##_members); \
     a##s##_members = rb_ary_new(); \
     rb_define_alloc_func(c##s, s##_s_alloc); \
     rb_define_const(c##s, "SIZEOF_STRUCT", ULONG2NUM(sizeof(s))); \

data/ext/pk11_version.h

@@ -1,6 +1,6 @@
 #ifndef RUBY_PK11_VERSION_H
 #define RUBY_PK11_VERSION_H
 
-static const char *VERSION = "0.3.0";
+static const char *VERSION = "0.3.4";
 
 #endif

data/ext/std_structs.rb

@@ -0,0 +1 @@
+PKCS11_STD_STRUCTS = [:CStruct, :CK_ATTRIBUTE, :CK_MECHANISM, :CK_VERSION, :CK_INFO, :CK_SLOT_INFO, :CK_TOKEN_INFO, :CK_SESSION_INFO, :CK_DATE, :CK_MECHANISM_INFO, :CK_C_INITIALIZE_ARGS, :CK_RSA_PKCS_OAEP_PARAMS, :CK_RSA_PKCS_PSS_PARAMS, :CK_ECDH1_DERIVE_PARAMS, :CK_ECMQV_DERIVE_PARAMS, :CK_X9_42_DH1_DERIVE_PARAMS, :CK_X9_42_DH2_DERIVE_PARAMS, :CK_X9_42_MQV_DERIVE_PARAMS, :CK_KEA_DERIVE_PARAMS, :CK_RC2_CBC_PARAMS, :CK_RC2_MAC_GENERAL_PARAMS, :CK_RC5_PARAMS, :CK_RC5_CBC_PARAMS, :CK_RC5_MAC_GENERAL_PARAMS, :CK_DES_CBC_ENCRYPT_DATA_PARAMS, :CK_AES_CBC_ENCRYPT_DATA_PARAMS, :CK_SKIPJACK_PRIVATE_WRAP_PARAMS, :CK_SKIPJACK_RELAYX_PARAMS, :CK_PBE_PARAMS, :CK_KEY_WRAP_SET_OAEP_PARAMS, :CK_SSL3_RANDOM_DATA, :CK_SSL3_MASTER_KEY_DERIVE_PARAMS, :CK_SSL3_KEY_MAT_OUT, :CK_SSL3_KEY_MAT_PARAMS, :CK_WTLS_RANDOM_DATA, :CK_WTLS_MASTER_KEY_DERIVE_PARAMS, :CK_WTLS_PRF_PARAMS, :CK_WTLS_KEY_MAT_OUT, :CK_WTLS_KEY_MAT_PARAMS, :CK_CMS_SIG_PARAMS, :CK_KEY_DERIVATION_STRING_DATA, :CK_PKCS5_PBKD2_PARAMS, :CK_OTP_PARAM, :CK_OTP_PARAMS, :CK_OTP_SIGNATURE_INFO, :CK_KIP_PARAMS, :CK_AES_CTR_PARAMS, :CK_GCM_PARAMS, :CK_CCM_PARAMS, :CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS, :CK_ARIA_CBC_ENCRYPT_DATA_PARAMS, :CK_DSA_PARAMETER_GEN_PARAM, :CK_ECDH_AES_KEY_WRAP_PARAMS, :CK_RSA_AES_KEY_WRAP_PARAMS, :CK_TLS12_MASTER_KEY_DERIVE_PARAMS, :CK_TLS12_KEY_MAT_PARAMS, :CK_TLS_KDF_PARAMS, :CK_TLS_MAC_PARAMS, :CK_GOSTR3410_DERIVE_PARAMS, :CK_GOSTR3410_KEY_WRAP_PARAMS]