No OneTemporary
Actions

Size

51 KB

Subscribers

None

View Options

	diff --git a/doc/scdaemon.texi b/doc/scdaemon.texi
	index 9184ce202..200fed890 100644
	--- a/doc/scdaemon.texi
	+++ b/doc/scdaemon.texi
	@@ -1,720 +1,731 @@
	@c Copyright (C) 2002 Free Software Foundation, Inc.
	@c This is part of the GnuPG manual.
	@c For copying conditions, see the file gnupg.texi.

	@node Invoking SCDAEMON
	@chapter Invoking the SCDAEMON
	@cindex SCDAEMON command options
	@cindex command options
	@cindex options, SCDAEMON command

	@manpage scdaemon.1
	@ifset manverb
	.B scdaemon
	\- Smartcard daemon for the GnuPG system
	@end ifset

	@mansect synopsis
	@ifset manverb
	.B scdaemon
	.RB [ \-\-homedir
	.IR dir ]
	.RB [ \-\-options
	.IR file ]
	.RI [ options ]
	.B \-\-server
	.br
	.B scdaemon
	.RB [ \-\-homedir
	.IR dir ]
	.RB [ \-\-options
	.IR file ]
	.RI [ options ]
	.B \-\-daemon
	.RI [ command_line ]
	@end ifset


	@mansect description
	The @command{scdaemon} is a daemon to manage smartcards. It is usually
	invoked by @command{gpg-agent} and in general not used directly.

	@manpause
	@xref{Option Index}, for an index to @command{scdaemon}'s commands and
	options.
	@mancont

	@menu
	* Scdaemon Commands:: List of all commands.
	* Scdaemon Options:: List of all options.
	* Card applications:: Description of card applications.
	* Scdaemon Configuration:: Configuration files.
	* Scdaemon Examples:: Some usage examples.
	* Scdaemon Protocol:: The protocol the daemon uses.
	@end menu

	@mansect commands

	@node Scdaemon Commands
	@section Commands

	Commands are not distinguished from options except for the fact that
	only one command is allowed.

	@table @gnupgtabopt
	@item --version
	@opindex version
	Print the program version and licensing information. Not that you can
	abbreviate this command.

	@item --help, -h
	@opindex help
	Print a usage message summarizing the most useful command-line options.
	Not that you can abbreviate this command.

	@item --dump-options
	@opindex dump-options
	Print a list of all available options and commands. Not that you can
	abbreviate this command.

	@item --server
	@opindex server
	Run in server mode and wait for commands on the @code{stdin}. This is
	default mode is to create a socket and listen for commands there.

	@item --multi-server
	@opindex multi-server
	Run in server mode and wait for commands on the @code{stdin} as well as
	on an additional Unix Domain socket. The server command @code{GETINFO}
	may be used to get the name of that extra socket.

	@item --daemon
	@opindex daemon
	Run the program in the background. This option is required to prevent
	it from being accidentally running in the background.

	@end table


	@mansect options

	@node Scdaemon Options
	@section Option Summary

	@table @gnupgtabopt

	@item --options @var{file}
	@opindex options
	Reads configuration from @var{file} instead of from the default
	per-user configuration file. The default configuration file is named
	@file{scdaemon.conf} and expected in the @file{.gnupg} directory directly
	below the home directory of the user.

	@include opt-homedir.texi


	@item -v
	@item --verbose
	@opindex v
	@opindex verbose
	Outputs additional information while running.
	You can increase the verbosity by giving several
	verbose commands to @command{gpgsm}, such as @samp{-vv}.

	@item --debug-level @var{level}
	@opindex debug-level
	Select the debug level for investigating problems. @var{level} may be
	a numeric value or a keyword:

	@table @code
	@item none
	No debugging at all. A value of less than 1 may be used instead of
	the keyword.
	@item basic
	Some basic debug messages. A value between 1 and 2 may be used
	instead of the keyword.
	@item advanced
	More verbose debug messages. A value between 3 and 5 may be used
	instead of the keyword.
	@item expert
	Even more detailed messages. A value between 6 and 8 may be used
	instead of the keyword.
	@item guru
	All of the debug messages you can get. A value greater than 8 may be
	used instead of the keyword. The creation of hash tracing files is
	only enabled if the keyword is used.
	@end table

	How these messages are mapped to the actual debugging flags is not
	specified and may change with newer releases of this program. They are
	however carefully selected to best aid in debugging.

	@quotation Note
	All debugging options are subject to change and thus should not be used
	by any application program. As the name says, they are only used as
	helpers to debug problems.
	@end quotation


	@item --debug @var{flags}
	@opindex debug
	This option is only useful for debugging and the behaviour may change at
	any time without notice. FLAGS are bit encoded and may be given in
	usual C-Syntax. The currently defined bits are:

	@table @code
	@item 0 (1)
	command I/O
	@item 1 (2)
	values of big number integers
	@item 2 (4)
	low level crypto operations
	@item 5 (32)
	memory allocation
	@item 6 (64)
	caching
	@item 7 (128)
	show memory statistics.
	@item 9 (512)
	write hashed data to files named @code{dbgmd-000*}
	@item 10 (1024)
	trace Assuan protocol. See also option @option{--debug-assuan-log-cats}.
	@item 11 (2048)
	trace APDU I/O to the card. This may reveal sensitive data.
	+@item 12 (4096)
	+trace some card reader related function calls.
	@end table

	@item --debug-all
	@opindex debug-all
	Same as @code{--debug=0xffffffff}

	@item --debug-wait @var{n}
	@opindex debug-wait
	When running in server mode, wait @var{n} seconds before entering the
	actual processing loop and print the pid. This gives time to attach a
	debugger.

	@item --debug-ccid-driver
	@opindex debug-wait
	Enable debug output from the included CCID driver for smartcards.
	Using this option twice will also enable some tracing of the T=1
	protocol. Note that this option may reveal sensitive data.

	@item --debug-disable-ticker
	@opindex debug-disable-ticker
	This option disables all ticker functions like checking for card
	insertions.

	@item --debug-allow-core-dump
	@opindex debug-allow-core-dump
	For security reasons we won't create a core dump when the process
	aborts. For debugging purposes it is sometimes better to allow core
	dump. This options enables it and also changes the working directory to
	@file{/tmp} when running in @option{--server} mode.

	@item --debug-log-tid
	@opindex debug-log-tid
	This option appends a thread ID to the PID in the log output.

	@item --debug-assuan-log-cats @var{cats}
	@opindex debug-assuan-log-cats
	Changes the active Libassuan logging categories to @var{cats}. The
	value for @var{cats} is an unsigned integer given in usual C-Syntax.
	A value of of 0 switches to a default category. If this option is not
	used the categories are taken from the environment variable
	@samp{ASSUAN_DEBUG}. Note that this option has only an effect if the
	Assuan debug flag has also been with the option @option{--debug}. For
	a list of categories see the Libassuan manual.

	@item --no-detach
	@opindex no-detach
	Don't detach the process from the console. This is mainly useful for
	debugging.

	@item --log-file @var{file}
	@opindex log-file
	Append all logging output to @var{file}. This is very helpful in
	seeing what the agent actually does.


	@item --pcsc-driver @var{library}
	@opindex pcsc-driver
	Use @var{library} to access the smartcard reader. The current default
	is @file{libpcsclite.so}. Instead of using this option you might also
	want to install a symbolic link to the default file name
	(e.g. from @file{libpcsclite.so.1}).

	@item --ctapi-driver @var{library}
	@opindex ctapi-driver
	Use @var{library} to access the smartcard reader. The current default
	is @file{libtowitoko.so}. Note that the use of this interface is
	deprecated; it may be removed in future releases.

	@item --disable-ccid
	@opindex disable-ccid
	Disable the integrated support for CCID compliant readers. This
	allows to fall back to one of the other drivers even if the internal
	CCID driver can handle the reader. Note, that CCID support is only
	available if libusb was available at build time.

	@item --reader-port @var{number_or_string}
	@opindex reader-port
	This option may be used to specify the port of the card terminal. A
	value of 0 refers to the first serial device; add 32768 to access USB
	devices. The default is 32768 (first USB device). PC/SC or CCID
	readers might need a string here; run the program in verbose mode to get
	a list of available readers. The default is then the first reader
	found.

	To get a list of available CCID readers you may use this command:
	@smallexample
	echo scd getinfo reader_list \| gpg-connect-agent --decode \| awk '/^D/ @{print $2@}'
	@end smallexample


	@item --card-timeout @var{n}
	@opindex card-timeout
	If @var{n} is not 0 and no client is actively using the card, the card
	will be powered down after @var{n} seconds. Powering down the card
	avoids a potential risk of damaging a card when used with certain
	cheap readers. This also allows non Scdaemon aware applications to
	access the card. The disadvantage of using a card timeout is that
	accessing the card takes longer and that the user needs to enter the
	PIN again after the next power up.

	Note that with the current version of Scdaemon the card is powered
	down immediately at the next timer tick for any value of @var{n} other
	than 0.


	@item --disable-keypad
	@opindex disable-keypad
	Even if a card reader features a keypad, do not try to use it.


	@item --deny-admin
	@opindex deny-admin
	@opindex allow-admin
	This option disables the use of admin class commands for card
	applications where this is supported. Currently we support it for the
	OpenPGP card. This commands is useful to inhibit accidental access to
	admin class command which could ultimately lock the card through wrong
	PIN numbers. Note that GnuPG versions older than 2.0.11 featured an
	@option{--allow-admin} command which was required to use such admin
	commands. This option has no more effect today because the default is
	now to allow admin commands.

	@item --disable-application @var{name}
	@opindex disable-application
	This option disables the use of the card application named
	@var{name}. This is mainly useful for debugging or if a application
	with lower priority should be used by default.

	@end table

	All the long options may also be given in the configuration file after
	stripping off the two leading dashes.


	@mansect card applications
	@node Card applications
	@section Description of card applications

	@command{scdaemon} supports the card applications as described below.

	@menu
	* OpenPGP Card:: The OpenPGP card application
	* NKS Card:: The Telesec NetKey card application
	* DINSIG Card:: The DINSIG card application
	* PKCS#15 Card:: The PKCS#15 card application
	* Geldkarte Card:: The Geldkarte application
	+* Undefined Card:: The Undefined stub application
	@end menu

	@node OpenPGP Card
	@subsection The OpenPGP card application ``openpgp''

	This application is currently only used by @command{gpg} but may in
	future also be useful with @command{gpgsm}. Version 1 and version 2 of
	the card is supported.

	The specifications for these cards are available at
	@uref{http://g10code.com/docs/openpgp-card-1.0.pdf} and
	@uref{http://g10code.com/docs/openpgp-card-2.0.pdf}.

	@node NKS Card
	@subsection The Telesec NetKey card ``nks''

	This is the main application of the Telesec cards as available in
	Germany. It is a superset of the German DINSIG card. The card is
	used by @command{gpgsm}.

	@node DINSIG Card
	@subsection The DINSIG card application ``dinsig''

	This is an application as described in the German draft standard
	@emph{DIN V 66291-1}. It is intended to be used by cards supporting
	the German signature law and its bylaws (SigG and SigV).

	@node PKCS#15 Card
	@subsection The PKCS#15 card application ``p15''

	This is common framework for smart card applications. It is used by
	@command{gpgsm}.

	@node Geldkarte Card
	@subsection The Geldkarte card application ``geldkarte''

	This is a simple application to display information of a German
	Geldkarte. The Geldkarte is a small amount debit card application which
	comes with almost all German banking cards.

	+@node Undefined Card
	+@subsection The Undefined card application ``undefined''
	+
	+This is a stub application to allow the use of the APDU command even
	+if no supported application is found on the card. This application is
	+not used automatically but must be explicitly requested using the
	+SERIALNO command.
	+

	@c *******************************************
	@c ************* **************
	@c ************* FILES **************
	@c ************* **************
	@c *******************************************
	@mansect files
	@node Scdaemon Configuration
	@section Configuration files

	There are a few configuration files to control certain aspects of
	@command{scdaemons}'s operation. Unless noted, they are expected in the
	current home directory (@pxref{option --homedir}).

	@table @file

	@item scdaemon.conf
	@cindex scdaemon.conf
	This is the standard configuration file read by @command{scdaemon} on
	startup. It may contain any valid long option; the leading two dashes
	may not be entered and the option may not be abbreviated. This default
	name may be changed on the command line (@pxref{option --options}).

	@item scd-event
	@cindex scd-event
	If this file is present and executable, it will be called on veyer card
	reader's status changed. An example of this script is provided with the
	distribution

	@item reader_@var{n}.status
	This file is created by @command{sdaemon} to let other applications now
	about reader status changes. Its use is now deprecated in favor of
	@file{scd-event}.

	@end table


	@c
	@c Examples
	@c
	@mansect examples
	@node Scdaemon Examples
	@section Examples

	@c man begin EXAMPLES

	@example
	$ scdaemon --server -v
	@end example

	@c man end

	@c
	@c Assuan Protocol
	@c
	@manpause
	@node Scdaemon Protocol
	@section Scdaemon's Assuan Protocol

	The SC-Daemon should be started by the system to provide access to
	external tokens. Using Smartcards on a multi-user system does not
	make much sense expect for system services, but in this case no
	regular user accounts are hosted on the machine.

	A client connects to the SC-Daemon by connecting to the socket named
	@file{/var/run/scdaemon/socket}, configuration information is read from
	@var{/etc/scdaemon.conf}

	Each connection acts as one session, SC-Daemon takes care of
	synchronizing access to a token between sessions.

	@menu
	* Scdaemon SERIALNO:: Return the serial number.
	* Scdaemon LEARN:: Read all useful information from the card.
	* Scdaemon READCERT:: Return a certificate.
	* Scdaemon READKEY:: Return a public key.
	* Scdaemon PKSIGN:: Signing data with a Smartcard.
	* Scdaemon PKDECRYPT:: Decrypting data with a Smartcard.
	* Scdaemon GETATTR:: Read an attribute's value.
	* Scdaemon SETATTR:: Update an attribute's value.
	* Scdaemon WRITEKEY:: Write a key to a card.
	* Scdaemon GENKEY:: Generate a new key on-card.
	* Scdaemon RANDOM:: Return random bytes generate on-card.
	* Scdaemon PASSWD:: Change PINs.
	* Scdaemon CHECKPIN:: Perform a VERIFY operation.
	* Scdaemon RESTART:: Restart connection
	* Scdaemon APDU:: Send a verbatim APDU to the card
	@end menu

	@node Scdaemon SERIALNO
	@subsection Return the serial number

	This command should be used to check for the presence of a card. It is
	special in that it can be used to reset the card. Most other commands
	will return an error when a card change has been detected and the use of
	this function is therefore required.

	Background: We want to keep the client clear of handling card changes
	between operations; i.e. the client can assume that all operations are
	done on the same card unless he call this function.

	@example
	SERIALNO
	@end example

	Return the serial number of the card using a status response like:

	@example
	S SERIALNO D27600000000000000000000 0
	@end example

	The trailing 0 should be ignored for now, it is reserved for a future
	extension. The serial number is the hex encoded value identified by
	the @code{0x5A} tag in the GDO file (FIX=0x2F02).



	@node Scdaemon LEARN
	@subsection Read all useful information from the card

	@example
	LEARN [--force]
	@end example

	Learn all useful information of the currently inserted card. When
	used without the force options, the command might do an INQUIRE
	like this:

	@example
	INQUIRE KNOWNCARDP <hexstring_with_serialNumber> <timestamp>
	@end example

	The client should just send an @code{END} if the processing should go on
	or a @code{CANCEL} to force the function to terminate with a cancel
	error message. The response of this command is a list of status lines
	formatted as this:

	@example
	S KEYPAIRINFO @var{hexstring_with_keygrip} @var{hexstring_with_id}
	@end example

	If there is no certificate yet stored on the card a single "X" is
	returned in @var{hexstring_with_keygrip}.

	@node Scdaemon READCERT
	@subsection Return a certificate

	@example
	READCERT @var{hexified_certid}\|@var{keyid}
	@end example

	This function is used to read a certificate identified by
	@var{hexified_certid} from the card. With OpenPGP cards the keyid
	@code{OpenPGP.3} may be used to rad the certificate of version 2 cards.


	@node Scdaemon READKEY
	@subsection Return a public key

	@example
	READKEY @var{hexified_certid}
	@end example

	Return the public key for the given cert or key ID as an standard
	S-Expression.



	@node Scdaemon PKSIGN
	@subsection Signing data with a Smartcard

	To sign some data the caller should use the command

	@example
	SETDATA @var{hexstring}
	@end example

	to tell @command{scdaemon} about the data to be signed. The data must be given in
	hex notation. The actual signing is done using the command

	@example
	PKSIGN @var{keyid}
	@end example

	where @var{keyid} is the hexified ID of the key to be used. The key id
	may have been retrieved using the command @code{LEARN}. If another
	hash algorithm than SHA-1 is used, that algorithm may be given like:

	@example
	PKSIGN --hash=@var{algoname} @var{keyid}
	@end example

	With @var{algoname} are one of @code{sha1}, @code{rmd160} or @code{md5}.


	@node Scdaemon PKDECRYPT
	@subsection Decrypting data with a Smartcard

	To decrypt some data the caller should use the command

	@example
	SETDATA @var{hexstring}
	@end example

	to tell @command{scdaemon} about the data to be decrypted. The data
	must be given in hex notation. The actual decryption is then done
	using the command

	@example
	PKDECRYPT @var{keyid}
	@end example

	where @var{keyid} is the hexified ID of the key to be used.


	@node Scdaemon GETATTR
	@subsection Read an attribute's value.

	TO BE WRITTEN.

	@node Scdaemon SETATTR
	@subsection Update an attribute's value.

	TO BE WRITTEN.

	@node Scdaemon WRITEKEY
	@subsection Write a key to a card.

	@example
	WRITEKEY [--force] @var{keyid}
	@end example

	This command is used to store a secret key on a smartcard. The
	allowed keyids depend on the currently selected smartcard
	application. The actual keydata is requested using the inquiry
	@code{KEYDATA} and need to be provided without any protection. With
	@option{--force} set an existing key under this @var{keyid} will get
	overwritten. The key data is expected to be the usual canonical encoded
	S-expression.

	A PIN will be requested in most cases. This however depends on the
	actual card application.


	@node Scdaemon GENKEY
	@subsection Generate a new key on-card.

	TO BE WRITTEN.

	@node Scdaemon RANDOM
	@subsection Return random bytes generate on-card.

	TO BE WRITTEN.


	@node Scdaemon PASSWD
	@subsection Change PINs.

	@example
	PASSWD [--reset] [--nullpin] @var{chvno}
	@end example

	Change the PIN or reset the retry counter of the card holder
	verification vector number @var{chvno}. The option @option{--nullpin}
	is used to initialize the PIN of TCOS cards (6 byte NullPIN only).


	@node Scdaemon CHECKPIN
	@subsection Perform a VERIFY operation.

	@example
	CHECKPIN @var{idstr}
	@end example

	Perform a VERIFY operation without doing anything else. This may be
	used to initialize a the PIN cache earlier to long lasting
	operations. Its use is highly application dependent:

	@table @strong
	@item OpenPGP

	Perform a simple verify operation for CHV1 and CHV2, so that further
	operations won't ask for CHV2 and it is possible to do a cheap check on
	the PIN: If there is something wrong with the PIN entry system, only the
	regular CHV will get blocked and not the dangerous CHV3. @var{idstr} is
	the usual card's serial number in hex notation; an optional fingerprint
	part will get ignored.

	There is however a special mode if @var{idstr} is suffixed with the
	literal string @code{[CHV3]}: In this case the Admin PIN is checked if
	and only if the retry counter is still at 3.

	@end table



	@node Scdaemon RESTART
	@subsection Perform a RESTART operation.

	@example
	RESTART
	@end example

	Restart the current connection; this is a kind of warm reset. It
	deletes the context used by this connection but does not actually
	reset the card.

	This is used by gpg-agent to reuse a primary pipe connection and
	may be used by clients to backup from a conflict in the serial
	command; i.e. to select another application.




	@node Scdaemon APDU
	@subsection Send a verbatim APDU to the card.

	@example
	APDU [--atr] [--more] [--exlen[=@var{n}]] [@var{hexstring}]
	@end example


	Send an APDU to the current reader. This command bypasses the high
	level functions and sends the data directly to the card.
	@var{hexstring} is expected to be a proper APDU. If @var{hexstring} is
	not given no commands are send to the card; However the command will
	implicitly check whether the card is ready for use.

	Using the option @code{--atr} returns the ATR of the card as a status
	message before any data like this:
	@example
	S CARD-ATR 3BFA1300FF813180450031C173C00100009000B1
	@end example

	Using the option @code{--more} handles the card status word MORE_DATA
	(61xx) and concatenate all responses to one block.

	Using the option @code{--exlen} the returned APDU may use extended
	length up to N bytes. If N is not given a default value is used
	(currently 4096).



	@mansect see also
	@ifset isman
	@command{gpg-agent}(1),
	@command{gpgsm}(1),
	@command{gpg2}(1)
	@end ifset
	@include see-also-note.texi

	diff --git a/scd/app.c b/scd/app.c
	index 6f0d7560b..63ef4fa65 100644
	--- a/scd/app.c
	+++ b/scd/app.c
	@@ -1,981 +1,991 @@
	/* app.c - Application selection.
	* Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
	*
	* This file is part of GnuPG.
	*
	* GnuPG is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation; either version 3 of the License, or
	* (at your option) any later version.
	*
	* GnuPG is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, see <http://www.gnu.org/licenses/>.
	*/

	#include <config.h>
	#include <errno.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <pth.h>

	#include "scdaemon.h"
	#include "app-common.h"
	#include "apdu.h"
	#include "iso7816.h"
	#include "tlv.h"

	/* This table is used to keep track of locks on a per reader base.
	The index into the table is the slot number of the reader. The
	mutex will be initialized on demand (one of the advantages of a
	userland threading system). */
	static struct
	{
	int initialized;
	pth_mutex_t lock;
	app_t app; /* Application context in use or NULL. */
	app_t last_app; /* Last application object used as this slot or NULL. */
	} lock_table[10];



	static void deallocate_app (app_t app);



	static void
	print_progress_line (void opaque, const char what, int pc, int cur, int tot)
	{
	ctrl_t ctrl = opaque;
	char line[100];

	if (ctrl)
	{
	snprintf (line, sizeof line, "%s %c %d %d", what, pc, cur, tot);
	send_status_direct (ctrl, "PROGRESS", line);
	}
	}


	/* Lock the reader SLOT. This function shall be used right before
	calling any of the actual application functions to serialize access
	to the reader. We do this always even if the reader is not
	actually used. This allows an actual connection to assume that it
	never shares a reader (while performing one command). Returns 0 on
	success; only then the unlock_reader function must be called after
	returning from the handler. */
	static gpg_error_t
	lock_reader (int slot, ctrl_t ctrl)
	{
	gpg_error_t err;

	if (slot < 0 \|\| slot >= DIM (lock_table))
	return gpg_error (slot<0? GPG_ERR_INV_VALUE : GPG_ERR_RESOURCE_LIMIT);

	if (!lock_table[slot].initialized)
	{
	if (!pth_mutex_init (&lock_table[slot].lock))
	{
	err = gpg_error_from_syserror ();
	log_error ("error initializing mutex: %s\n", strerror (errno));
	return err;
	}
	lock_table[slot].initialized = 1;
	lock_table[slot].app = NULL;
	lock_table[slot].last_app = NULL;
	}

	if (!pth_mutex_acquire (&lock_table[slot].lock, 0, NULL))
	{
	err = gpg_error_from_syserror ();
	log_error ("failed to acquire APP lock for slot %d: %s\n",
	slot, strerror (errno));
	return err;
	}

	apdu_set_progress_cb (slot, print_progress_line, ctrl);

	return 0;
	}

	/* Release a lock on the reader. See lock_reader(). */
	static void
	unlock_reader (int slot)
	{
	if (slot < 0 \|\| slot >= DIM (lock_table)
	\|\| !lock_table[slot].initialized)
	log_bug ("unlock_reader called for invalid slot %d\n", slot);

	apdu_set_progress_cb (slot, NULL, NULL);

	if (!pth_mutex_release (&lock_table[slot].lock))
	log_error ("failed to release APP lock for slot %d: %s\n",
	slot, strerror (errno));
	}


	static void
	dump_mutex_state (pth_mutex_t *m)
	{
	#ifdef _W32_PTH_H
	(void)m;
	log_printf ("unknown under W32");
	#else
	if (!(m->mx_state & PTH_MUTEX_INITIALIZED))
	log_printf ("not_initialized");
	else if (!(m->mx_state & PTH_MUTEX_LOCKED))
	log_printf ("not_locked");
	else
	log_printf ("locked tid=0x%lx count=%lu", (long)m->mx_owner, m->mx_count);
	#endif
	}


	/* This function may be called to print information pertaining to the
	current state of this module to the log. */
	void
	app_dump_state (void)
	{
	int slot;

	for (slot=0; slot < DIM (lock_table); slot++)
	if (lock_table[slot].initialized)
	{
	log_info ("app_dump_state: slot=%d lock=", slot);
	dump_mutex_state (&lock_table[slot].lock);
	if (lock_table[slot].app)
	{
	log_printf (" app=%p", lock_table[slot].app);
	if (lock_table[slot].app->apptype)
	log_printf (" type=`%s'", lock_table[slot].app->apptype);
	}
	if (lock_table[slot].last_app)
	{
	log_printf (" lastapp=%p", lock_table[slot].last_app);
	if (lock_table[slot].last_app->apptype)
	log_printf (" type=`%s'", lock_table[slot].last_app->apptype);
	}
	log_printf ("\n");
	}
	}

	/* Check wether the application NAME is allowed. This does not mean
	we have support for it though. */
	static int
	is_app_allowed (const char *name)
	{
	strlist_t l;

	for (l=opt.disabled_applications; l; l = l->next)
	if (!strcmp (l->d, name))
	return 0; /* no */
	return 1; /* yes */
	}


	/* This may be called to tell this module about a removed or resetted card. */
	void
	application_notify_card_reset (int slot)
	{
	app_t app;

	if (slot < 0 \|\| slot >= DIM (lock_table))
	return;

	/* FIXME: We are ignoring any error value here. */
	lock_reader (slot, NULL);

	/* Mark application as non-reusable. */
	if (lock_table[slot].app)
	lock_table[slot].app->no_reuse = 1;

	/* Deallocate a saved application for that slot, so that we won't
	try to reuse it. If there is no saved application, set a flag so
	that we won't save the current state. */
	app = lock_table[slot].last_app;

	if (app)
	{
	lock_table[slot].last_app = NULL;
	deallocate_app (app);
	}
	unlock_reader (slot);
	}


	/* This function is used by the serialno command to check for an
	application conflict which may appear if the serialno command is
	used to request a specific application and the connection has
	already done a select_application. */
	gpg_error_t
	check_application_conflict (ctrl_t ctrl, int slot, const char *name)
	{
	app_t app;

	(void)ctrl;

	if (slot < 0 \|\| slot >= DIM (lock_table))
	return gpg_error (GPG_ERR_INV_VALUE);

	app = lock_table[slot].initialized ? lock_table[slot].app : NULL;
	if (app && app->apptype && name)
	if ( ascii_strcasecmp (app->apptype, name))
	return gpg_error (GPG_ERR_CONFLICT);
	return 0;
	}


	/* If called with NAME as NULL, select the best fitting application
	and return a context; otherwise select the application with NAME
	and return a context. SLOT identifies the reader device. Returns
	an error code and stores NULL at R_APP if no application was found
	or no card is present. */
	gpg_error_t
	select_application (ctrl_t ctrl, int slot, const char name, app_t r_app)
	{
	gpg_error_t err;
	app_t app = NULL;
	unsigned char *result = NULL;
	size_t resultlen;

	(void)ctrl;

	*r_app = NULL;

	err = lock_reader (slot, ctrl);
	if (err)
	return err;

	/* First check whether we already have an application to share. */
	app = lock_table[slot].initialized ? lock_table[slot].app : NULL;
	if (app && name)
	if (!app->apptype \|\| ascii_strcasecmp (app->apptype, name))
	{
	unlock_reader (slot);
	if (app->apptype)
	log_info ("application `%s' in use by reader %d - can't switch\n",
	app->apptype, slot);
	return gpg_error (GPG_ERR_CONFLICT);
	}

	/* Don't use a non-reusable marked application. */
	if (app && app->no_reuse)
	{
	unlock_reader (slot);
	log_info ("lingering application `%s' in use by reader %d"
	" - can't switch\n",
	app->apptype? app->apptype:"?", slot);
	return gpg_error (GPG_ERR_CONFLICT);
	}

	/* If we don't have an app, check whether we have a saved
	application for that slot. This is useful so that a card does
	not get reset even if only one session is using the card - this
	way the PIN cache and other cached data are preserved. */
	if (!app && lock_table[slot].initialized && lock_table[slot].last_app)
	{
	app = lock_table[slot].last_app;
	if (!name \|\| (app->apptype && !ascii_strcasecmp (app->apptype, name)) )
	{
	/* Yes, we can reuse this application - either the caller
	requested an unspecific one or the requested one matches
	the saved one. */
	lock_table[slot].app = app;
	lock_table[slot].last_app = NULL;
	}
	else
	{
	/* No, this saved application can't be used - deallocate it. */
	lock_table[slot].last_app = NULL;
	deallocate_app (app);
	app = NULL;
	}
	}

	/* If we can reuse an application, bump the reference count and
	return it. */
	if (app)
	{
	if (app->slot != slot)
	log_bug ("slot mismatch %d/%d\n", app->slot, slot);
	app->slot = slot;

	app->ref_count++;
	*r_app = app;
	unlock_reader (slot);
	return 0; /* Okay: We share that one. */
	}

	/* Need to allocate a new one. */
	app = xtrycalloc (1, sizeof *app);
	if (!app)
	{
	err = gpg_error_from_syserror ();
	log_info ("error allocating context: %s\n", gpg_strerror (err));
	unlock_reader (slot);
	return err;
	}
	app->slot = slot;


	/* Fixme: We should now first check whether a card is at all
	present. */

	/* Try to read the GDO file first to get a default serial number. */
	err = iso7816_select_file (slot, 0x3F00, 1, NULL, NULL);
	if (!err)
	err = iso7816_select_file (slot, 0x2F02, 0, NULL, NULL);
	if (!err)
	err = iso7816_read_binary (slot, 0, 0, &result, &resultlen);
	if (!err)
	{
	size_t n;
	const unsigned char *p;

	p = find_tlv_unchecked (result, resultlen, 0x5A, &n);
	if (p)
	resultlen -= (p-result);
	if (p && n > resultlen && n == 0x0d && resultlen+1 == n)
	{
	/* The object it does not fit into the buffer. This is an
	invalid encoding (or the buffer is too short. However, I
	have some test cards with such an invalid encoding and
	therefore I use this ugly workaround to return something
	I can further experiment with. */
	log_info ("enabling BMI testcard workaround\n");
	n--;
	}

	if (p && n <= resultlen)
	{
	/* The GDO file is pretty short, thus we simply reuse it for
	storing the serial number. */
	memmove (result, p, n);
	app->serialno = result;
	app->serialnolen = n;
	err = app_munge_serialno (app);
	if (err)
	goto leave;
	}
	else
	xfree (result);
	result = NULL;
	}

	/* For certain error codes, there is no need to try more. */
	if (gpg_err_code (err) == GPG_ERR_CARD_NOT_PRESENT
	\|\| gpg_err_code (err) == GPG_ERR_ENODEV)
	goto leave;

	/* Figure out the application to use. */
	err = gpg_error (GPG_ERR_NOT_FOUND);

	if (err && is_app_allowed ("openpgp")
	&& (!name \|\| !strcmp (name, "openpgp")))
	err = app_select_openpgp (app);
	if (err && is_app_allowed ("nks") && (!name \|\| !strcmp (name, "nks")))
	err = app_select_nks (app);
	if (err && is_app_allowed ("p15") && (!name \|\| !strcmp (name, "p15")))
	err = app_select_p15 (app);
	if (err && is_app_allowed ("dinsig") && (!name \|\| !strcmp (name, "dinsig")))
	err = app_select_dinsig (app);
	if (err && is_app_allowed ("geldkarte")
	&& (!name \|\| !strcmp (name, "geldkarte")))
	err = app_select_geldkarte (app);
	+ if (err && is_app_allowed ("undefined")
	+ && (name && !strcmp (name, "undefined")))
	+ {
	+ /* We switch to the "undefined" application only if explicitly
	+ requested. */
	+ app->apptype = "UNDEFINED";
	+ err = 0;
	+ }
	if (err && name)
	err = gpg_error (GPG_ERR_NOT_SUPPORTED);

	leave:
	if (err)
	{
	if (name)
	log_info ("can't select application `%s': %s\n",
	name, gpg_strerror (err));
	else
	log_info ("no supported card application found: %s\n",
	gpg_strerror (err));
	xfree (app);
	unlock_reader (slot);
	return err;
	}

	app->ref_count = 1;

	lock_table[slot].app = app;
	*r_app = app;
	unlock_reader (slot);
	return 0;
	}


	char *
	get_supported_applications (void)
	{
	const char *list[] = {
	"openpgp",
	"nks",
	"p15",
	"dinsig",
	"geldkarte",
	+ /* Note: "undefined" is not listed here because it needs special
	+ treatment by the client. */
	NULL
	};
	int idx;
	size_t nbytes;
	char buffer, p;

	for (nbytes=1, idx=0; list[idx]; idx++)
	nbytes += strlen (list[idx]) + 1 + 1;

	buffer = xtrymalloc (nbytes);
	if (!buffer)
	return NULL;

	for (p=buffer, idx=0; list[idx]; idx++)
	if (is_app_allowed (list[idx]))
	p = stpcpy (stpcpy (p, list[idx]), ":\n");
	*p = 0;

	return buffer;
	}


	/* Deallocate the application. */
	static void
	deallocate_app (app_t app)
	{
	if (app->fnc.deinit)
	{
	app->fnc.deinit (app);
	app->fnc.deinit = NULL;
	}

	xfree (app->serialno);
	xfree (app);
	}

	/* Free the resources associated with the application APP. APP is
	allowed to be NULL in which case this is a no-op. Note that we are
	using reference counting to track the users of the application and
	actually deferring the deallocation to allow for a later reuse by
	a new connection. */
	void
	release_application (app_t app)
	{
	int slot;

	if (!app)
	return;

	if (!app->ref_count)
	log_bug ("trying to release an already released context\n");
	if (--app->ref_count)
	return;

	/* Move the reference to the application in the lock table. */
	slot = app->slot;
	/* FIXME: We are ignoring any error value. */
	lock_reader (slot, NULL);
	if (lock_table[slot].app != app)
	{
	unlock_reader (slot);
	log_bug ("app mismatch %p/%p\n", app, lock_table[slot].app);
	deallocate_app (app);
	return;
	}

	if (lock_table[slot].last_app)
	deallocate_app (lock_table[slot].last_app);
	if (app->no_reuse)
	{
	/* If we shall not re-use the application we can't save it for
	later use. */
	deallocate_app (app);
	lock_table[slot].last_app = NULL;
	}
	else
	lock_table[slot].last_app = lock_table[slot].app;
	lock_table[slot].app = NULL;
	unlock_reader (slot);
	}



	/* The serial number may need some cosmetics. Do it here. This
	function shall only be called once after a new serial number has
	been put into APP->serialno.

	Prefixes we use:

	FF 00 00 = For serial numbers starting with an FF
	FF 01 00 = Some german p15 cards return an empty serial number so the
	serial number from the EF(TokenInfo) is used instead.
	FF 7F 00 = No serialno.

	All other serial number not starting with FF are used as they are.
	*/
	gpg_error_t
	app_munge_serialno (app_t app)
	{
	if (app->serialnolen && app->serialno[0] == 0xff)
	{
	/* The serial number starts with our special prefix. This
	requires that we put our default prefix "FF0000" in front. */
	unsigned char *p = xtrymalloc (app->serialnolen + 3);
	if (!p)
	return gpg_error_from_syserror ();
	memcpy (p, "\xff\0", 3);
	memcpy (p+3, app->serialno, app->serialnolen);
	app->serialnolen += 3;
	xfree (app->serialno);
	app->serialno = p;
	}
	else if (!app->serialnolen)
	{
	unsigned char *p = xtrymalloc (3);
	if (!p)
	return gpg_error_from_syserror ();
	memcpy (p, "\xff\x7f", 3);
	app->serialnolen = 3;
	xfree (app->serialno);
	app->serialno = p;
	}
	return 0;
	}



	/* Retrieve the serial number and the time of the last update of the
	card. The serial number is returned as a malloced string (hex
	encoded) in SERIAL and the time of update is returned in STAMP. If
	no update time is available the returned value is 0. Caller must
	free SERIAL unless the function returns an error. If STAMP is not
	of interest, NULL may be passed. */
	gpg_error_t
	app_get_serial_and_stamp (app_t app, char *serial, time_t stamp)
	{
	char *buf;

	if (!app \|\| !serial)
	return gpg_error (GPG_ERR_INV_VALUE);

	*serial = NULL;
	if (stamp)
	stamp = 0; / not available */

	if (!app->serialnolen)
	buf = xtrystrdup ("FF7F00");
	else
	buf = bin2hex (app->serialno, app->serialnolen, NULL);
	if (!buf)
	return gpg_error_from_syserror ();

	*serial = buf;
	return 0;
	}


	/* Write out the application specifig status lines for the LEARN
	command. */
	gpg_error_t
	app_write_learn_status (app_t app, ctrl_t ctrl, unsigned int flags)
	{
	gpg_error_t err;

	if (!app)
	return gpg_error (GPG_ERR_INV_VALUE);
	if (!app->ref_count)
	return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
	if (!app->fnc.learn_status)
	return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);

	/* We do not send APPTYPE if only keypairinfo is requested. */
	if (app->apptype && !(flags & 1))
	send_status_info (ctrl, "APPTYPE",
	app->apptype, strlen (app->apptype), NULL, 0);
	err = lock_reader (app->slot, ctrl);
	if (err)
	return err;
	err = app->fnc.learn_status (app, ctrl, flags);
	unlock_reader (app->slot);
	return err;
	}


	/* Read the certificate with id CERTID (as returned by learn_status in
	the CERTINFO status lines) and return it in the freshly allocated
	buffer put into CERT and the length of the certificate put into
	CERTLEN. */
	gpg_error_t
	app_readcert (app_t app, const char *certid,
	unsigned char *cert, size_t certlen)
	{
	gpg_error_t err;

	if (!app)
	return gpg_error (GPG_ERR_INV_VALUE);
	if (!app->ref_count)
	return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
	if (!app->fnc.readcert)
	return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
	err = lock_reader (app->slot, NULL/* FIXME*/);
	if (err)
	return err;
	err = app->fnc.readcert (app, certid, cert, certlen);
	unlock_reader (app->slot);
	return err;
	}


	/* Read the key with ID KEYID. On success a canonical encoded
	S-expression with the public key will get stored at PK and its
	length (for assertions) at PKLEN; the caller must release that
	buffer. On error NULL will be stored at PK and PKLEN and an error
	code returned.

	This function might not be supported by all applications. */
	gpg_error_t
	app_readkey (app_t app, const char keyid, unsigned char pk, size_t pklen)
	{
	gpg_error_t err;

	if (pk)
	*pk = NULL;
	if (pklen)
	*pklen = 0;

	if (!app \|\| !keyid \|\| !pk \|\| !pklen)
	return gpg_error (GPG_ERR_INV_VALUE);
	if (!app->ref_count)
	return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
	if (!app->fnc.readkey)
	return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
	err = lock_reader (app->slot, NULL /FIXME/);
	if (err)
	return err;
	err= app->fnc.readkey (app, keyid, pk, pklen);
	unlock_reader (app->slot);
	return err;
	}


	/* Perform a GETATTR operation. */
	gpg_error_t
	app_getattr (app_t app, ctrl_t ctrl, const char *name)
	{
	gpg_error_t err;

	if (!app \|\| !name \|\| !*name)
	return gpg_error (GPG_ERR_INV_VALUE);
	if (!app->ref_count)
	return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);

	if (app->apptype && name && !strcmp (name, "APPTYPE"))
	{
	send_status_info (ctrl, "APPTYPE",
	app->apptype, strlen (app->apptype), NULL, 0);
	return 0;
	}
	if (name && !strcmp (name, "SERIALNO"))
	{
	char *serial;
	time_t stamp;
	int rc;

	rc = app_get_serial_and_stamp (app, &serial, &stamp);
	if (rc)
	return rc;
	send_status_info (ctrl, "SERIALNO", serial, strlen (serial), NULL, 0);
	xfree (serial);
	return 0;
	}

	if (!app->fnc.getattr)
	return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
	err = lock_reader (app->slot, ctrl);
	if (err)
	return err;
	err = app->fnc.getattr (app, ctrl, name);
	unlock_reader (app->slot);
	return err;
	}

	/* Perform a SETATTR operation. */
	gpg_error_t
	app_setattr (app_t app, const char *name,
	gpg_error_t (pincb)(void, const char , char *),
	void *pincb_arg,
	const unsigned char *value, size_t valuelen)
	{
	gpg_error_t err;

	if (!app \|\| !name \|\| !*name \|\| !value)
	return gpg_error (GPG_ERR_INV_VALUE);
	if (!app->ref_count)
	return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
	if (!app->fnc.setattr)
	return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
	err = lock_reader (app->slot, NULL /FIXME/);
	if (err)
	return err;
	err = app->fnc.setattr (app, name, pincb, pincb_arg, value, valuelen);
	unlock_reader (app->slot);
	return err;
	}

	/* Create the signature and return the allocated result in OUTDATA.
	If a PIN is required the PINCB will be used to ask for the PIN; it
	should return the PIN in an allocated buffer and put it into PIN. */
	gpg_error_t
	app_sign (app_t app, const char *keyidstr, int hashalgo,
	gpg_error_t (pincb)(void, const char , char *),
	void *pincb_arg,
	const void *indata, size_t indatalen,
	unsigned char *outdata, size_t outdatalen )
	{
	gpg_error_t err;

	if (!app \|\| !indata \|\| !indatalen \|\| !outdata \|\| !outdatalen \|\| !pincb)
	return gpg_error (GPG_ERR_INV_VALUE);
	if (!app->ref_count)
	return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
	if (!app->fnc.sign)
	return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
	err = lock_reader (app->slot, NULL /FIXME/);
	if (err)
	return err;
	err = app->fnc.sign (app, keyidstr, hashalgo,
	pincb, pincb_arg,
	indata, indatalen,
	outdata, outdatalen);
	unlock_reader (app->slot);
	if (opt.verbose)
	log_info ("operation sign result: %s\n", gpg_strerror (err));
	return err;
	}

	/* Create the signature using the INTERNAL AUTHENTICATE command and
	return the allocated result in OUTDATA. If a PIN is required the
	PINCB will be used to ask for the PIN; it should return the PIN in
	an allocated buffer and put it into PIN. */
	gpg_error_t
	app_auth (app_t app, const char *keyidstr,
	gpg_error_t (pincb)(void, const char , char *),
	void *pincb_arg,
	const void *indata, size_t indatalen,
	unsigned char *outdata, size_t outdatalen )
	{
	gpg_error_t err;

	if (!app \|\| !indata \|\| !indatalen \|\| !outdata \|\| !outdatalen \|\| !pincb)
	return gpg_error (GPG_ERR_INV_VALUE);
	if (!app->ref_count)
	return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
	if (!app->fnc.auth)
	return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
	err = lock_reader (app->slot, NULL /FIXME/);
	if (err)
	return err;
	err = app->fnc.auth (app, keyidstr,
	pincb, pincb_arg,
	indata, indatalen,
	outdata, outdatalen);
	unlock_reader (app->slot);
	if (opt.verbose)
	log_info ("operation auth result: %s\n", gpg_strerror (err));
	return err;
	}


	/* Decrypt the data in INDATA and return the allocated result in OUTDATA.
	If a PIN is required the PINCB will be used to ask for the PIN; it
	should return the PIN in an allocated buffer and put it into PIN. */
	gpg_error_t
	app_decipher (app_t app, const char *keyidstr,
	gpg_error_t (pincb)(void, const char , char *),
	void *pincb_arg,
	const void *indata, size_t indatalen,
	unsigned char *outdata, size_t outdatalen )
	{
	gpg_error_t err;

	if (!app \|\| !indata \|\| !indatalen \|\| !outdata \|\| !outdatalen \|\| !pincb)
	return gpg_error (GPG_ERR_INV_VALUE);
	if (!app->ref_count)
	return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
	if (!app->fnc.decipher)
	return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
	err = lock_reader (app->slot, NULL /FIXME/);
	if (err)
	return err;
	err = app->fnc.decipher (app, keyidstr,
	pincb, pincb_arg,
	indata, indatalen,
	outdata, outdatalen);
	unlock_reader (app->slot);
	if (opt.verbose)
	log_info ("operation decipher result: %s\n", gpg_strerror (err));
	return err;
	}


	/* Perform the WRITECERT operation. */
	gpg_error_t
	app_writecert (app_t app, ctrl_t ctrl,
	const char *certidstr,
	gpg_error_t (pincb)(void, const char , char *),
	void *pincb_arg,
	const unsigned char *data, size_t datalen)
	{
	gpg_error_t err;

	if (!app \|\| !certidstr \|\| !*certidstr \|\| !pincb)
	return gpg_error (GPG_ERR_INV_VALUE);
	if (!app->ref_count)
	return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
	if (!app->fnc.writecert)
	return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
	err = lock_reader (app->slot, ctrl);
	if (err)
	return err;
	err = app->fnc.writecert (app, ctrl, certidstr,
	pincb, pincb_arg, data, datalen);
	unlock_reader (app->slot);
	if (opt.verbose)
	log_info ("operation writecert result: %s\n", gpg_strerror (err));
	return err;
	}


	/* Perform the WRITEKEY operation. */
	gpg_error_t
	app_writekey (app_t app, ctrl_t ctrl,
	const char *keyidstr, unsigned int flags,
	gpg_error_t (pincb)(void, const char , char *),
	void *pincb_arg,
	const unsigned char *keydata, size_t keydatalen)
	{
	gpg_error_t err;

	if (!app \|\| !keyidstr \|\| !*keyidstr \|\| !pincb)
	return gpg_error (GPG_ERR_INV_VALUE);
	if (!app->ref_count)
	return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
	if (!app->fnc.writekey)
	return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
	err = lock_reader (app->slot, ctrl);
	if (err)
	return err;
	err = app->fnc.writekey (app, ctrl, keyidstr, flags,
	pincb, pincb_arg, keydata, keydatalen);
	unlock_reader (app->slot);
	if (opt.verbose)
	log_info ("operation writekey result: %s\n", gpg_strerror (err));
	return err;
	}


	/* Perform a SETATTR operation. */
	gpg_error_t
	app_genkey (app_t app, ctrl_t ctrl, const char *keynostr, unsigned int flags,
	time_t createtime,
	gpg_error_t (pincb)(void, const char , char *),
	void *pincb_arg)
	{
	gpg_error_t err;

	if (!app \|\| !keynostr \|\| !*keynostr \|\| !pincb)
	return gpg_error (GPG_ERR_INV_VALUE);
	if (!app->ref_count)
	return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
	if (!app->fnc.genkey)
	return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
	err = lock_reader (app->slot, ctrl);
	if (err)
	return err;
	err = app->fnc.genkey (app, ctrl, keynostr, flags,
	createtime, pincb, pincb_arg);
	unlock_reader (app->slot);
	if (opt.verbose)
	log_info ("operation genkey result: %s\n", gpg_strerror (err));
	return err;
	}


	/* Perform a GET CHALLENGE operation. This fucntion is special as it
	directly accesses the card without any application specific
	wrapper. */
	gpg_error_t
	app_get_challenge (app_t app, size_t nbytes, unsigned char *buffer)
	{
	gpg_error_t err;

	if (!app \|\| !nbytes \|\| !buffer)
	return gpg_error (GPG_ERR_INV_VALUE);
	if (!app->ref_count)
	return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
	err = lock_reader (app->slot, NULL /FIXME/);
	if (err)
	return err;
	err = iso7816_get_challenge (app->slot, nbytes, buffer);
	unlock_reader (app->slot);
	return err;
	}



	/* Perform a CHANGE REFERENCE DATA or RESET RETRY COUNTER operation. */
	gpg_error_t
	app_change_pin (app_t app, ctrl_t ctrl, const char *chvnostr, int reset_mode,
	gpg_error_t (pincb)(void, const char , char *),
	void *pincb_arg)
	{
	gpg_error_t err;

	if (!app \|\| !chvnostr \|\| !*chvnostr \|\| !pincb)
	return gpg_error (GPG_ERR_INV_VALUE);
	if (!app->ref_count)
	return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
	if (!app->fnc.change_pin)
	return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
	err = lock_reader (app->slot, ctrl);
	if (err)
	return err;
	err = app->fnc.change_pin (app, ctrl, chvnostr, reset_mode,
	pincb, pincb_arg);
	unlock_reader (app->slot);
	if (opt.verbose)
	log_info ("operation change_pin result: %s\n", gpg_strerror (err));
	return err;
	}


	/* Perform a VERIFY operation without doing anything lese. This may
	be used to initialze a the PIN cache for long lasting other
	operations. Its use is highly application dependent. */
	gpg_error_t
	app_check_pin (app_t app, const char *keyidstr,
	gpg_error_t (pincb)(void, const char , char *),
	void *pincb_arg)
	{
	gpg_error_t err;

	if (!app \|\| !keyidstr \|\| !*keyidstr \|\| !pincb)
	return gpg_error (GPG_ERR_INV_VALUE);
	if (!app->ref_count)
	return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
	if (!app->fnc.check_pin)
	return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
	err = lock_reader (app->slot, NULL /FIXME/);
	if (err)
	return err;
	err = app->fnc.check_pin (app, keyidstr, pincb, pincb_arg);
	unlock_reader (app->slot);
	if (opt.verbose)
	log_info ("operation check_pin result: %s\n", gpg_strerror (err));
	return err;
	}

File Metadata

Mime Type: text/x-diff
Expires: Sun, Feb 23, 8:13 PM (1 h, 8 m)
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: 6a/b1/661d248d85567cff185ae0b2724a

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions