libpcscxx/doc/examples/suisse-id-demo.cxx

/*! @file

    @id $Id$
*/
//       1         2         3         4         5         6         7         8
// 45678901234567890123456789012345678901234567890123456789012345678901234567890

#include <cryptoki.hxx>
#include <pcsc.hxx>
#include <mrw/args.hxx>
#include <mrw/vector.hxx>
#include <mrw/shared.hxx>

#include <stdexcept>
#include <iostream>

namespace suisseid {

  class Card {
    public:
      Card(mrw::Shared<pcsc::Connection::Reader> reader,
           mrw::Shared<cryptoki::Slot> slot):
          _reader(reader),
          _slot(slot) {
      }
      virtual ~Card() {}
      const std::string& name() {
        return _reader->name;
      }
    private:
      mrw::Shared<pcsc::Connection::Reader> _reader;
      mrw::Shared<cryptoki::Slot> _slot;
  };
  
  class PostSuisseID: public Card {
    public:
      PostSuisseID(mrw::Shared<pcsc::Connection::Reader> reader,
                   mrw::Shared<cryptoki::Slot> slot):
          Card(reader, slot) {
      }
  };
  
  class Manager {
      
    public:
      
      Manager(const std::string& lib="libcvP11.so"):
          _cryptoki(lib) {
      }
      
      Manager(const pcsc::Connection& pcsc,
              const std::string& lib="libcvP11.so"):
          _pcsc(pcsc),
          _cryptoki(lib) {
      }
      
      Manager(const cryptoki::Library& cryptoki):
          _cryptoki(cryptoki) {
      }

      Manager(const pcsc::Connection& pcsc,
              const cryptoki::Library& cryptoki):
          _pcsc(pcsc),
          _cryptoki(cryptoki) {
      }
      
      typedef std::vector<mrw::Shared<Card> > Cards;
      
      Cards scan() {
        Cards res;
        // By now, scan only for PostSuisseID; in future use factory pattern
        pcsc::Connection::Strings readers
          (_pcsc.getReadersWithAtr("4b53776973735369676e"));
        for (pcsc::Connection::Strings::iterator reader(readers.begin());
             reader!=readers.end(); ++reader) {
          cryptoki::SlotList slots(_cryptoki.slotList(true, *reader));
          if (slots.size()==1)
            res.push_back(dynamic_cast<Card*>
                          (new PostSuisseID(_pcsc.reader(*reader), slots[0])));
        }
        return res;
      }
      
    private:
      
      pcsc::Connection _pcsc;
      cryptoki::Library _cryptoki;
      
  };
  
}

int main(int argc, char** argv) try {
  
  std::string lib("libcvP11.so");
  mrw::args::parse(argc, argv,
                   "Sign a text (optionally several times for performance"
                   " measurements).",
                   mrw::args::list()
                   <<mrw::args::decl("h", "help", "show help",
                                     mrw::args::decl::param_list()
                                     <<mrw::args::help()
                                     <<mrw::args::exit())
                   <<mrw::args::decl("l", "library", "cryptoki lirary to load",
                                     mrw::args::decl::param_list()
                                     <<mrw::args::param(lib, "lib")));

  suisseid::Manager suisseid;
  suisseid::Manager::Cards cards(suisseid.scan());
  for (suisseid::Manager::Cards::iterator card(cards.begin());
       card!=cards.end(); ++card)
    std::cout<<"Found SuisseID: "<<(*card)->name()<<std::endl;
  return 0;
 } catch (std::exception& x) {
  std::cerr<<"**** ERROR in "<<*argv<<": "<<x.what()<<std::endl;
 }