pkcs11_protect_server 0.2.3 → 0.3.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6fd43fb449a5dea77402583aac55585c11918fff2b61c05a836396c0c57349d1
+  data.tar.gz: 02c39243000b40517d52e9ed0440dcdeaddd7e1d61b755d0aec7f5a2fa31243e
+SHA512:
+  metadata.gz: 22662ee801a1b4eb0f6f6a1a21cda143d53b0cd1b63c68ff5f8d81275a96d2dbe380fae8e1e5911220928032f320a6b6b2fa163be544a36d317a47095770a68a
+  data.tar.gz: bd545b633cba8caf2318eb3145758eef9bbbb59ebff0ab1452dbd833e98b369c0b0750e05b097082e575bdd76a782112082c7137526cbf1ec78632048389bc44

checksums.yaml.gz.sig

@@ -0,0 +1,2 @@
+��.=	=f�JX�c�#P=�+7��7����;���릴�?fd1����A.@�"a���0����a�kySy�lɴz�=41]�$����cz�wG� 
+��a+��np+@�"�]m��V�SU��.c)F�ї�~���Vuie��a�.�������i�O�XÃ�D�h����

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/README_PROTECT_SERVER.rdoc

@@ -1,8 +1,8 @@
 = PKCS #11/Ruby Interface for Safenet Protect Server HSM
 
-* Homepage: http://github.com/larskanis/pkcs11
-* API documentation: http://pkcs11.rubyforge.org/pkcs11/
-* Safenet[http://www.safenet-inc.com] - Protect Server HSM
+home :: http://github.com/larskanis/pkcs11
+API documentation: http://pkcs11.rubyforge.org/pkcs11/
+Safenet Protect Server HSM : http://www.safenet-inc.com
 
 This ruby gem is an add-on to ruby-pkcs11[http://github.com/larskanis/pkcs11] .
 It allowes to use Protect Server specific extensions, which are beyond the PKCS#11 standard.

data/Rakefile

@@ -7,35 +7,43 @@ 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 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]
+
 hoe = Hoe.spec 'pkcs11_protect_server' do
   developer('Lars Kanis', 'kanis@comcard.de')
   extra_deps << ['pkcs11', "= #{pkcs11_version}"]
-  extra_dev_deps << ['yard', '>= 0.6']
-  extra_dev_deps << ['rake-compiler', '>= 0.7']
+  extra_dev_deps << ['yard', '~> 0.6']
+  extra_dev_deps << ['rake-compiler', '~> 0.7']
 
-  self.url = 'http://github.com/larskanis/pkcs11'
   self.summary = 'Safenet-ProtectServer extensions for PKCS#11-Ruby'
   self.description = 'This module allows Ruby programs to use vendor extensions for Safenet Protect Server.'
   self.version = pkcs11_version
@@ -45,12 +53,10 @@ 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[:has_rdoc] = 'yard'
+  spec_extras[:files] += SHARED_FILES + GENERATED_FILES
+  spec_extras[:required_ruby_version] = '>= 2.2.0'
 end
 
-ENV['RUBY_CC_VERSION'] ||= '1.8.7:1.9.2'
-
 Rake::ExtensionTask.new('pkcs11_protect_server_ext', hoe.spec) do |ext|
   ext.ext_dir = 'ext'
   ext.cross_compile = true                # enable cross compilation (requires cross compile toolchain)
@@ -59,28 +65,21 @@ 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|
-    cp t.prerequisites.first, t.name, :verbose=>true
+# 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']} 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']} 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'
+task doc_files:  'ext/pk11s_struct.doc'
 
 # vim: syntax=ruby

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