No OneTemporary
Actions

Size

65 KB

Subscribers

None

View Options

	diff --git a/doc/scdaemon.texi b/doc/scdaemon.texi
	index 575553f35..21c3fd826 100644
	--- a/doc/scdaemon.texi
	+++ b/doc/scdaemon.texi
	@@ -1,770 +1,776 @@
	@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.

	@include defs.inc

	@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. Note that you cannot
	abbreviate this command.

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

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

	@item --server
	@opindex server
	Run in server mode and wait for commands on the @code{stdin}. The
	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 behavior 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 option 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
	@efindex ASSUAN_DEBUG
	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 0 switches to a default category. If this option is not
	used the categories are taken from the environment variable
	@code{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 --listen-backlog @var{n}
	@opindex listen-backlog
	Set the size of the queue for pending connections. The default is 64.
	This option has an effect only if @option{--multi-server} is also
	used.

	@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. Use @file{socket://} to log to
	socket.


	@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 falling 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:
	@cartouche
	@smallexample
	echo scd getinfo reader_list \
	\| gpg-connect-agent --decode \| awk '/^D/ @{print $2@}'
	@end smallexample
	@end cartouche

	+@item --card-timeout @var{n}
	+@opindex card-timeout
	+This option is deprecated. In GnuPG 2.0, it used to be used for
	+DISCONNECT command to control timing issue. Since DISCONNECT command
	+works synchronously, it has no effect.
	+
	@item --enable-pinpad-varlen
	@opindex enable-pinpad-varlen
	Please specify this option when the card reader supports variable
	length input for pinpad (default is no). For known readers (listed in
	ccid-driver.c and apdu.c), this option is not needed. Note that if
	your card reader doesn't supports variable length input but you want
	to use it, you need to specify your pinpad request on your card.


	@item --disable-pinpad
	@opindex disable-pinpad
	Even if a card reader features a pinpad, 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 option 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} option 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.

	@item --application-priority @var{namelist}
	@opindex application-priority
	This option allows to change the order in which applications of a card
	a tried if no specific application was requested. @var{namelist} is a
	space or comma delimited list of application names. Unknown names are
	simply skipped. Applications not mentioned in the list are put in the
	former order at the end of the new priority list.

	To get the list of current active applications, use
	@cartouche
	@smallexample
	gpg-connect-agent 'scd getinfo app_list' /bye
	@end smallexample
	@end cartouche

	@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
	* SmartCard-HSM:: The SmartCard-HSM 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.

	@noindent
	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 SmartCard-HSM
	@subsection The SmartCard-HSM card application ``sc-hsm''

	This application adds read-only support for keys and certificates
	stored on a @uref{http://www.smartcard-hsm.com, SmartCard-HSM}.

	To generate keys and store certificates you may use
	@uref{https://github.com/OpenSC/OpenSC/wiki/SmartCardHSM, OpenSC} or
	the tools from @uref{http://www.openscdp.org, OpenSCDP}.

	The SmartCard-HSM cards requires a card reader that supports Extended
	Length APDUs.

	@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 every card
	reader's status change. An example of this script is provided with the
	distribution

	@item reader_@var{n}.status
	This file is created by @command{scdaemon} 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 except 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{@value{LOCALRUNDIR}/scdaemon/socket}, configuration information
	is read from @var{@value{SYSCONFDIR}/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 generated 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
	@end example

	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 @option{--force} option, the command might do an INQUIRE
	like this:

	@example
	INQUIRE KNOWNCARDP <hexstring_with_serialNumber>
	@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 read 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.

	If the card is aware of the apdding format a status line with padding
	information is send before the plaintext data. The key for this
	status line is @code{PADDING} with the only defined value being 0 and
	meaning padding has been removed.

	@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 generated 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/scdaemon.c b/scd/scdaemon.c
	index 12eff755b..42efb4c37 100644
	--- a/scd/scdaemon.c
	+++ b/scd/scdaemon.c
	@@ -1,1457 +1,1462 @@
	/* scdaemon.c - The GnuPG Smartcard Daemon
	* Copyright (C) 2001-2002, 2004-2005, 2007-2009 Free Software Foundation, Inc.
	* Copyright (C) 2001-2002, 2004-2005, 2007-2014 Werner Koch
	*
	* 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 <https://www.gnu.org/licenses/>.
	*/

	#include <config.h>

	#include <stdio.h>
	#include <stdlib.h>
	#include <stddef.h>
	#include <stdarg.h>
	#include <string.h>
	#include <errno.h>
	#include <assert.h>
	#include <time.h>
	#include <fcntl.h>
	#ifndef HAVE_W32_SYSTEM
	#include <sys/socket.h>
	#include <sys/un.h>
	#endif /HAVE_W32_SYSTEM/
	#include <unistd.h>
	#include <signal.h>
	#include <npth.h>

	#define GNUPG_COMMON_NEED_AFLOCAL
	#include "scdaemon.h"
	#include <ksba.h>
	#include <gcrypt.h>

	#include <assuan.h> /* malloc hooks */

	#include "../common/i18n.h"
	#include "../common/sysutils.h"
	#include "app-common.h"
	#include "iso7816.h"
	#include "apdu.h"
	#include "ccid-driver.h"
	#include "../common/gc-opt-flags.h"
	#include "../common/asshelp.h"
	#include "../common/exechelp.h"
	#include "../common/init.h"

	#ifndef ENAMETOOLONG
	# define ENAMETOOLONG EINVAL
	#endif

	enum cmd_and_opt_values
	{ aNull = 0,
	oCsh = 'c',
	oQuiet = 'q',
	oSh = 's',
	oVerbose = 'v',

	oNoVerbose = 500,
	aGPGConfList,
	aGPGConfTest,
	oOptions,
	oDebug,
	oDebugAll,
	oDebugLevel,
	oDebugWait,
	oDebugAllowCoreDump,
	oDebugCCIDDriver,
	oDebugLogTid,
	oDebugAssuanLogCats,
	oNoGreeting,
	oNoOptions,
	oHomedir,
	oNoDetach,
	oNoGrab,
	oLogFile,
	oServer,
	oMultiServer,
	oDaemon,
	oBatch,
	oReaderPort,
	+ oCardTimeout,
	octapiDriver,
	opcscDriver,
	oDisableCCID,
	oDisableOpenSC,
	oDisablePinpad,
	oAllowAdmin,
	oDenyAdmin,
	oDisableApplication,
	oApplicationPriority,
	oEnablePinpadVarlen,
	oListenBacklog
	};



	static ARGPARSE_OPTS opts[] = {
	ARGPARSE_c (aGPGConfList, "gpgconf-list", "@"),
	ARGPARSE_c (aGPGConfTest, "gpgconf-test", "@"),

	ARGPARSE_group (301, N_("@Options:\n ")),

	ARGPARSE_s_n (oServer,"server", N_("run in server mode (foreground)")),
	ARGPARSE_s_n (oMultiServer, "multi-server",
	N_("run in multi server mode (foreground)")),
	ARGPARSE_s_n (oDaemon, "daemon", N_("run in daemon mode (background)")),
	ARGPARSE_s_n (oVerbose, "verbose", N_("verbose")),
	ARGPARSE_s_n (oQuiet, "quiet", N_("be somewhat more quiet")),
	ARGPARSE_s_n (oSh, "sh", N_("sh-style command output")),
	ARGPARSE_s_n (oCsh, "csh", N_("csh-style command output")),
	ARGPARSE_s_s (oOptions, "options", N_("\|FILE\|read options from FILE")),
	ARGPARSE_s_s (oDebug, "debug", "@"),
	ARGPARSE_s_n (oDebugAll, "debug-all", "@"),
	ARGPARSE_s_s (oDebugLevel, "debug-level" ,
	N_("\|LEVEL\|set the debugging level to LEVEL")),
	ARGPARSE_s_i (oDebugWait, "debug-wait", "@"),
	ARGPARSE_s_n (oDebugAllowCoreDump, "debug-allow-core-dump", "@"),
	ARGPARSE_s_n (oDebugCCIDDriver, "debug-ccid-driver", "@"),
	ARGPARSE_s_n (oDebugLogTid, "debug-log-tid", "@"),
	ARGPARSE_p_u (oDebugAssuanLogCats, "debug-assuan-log-cats", "@"),
	ARGPARSE_s_n (oNoDetach, "no-detach", N_("do not detach from the console")),
	ARGPARSE_s_s (oLogFile, "log-file", N_("\|FILE\|write a log to FILE")),
	ARGPARSE_s_s (oReaderPort, "reader-port",
	N_("\|N\|connect to reader at port N")),
	ARGPARSE_s_s (octapiDriver, "ctapi-driver",
	N_("\|NAME\|use NAME as ct-API driver")),
	ARGPARSE_s_s (opcscDriver, "pcsc-driver",
	N_("\|NAME\|use NAME as PC/SC driver")),
	ARGPARSE_s_n (oDisableCCID, "disable-ccid",
	#ifdef HAVE_LIBUSB
	N_("do not use the internal CCID driver")
	#else
	"@"
	#endif
	/* end --disable-ccid */),
	+ ARGPARSE_s_u (oCardTimeout, "card-timeout",
	+ N_("\|N\|disconnect the card after N seconds of inactivity")),

	ARGPARSE_s_n (oDisablePinpad, "disable-pinpad",
	N_("do not use a reader's pinpad")),
	ARGPARSE_ignore (300, "disable-keypad"),

	ARGPARSE_s_n (oAllowAdmin, "allow-admin", "@"),
	ARGPARSE_s_n (oDenyAdmin, "deny-admin",
	N_("deny the use of admin card commands")),
	ARGPARSE_s_s (oDisableApplication, "disable-application", "@"),
	ARGPARSE_s_s (oApplicationPriority, "application-priority",
	N_("\|LIST\|Change the application priority to LIST")),
	ARGPARSE_s_n (oEnablePinpadVarlen, "enable-pinpad-varlen",
	N_("use variable length input for pinpad")),
	ARGPARSE_s_s (oHomedir, "homedir", "@"),
	ARGPARSE_s_i (oListenBacklog, "listen-backlog", "@"),

	ARGPARSE_end ()
	};


	/* The list of supported debug flags. */
	static struct debug_flags_s debug_flags [] =
	{
	{ DBG_MPI_VALUE , "mpi" },
	{ DBG_CRYPTO_VALUE , "crypto" },
	{ DBG_MEMORY_VALUE , "memory" },
	{ DBG_CACHE_VALUE , "cache" },
	{ DBG_MEMSTAT_VALUE, "memstat" },
	{ DBG_HASHING_VALUE, "hashing" },
	{ DBG_IPC_VALUE , "ipc" },
	{ DBG_CARD_IO_VALUE, "cardio" },
	{ DBG_READER_VALUE , "reader" },
	{ 0, NULL }
	};


	/* The card driver we use by default for PC/SC. */
	#if defined(HAVE_W32_SYSTEM) \|\| defined(__CYGWIN__)
	#define DEFAULT_PCSC_DRIVER "winscard.dll"
	#elif defined(__APPLE__)
	#define DEFAULT_PCSC_DRIVER "/System/Library/Frameworks/PCSC.framework/PCSC"
	#elif defined(__GLIBC__)
	#define DEFAULT_PCSC_DRIVER "libpcsclite.so.1"
	#else
	#define DEFAULT_PCSC_DRIVER "libpcsclite.so"
	#endif

	/* The timer tick used to check card removal.

	We poll every 500ms to let the user immediately know a status
	change.

	For a card reader with an interrupt endpoint, this timer is not
	used with the internal CCID driver.

	This is not too good for power saving but given that there is no
	easy way to block on card status changes it is the best we can do.
	For PC/SC we could in theory use an extra thread to wait for status
	changes but that requires a native thread because there is no way
	to make the underlying PC/SC card change function block using a Npth
	mechanism. Given that a native thread could only be used under W32
	we don't do that at all. */
	#define TIMERTICK_INTERVAL_SEC (0)
	#define TIMERTICK_INTERVAL_USEC (500000)

	/* Flag to indicate that a shutdown was requested. */
	static int shutdown_pending;

	/* It is possible that we are currently running under setuid permissions */
	static int maybe_setuid = 1;

	/* Flag telling whether we are running as a pipe server. */
	static int pipe_server;

	/* Name of the communication socket */
	static char *socket_name;
	/* Name of the redirected socket or NULL. */
	static char *redir_socket_name;

	/* We need to keep track of the server's nonces (these are dummies for
	POSIX systems). */
	static assuan_sock_nonce_t socket_nonce;

	/* Value for the listen() backlog argument. Change at runtime with
	* --listen-backlog. */
	static int listen_backlog = 64;

	#ifdef HAVE_W32_SYSTEM
	static HANDLE the_event;
	#else
	/* PID to notify update of usb devices. */
	static pid_t main_thread_pid;
	#endif
	#ifdef HAVE_PSELECT_NO_EINTR
	/* FD to notify changes. */
	static int notify_fd;
	#endif

	static char create_socket_name (char standard_name);
	static gnupg_fd_t create_server_socket (const char *name,
	char **r_redir_name,
	assuan_sock_nonce_t *nonce);

	static void start_connection_thread (void arg);
	static void handle_connections (int listen_fd);

	/* Pth wrapper function definitions. */
	ASSUAN_SYSTEM_NPTH_IMPL;

	static int active_connections;


	static char *
	make_libversion (const char libname, const char (getfnc)(const char))
	{
	const char *s;
	char *result;

	if (maybe_setuid)
	{
	gcry_control (GCRYCTL_INIT_SECMEM, 0, 0); /* Drop setuid. */
	maybe_setuid = 0;
	}
	s = getfnc (NULL);
	result = xmalloc (strlen (libname) + 1 + strlen (s) + 1);
	strcpy (stpcpy (stpcpy (result, libname), " "), s);
	return result;
	}


	static const char *
	my_strusage (int level)
	{
	static char ver_gcry, ver_ksba;
	const char *p;

	switch (level)
	{
	case 11: p = "@SCDAEMON@ (@GNUPG@)";
	break;
	case 13: p = VERSION; break;
	case 17: p = PRINTABLE_OS_NAME; break;
	case 19: p = _("Please report bugs to <@EMAIL@>.\n"); break;

	case 20:
	if (!ver_gcry)
	ver_gcry = make_libversion ("libgcrypt", gcry_check_version);
	p = ver_gcry;
	break;
	case 21:
	if (!ver_ksba)
	ver_ksba = make_libversion ("libksba", ksba_check_version);
	p = ver_ksba;
	break;
	case 1:
	case 40: p = _("Usage: @SCDAEMON@ [options] (-h for help)");
	break;
	case 41: p = _("Syntax: scdaemon [options] [command [args]]\n"
	"Smartcard daemon for @GNUPG@\n");
	break;

	default: p = NULL;
	}
	return p;
	}


	static int
	tid_log_callback (unsigned long *rvalue)
	{
	int len = sizeof (*rvalue);
	npth_t thread;

	thread = npth_self ();
	if (sizeof (thread) < len)
	len = sizeof (thread);
	memcpy (rvalue, &thread, len);

	return 2; /* Use use hex representation. */
	}


	/* Setup the debugging. With a LEVEL of NULL only the active debug
	flags are propagated to the subsystems. With LEVEL set, a specific
	set of debug flags is set; thus overriding all flags already
	set. */
	static void
	set_debug (const char *level)
	{
	int numok = (level && digitp (level));
	int numlvl = numok? atoi (level) : 0;

	if (!level)
	;
	else if (!strcmp (level, "none") \|\| (numok && numlvl < 1))
	opt.debug = 0;
	else if (!strcmp (level, "basic") \|\| (numok && numlvl <= 2))
	opt.debug = DBG_IPC_VALUE;
	else if (!strcmp (level, "advanced") \|\| (numok && numlvl <= 5))
	opt.debug = DBG_IPC_VALUE;
	else if (!strcmp (level, "expert") \|\| (numok && numlvl <= 8))
	opt.debug = (DBG_IPC_VALUE\|DBG_CACHE_VALUE\|DBG_CARD_IO_VALUE);
	else if (!strcmp (level, "guru") \|\| numok)
	{
	opt.debug = ~0;
	/* Unless the "guru" string has been used we don't want to allow
	hashing debugging. The rationale is that people tend to
	select the highest debug value and would then clutter their
	disk with debug files which may reveal confidential data. */
	if (numok)
	opt.debug &= ~(DBG_HASHING_VALUE);
	}
	else
	{
	log_error (_("invalid debug-level '%s' given\n"), level);
	scd_exit(2);
	}


	if (opt.debug && !opt.verbose)
	opt.verbose = 1;
	if (opt.debug && opt.quiet)
	opt.quiet = 0;

	if (opt.debug & DBG_MPI_VALUE)
	gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 2);
	if (opt.debug & DBG_CRYPTO_VALUE )
	gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
	gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);

	if (opt.debug)
	parse_debug_flag (NULL, &opt.debug, debug_flags);
	}



	static void
	cleanup (void)
	{
	if (socket_name && *socket_name)
	{
	char *name;

	name = redir_socket_name? redir_socket_name : socket_name;

	gnupg_remove (name);
	*socket_name = 0;
	}
	}

	static void
	setup_signal_mask (void)
	{
	#ifndef HAVE_W32_SYSTEM
	npth_sigev_init ();
	npth_sigev_add (SIGHUP);
	npth_sigev_add (SIGUSR1);
	npth_sigev_add (SIGUSR2);
	npth_sigev_add (SIGINT);
	npth_sigev_add (SIGCONT);
	npth_sigev_add (SIGTERM);
	npth_sigev_fini ();
	main_thread_pid = getpid ();
	#endif
	}

	int
	main (int argc, char **argv )
	{
	ARGPARSE_ARGS pargs;
	int orig_argc;
	char **orig_argv;
	FILE *configfp = NULL;
	char *configname = NULL;
	const char *shell;
	unsigned int configlineno;
	int parse_debug = 0;
	const char *debug_level = NULL;
	int default_config =1;
	int greeting = 0;
	int nogreeting = 0;
	int multi_server = 0;
	int is_daemon = 0;
	int nodetach = 0;
	int csh_style = 0;
	char *logfile = NULL;
	int debug_wait = 0;
	int gpgconf_list = 0;
	const char *config_filename = NULL;
	int allow_coredump = 0;
	struct assuan_malloc_hooks malloc_hooks;
	int res;
	npth_t pipecon_handler;
	const char *application_priority = NULL;

	early_system_init ();
	set_strusage (my_strusage);
	gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
	/* Please note that we may running SUID(ROOT), so be very CAREFUL
	when adding any stuff between here and the call to INIT_SECMEM()
	somewhere after the option parsing */
	log_set_prefix ("scdaemon", GPGRT_LOG_WITH_PREFIX \| GPGRT_LOG_WITH_PID);

	/* Make sure that our subsystems are ready. */
	i18n_init ();
	init_common_subsystems (&argc, &argv);

	ksba_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);

	malloc_hooks.malloc = gcry_malloc;
	malloc_hooks.realloc = gcry_realloc;
	malloc_hooks.free = gcry_free;
	assuan_set_malloc_hooks (&malloc_hooks);
	assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
	assuan_set_system_hooks (ASSUAN_SYSTEM_NPTH);
	assuan_sock_init ();
	setup_libassuan_logging (&opt.debug, NULL);

	setup_libgcrypt_logging ();
	gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);

	disable_core_dumps ();

	/* Set default options. */
	opt.allow_admin = 1;
	opt.pcsc_driver = DEFAULT_PCSC_DRIVER;

	shell = getenv ("SHELL");
	if (shell && strlen (shell) >= 3 && !strcmp (shell+strlen (shell)-3, "csh") )
	csh_style = 1;

	/* Check whether we have a config file on the commandline */
	orig_argc = argc;
	orig_argv = argv;
	pargs.argc = &argc;
	pargs.argv = &argv;
	pargs.flags= 1\|(1<<6); /* do not remove the args, ignore version */
	while (arg_parse( &pargs, opts))
	{
	if (pargs.r_opt == oDebug \|\| pargs.r_opt == oDebugAll)
	parse_debug++;
	else if (pargs.r_opt == oOptions)
	{ /* yes there is one, so we do not try the default one, but
	read the option file when it is encountered at the
	commandline */
	default_config = 0;
	}
	else if (pargs.r_opt == oNoOptions)
	default_config = 0; /* --no-options */
	else if (pargs.r_opt == oHomedir)
	gnupg_set_homedir (pargs.r.ret_str);
	}

	/* initialize the secure memory. */
	gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
	maybe_setuid = 0;

	/*
	Now we are working under our real uid
	*/


	if (default_config)
	configname = make_filename (gnupg_homedir (), SCDAEMON_NAME EXTSEP_S "conf",
	NULL );


	argc = orig_argc;
	argv = orig_argv;
	pargs.argc = &argc;
	pargs.argv = &argv;
	pargs.flags= 1; /* do not remove the args */
	next_pass:
	if (configname)
	{
	configlineno = 0;
	configfp = fopen (configname, "r");
	if (!configfp)
	{
	if (default_config)
	{
	if( parse_debug )
	log_info (_("Note: no default option file '%s'\n"),
	configname );
	}
	else
	{
	log_error (_("option file '%s': %s\n"),
	configname, strerror(errno) );
	exit(2);
	}
	xfree (configname);
	configname = NULL;
	}
	if (parse_debug && configname )
	log_info (_("reading options from '%s'\n"), configname );
	default_config = 0;
	}

	while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) )
	{
	switch (pargs.r_opt)
	{
	case aGPGConfList: gpgconf_list = 1; break;
	case aGPGConfTest: gpgconf_list = 2; break;
	case oQuiet: opt.quiet = 1; break;
	case oVerbose: opt.verbose++; break;
	case oBatch: opt.batch=1; break;

	case oDebug:
	if (parse_debug_flag (pargs.r.ret_str, &opt.debug, debug_flags))
	{
	pargs.r_opt = ARGPARSE_INVALID_ARG;
	pargs.err = ARGPARSE_PRINT_ERROR;
	}
	break;
	case oDebugAll: opt.debug = ~0; break;
	case oDebugLevel: debug_level = pargs.r.ret_str; break;
	case oDebugWait: debug_wait = pargs.r.ret_int; break;
	case oDebugAllowCoreDump:
	enable_core_dumps ();
	allow_coredump = 1;
	break;
	case oDebugCCIDDriver:
	#ifdef HAVE_LIBUSB
	ccid_set_debug_level (ccid_set_debug_level (-1)+1);
	#endif /HAVE_LIBUSB/
	break;
	case oDebugLogTid:
	log_set_pid_suffix_cb (tid_log_callback);
	break;
	case oDebugAssuanLogCats:
	set_libassuan_log_cats (pargs.r.ret_ulong);
	break;

	case oOptions:
	/* config files may not be nested (silently ignore them) */
	if (!configfp)
	{
	xfree(configname);
	configname = xstrdup(pargs.r.ret_str);
	goto next_pass;
	}
	break;
	case oNoGreeting: nogreeting = 1; break;
	case oNoVerbose: opt.verbose = 0; break;
	case oNoOptions: break; /* no-options */
	case oHomedir: gnupg_set_homedir (pargs.r.ret_str); break;
	case oNoDetach: nodetach = 1; break;
	case oLogFile: logfile = pargs.r.ret_str; break;
	case oCsh: csh_style = 1; break;
	case oSh: csh_style = 0; break;
	case oServer: pipe_server = 1; break;
	case oMultiServer: pipe_server = 1; multi_server = 1; break;
	case oDaemon: is_daemon = 1; break;

	case oReaderPort: opt.reader_port = pargs.r.ret_str; break;
	case octapiDriver: opt.ctapi_driver = pargs.r.ret_str; break;
	case opcscDriver: opt.pcsc_driver = pargs.r.ret_str; break;
	case oDisableCCID: opt.disable_ccid = 1; break;
	case oDisableOpenSC: break;

	case oDisablePinpad: opt.disable_pinpad = 1; break;

	case oAllowAdmin: /* Dummy because allow is now the default. */
	break;
	case oDenyAdmin: opt.allow_admin = 0; break;

	+ case oCardTimeout: opt.card_timeout = pargs.r.ret_ulong; break;
	+
	case oDisableApplication:
	add_to_strlist (&opt.disabled_applications, pargs.r.ret_str);
	break;

	case oApplicationPriority:
	application_priority = pargs.r.ret_str;
	break;

	case oEnablePinpadVarlen: opt.enable_pinpad_varlen = 1; break;

	case oListenBacklog:
	listen_backlog = pargs.r.ret_int;
	break;

	default:
	pargs.err = configfp? ARGPARSE_PRINT_WARNING:ARGPARSE_PRINT_ERROR;
	break;
	}
	}
	if (configfp)
	{
	fclose( configfp );
	configfp = NULL;
	/* Keep a copy of the config name for use by --gpgconf-list. */
	config_filename = configname;
	configname = NULL;
	goto next_pass;
	}
	xfree (configname);
	configname = NULL;
	if (log_get_errorcount(0))
	exit(2);
	if (nogreeting )
	greeting = 0;

	if (greeting)
	{
	es_fprintf (es_stderr, "%s %s; %s\n",
	strusage(11), strusage(13), strusage(14) );
	es_fprintf (es_stderr, "%s\n", strusage(15) );
	}
	#ifdef IS_DEVELOPMENT_VERSION
	log_info ("NOTE: this is a development version!\n");
	#endif

	/* Print a warning if an argument looks like an option. */
	if (!opt.quiet && !(pargs.flags & ARGPARSE_FLAG_STOP_SEEN))
	{
	int i;

	for (i=0; i < argc; i++)
	if (argv[i][0] == '-' && argv[i][1] == '-')
	log_info (_("Note: '%s' is not considered an option\n"), argv[i]);
	}

	if (atexit (cleanup))
	{
	log_error ("atexit failed\n");
	cleanup ();
	exit (1);
	}

	set_debug (debug_level);

	if (initialize_module_command ())
	{
	log_error ("initialization failed\n");
	cleanup ();
	exit (1);
	}

	if (gpgconf_list == 2)
	scd_exit (0);
	if (gpgconf_list)
	{
	/* List options and default values in the GPG Conf format. */
	char *filename = NULL;
	char *filename_esc;

	if (config_filename)
	filename = xstrdup (config_filename);
	else
	filename = make_filename (gnupg_homedir (),
	SCDAEMON_NAME EXTSEP_S "conf", NULL);
	filename_esc = percent_escape (filename, NULL);

	es_printf ("%s-%s.conf:%lu:\"%s\n",
	GPGCONF_NAME, SCDAEMON_NAME,
	GC_OPT_FLAG_DEFAULT, filename_esc);
	xfree (filename_esc);
	xfree (filename);

	es_printf ("verbose:%lu:\n"
	"quiet:%lu:\n"
	"debug-level:%lu:\"none:\n"
	"log-file:%lu:\n",
	GC_OPT_FLAG_NONE,
	GC_OPT_FLAG_NONE,
	GC_OPT_FLAG_DEFAULT,
	GC_OPT_FLAG_NONE );

	es_printf ("reader-port:%lu:\n", GC_OPT_FLAG_NONE );
	es_printf ("ctapi-driver:%lu:\n", GC_OPT_FLAG_NONE );
	es_printf ("pcsc-driver:%lu:\"%s:\n",
	GC_OPT_FLAG_DEFAULT, DEFAULT_PCSC_DRIVER );
	#ifdef HAVE_LIBUSB
	es_printf ("disable-ccid:%lu:\n", GC_OPT_FLAG_NONE );
	#endif
	es_printf ("deny-admin:%lu:\n", GC_OPT_FLAG_NONE );
	es_printf ("disable-pinpad:%lu:\n", GC_OPT_FLAG_NONE );
	es_printf ("card-timeout:%lu:%d:\n", GC_OPT_FLAG_DEFAULT, 0);
	es_printf ("enable-pinpad-varlen:%lu:\n", GC_OPT_FLAG_NONE );
	es_printf ("application-priority:%lu:\n", GC_OPT_FLAG_NONE );

	scd_exit (0);
	}

	/* Now start with logging to a file if this is desired. */
	if (logfile)
	{
	log_set_file (logfile);
	log_set_prefix (NULL, GPGRT_LOG_WITH_PREFIX \| GPGRT_LOG_WITH_TIME \| GPGRT_LOG_WITH_PID);
	}

	if (debug_wait && pipe_server)
	{
	log_debug ("waiting for debugger - my pid is %u .....\n",
	(unsigned int)getpid());
	gnupg_sleep (debug_wait);
	log_debug ("... okay\n");
	}

	if (application_priority)
	app_update_priority_list (application_priority);

	if (pipe_server)
	{
	/* This is the simple pipe based server */
	ctrl_t ctrl;
	npth_attr_t tattr;
	int fd = -1;

	#ifndef HAVE_W32_SYSTEM
	{
	struct sigaction sa;

	sa.sa_handler = SIG_IGN;
	sigemptyset (&sa.sa_mask);
	sa.sa_flags = 0;
	sigaction (SIGPIPE, &sa, NULL);
	}
	#endif

	npth_init ();
	setup_signal_mask ();
	gpgrt_set_syscall_clamp (npth_unprotect, npth_protect);

	/* If --debug-allow-core-dump has been given we also need to
	switch the working directory to a place where we can actually
	write. */
	if (allow_coredump)
	{
	if (chdir("/tmp"))
	log_debug ("chdir to '/tmp' failed: %s\n", strerror (errno));
	else
	log_debug ("changed working directory to '/tmp'\n");
	}

	/* In multi server mode we need to listen on an additional
	socket. Create that socket now before starting the handler
	for the pipe connection. This allows that handler to send
	back the name of that socket. */
	if (multi_server)
	{
	socket_name = create_socket_name (SCDAEMON_SOCK_NAME);
	fd = FD2INT(create_server_socket (socket_name,
	&redir_socket_name, &socket_nonce));
	}

	res = npth_attr_init (&tattr);
	if (res)
	{
	log_error ("error allocating thread attributes: %s\n",
	strerror (res));
	scd_exit (2);
	}
	npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);

	ctrl = xtrycalloc (1, sizeof *ctrl);
	if ( !ctrl )
	{
	log_error ("error allocating connection control data: %s\n",
	strerror (errno) );
	scd_exit (2);
	}
	ctrl->thread_startup.fd = GNUPG_INVALID_FD;
	res = npth_create (&pipecon_handler, &tattr, start_connection_thread, ctrl);
	if (res)
	{
	log_error ("error spawning pipe connection handler: %s\n",
	strerror (res) );
	xfree (ctrl);
	scd_exit (2);
	}
	npth_setname_np (pipecon_handler, "pipe-connection");
	npth_attr_destroy (&tattr);

	/* We run handle_connection to wait for the shutdown signal and
	to run the ticker stuff. */
	handle_connections (fd);
	if (fd != -1)
	close (fd);
	}
	else if (!is_daemon)
	{
	log_info (_("please use the option '--daemon'"
	" to run the program in the background\n"));
	}
	else
	{ /* Regular server mode */
	int fd;
	#ifndef HAVE_W32_SYSTEM
	pid_t pid;
	int i;
	#endif

	/* Create the socket. */
	socket_name = create_socket_name (SCDAEMON_SOCK_NAME);
	fd = FD2INT (create_server_socket (socket_name,
	&redir_socket_name, &socket_nonce));


	fflush (NULL);
	#ifdef HAVE_W32_SYSTEM
	(void)csh_style;
	(void)nodetach;
	#else
	pid = fork ();
	if (pid == (pid_t)-1)
	{
	log_fatal ("fork failed: %s\n", strerror (errno) );
	exit (1);
	}
	else if (pid)
	{ /* we are the parent */
	char *infostr;

	close (fd);

	/* create the info string: <name>:<pid>:<protocol_version> */
	if (gpgrt_asprintf (&infostr, "SCDAEMON_INFO=%s:%lu:1",
	socket_name, (ulong) pid) < 0)
	{
	log_error ("out of core\n");
	kill (pid, SIGTERM);
	exit (1);
	}
	socket_name = 0; / don't let cleanup() remove the socket -
	the child should do this from now on */
	if (argc)
	{ /* run the program given on the commandline */
	if (putenv (infostr))
	{
	log_error ("failed to set environment: %s\n",
	strerror (errno) );
	kill (pid, SIGTERM );
	exit (1);
	}
	execvp (argv[0], argv);
	log_error ("failed to run the command: %s\n", strerror (errno));
	kill (pid, SIGTERM);
	exit (1);
	}
	else
	{
	/* Print the environment string, so that the caller can use
	shell's eval to set it */
	if (csh_style)
	{
	*strchr (infostr, '=') = ' ';
	es_printf ( "setenv %s;\n", infostr);
	}
	else
	{
	es_printf ( "%s; export SCDAEMON_INFO;\n", infostr);
	}
	xfree (infostr);
	exit (0);
	}
	/* NOTREACHED */
	} /* end parent */

	/* This is the child. */

	npth_init ();
	setup_signal_mask ();
	gpgrt_set_syscall_clamp (npth_unprotect, npth_protect);

	/* Detach from tty and put process into a new session. */
	if (!nodetach )
	{
	/* Close stdin, stdout and stderr unless it is the log stream. */
	for (i=0; i <= 2; i++)
	{
	if (!log_test_fd (i) && i != fd )
	{
	if ( !close (i)
	&& open ("/dev/null", i? O_WRONLY : O_RDONLY) == -1)
	{
	log_error ("failed to open '%s': %s\n",
	"/dev/null", strerror (errno));
	cleanup ();
	exit (1);
	}
	}
	}

	if (setsid() == -1)
	{
	log_error ("setsid() failed: %s\n", strerror(errno) );
	cleanup ();
	exit (1);
	}
	}

	{
	struct sigaction sa;

	sa.sa_handler = SIG_IGN;
	sigemptyset (&sa.sa_mask);
	sa.sa_flags = 0;
	sigaction (SIGPIPE, &sa, NULL);
	}

	#endif /!HAVE_W32_SYSTEM/

	if (gnupg_chdir (gnupg_daemon_rootdir ()))
	{
	log_error ("chdir to '%s' failed: %s\n",
	gnupg_daemon_rootdir (), strerror (errno));
	exit (1);
	}

	handle_connections (fd);

	close (fd);
	}

	return 0;
	}

	void
	scd_exit (int rc)
	{
	apdu_prepare_exit ();
	#if 0
	#warning no update_random_seed_file
	update_random_seed_file();
	#endif
	#if 0
	/* at this time a bit annoying */
	if (opt.debug & DBG_MEMSTAT_VALUE)
	{
	gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
	gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
	}
	if (opt.debug)
	gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
	#endif
	gcry_control (GCRYCTL_TERM_SECMEM );
	rc = rc? rc : log_get_errorcount(0)? 2 : 0;
	exit (rc);
	}


	static void
	scd_init_default_ctrl (ctrl_t ctrl)
	{
	(void)ctrl;
	}

	static void
	scd_deinit_default_ctrl (ctrl_t ctrl)
	{
	if (!ctrl)
	return;
	xfree (ctrl->in_data.value);
	ctrl->in_data.value = NULL;
	ctrl->in_data.valuelen = 0;
	}


	/* Return the name of the socket to be used to connect to this
	process. If no socket is available, return NULL. */
	const char *
	scd_get_socket_name ()
	{
	if (socket_name && *socket_name)
	return socket_name;
	return NULL;
	}


	#ifndef HAVE_W32_SYSTEM
	static void
	handle_signal (int signo)
	{
	switch (signo)
	{
	case SIGHUP:
	log_info ("SIGHUP received - "
	"re-reading configuration and resetting cards\n");
	/* reread_configuration (); */
	break;

	case SIGUSR1:
	log_info ("SIGUSR1 received - printing internal information:\n");
	/* Fixme: We need to see how to integrate pth dumping into our
	logging system. */
	/* pth_ctrl (PTH_CTRL_DUMPSTATE, log_get_stream ()); */
	app_dump_state ();
	break;

	case SIGUSR2:
	log_info ("SIGUSR2 received - no action defined\n");
	break;

	case SIGCONT:
	/* Nothing. */
	log_debug ("SIGCONT received - breaking select\n");
	break;

	case SIGTERM:
	if (!shutdown_pending)
	log_info ("SIGTERM received - shutting down ...\n");
	else
	log_info ("SIGTERM received - still %i running threads\n",
	active_connections);
	shutdown_pending++;
	if (shutdown_pending > 2)
	{
	log_info ("shutdown forced\n");
	log_info ("%s %s stopped\n", strusage(11), strusage(13) );
	cleanup ();
	scd_exit (0);
	}
	break;

	case SIGINT:
	log_info ("SIGINT received - immediate shutdown\n");
	log_info( "%s %s stopped\n", strusage(11), strusage(13));
	cleanup ();
	scd_exit (0);
	break;

	default:
	log_info ("signal %d received - no action defined\n", signo);
	}
	}
	#endif /!HAVE_W32_SYSTEM/


	/* Create a name for the socket. We check for valid characters as
	well as against a maximum allowed length for a unix domain socket
	is done. The function terminates the process in case of an error.
	Returns: Pointer to an allcoated string with the absolute name of
	the socket used. */
	static char *
	create_socket_name (char *standard_name)
	{
	char *name;

	name = make_filename (gnupg_socketdir (), standard_name, NULL);
	if (strchr (name, PATHSEP_C))
	{
	log_error (("'%s' are not allowed in the socket name\n"), PATHSEP_S);
	scd_exit (2);
	}
	return name;
	}



	/* Create a Unix domain socket with NAME. Returns the file descriptor
	or terminates the process in case of an error. If the socket has
	been redirected the name of the real socket is stored as a malloced
	string at R_REDIR_NAME. */
	static gnupg_fd_t
	create_server_socket (const char name, char *r_redir_name,
	assuan_sock_nonce_t *nonce)
	{
	struct sockaddr *addr;
	struct sockaddr_un *unaddr;
	socklen_t len;
	gnupg_fd_t fd;
	int rc;

	xfree (*r_redir_name);
	*r_redir_name = NULL;

	fd = assuan_sock_new (AF_UNIX, SOCK_STREAM, 0);
	if (fd == GNUPG_INVALID_FD)
	{
	log_error (_("can't create socket: %s\n"), strerror (errno));
	scd_exit (2);
	}

	unaddr = xmalloc (sizeof (*unaddr));
	addr = (struct sockaddr*)unaddr;

	{
	int redirected;

	if (assuan_sock_set_sockaddr_un (name, addr, &redirected))
	{
	if (errno == ENAMETOOLONG)
	log_error (_("socket name '%s' is too long\n"), name);
	else
	log_error ("error preparing socket '%s': %s\n",
	name, gpg_strerror (gpg_error_from_syserror ()));
	scd_exit (2);
	}
	if (redirected)
	{
	*r_redir_name = xstrdup (unaddr->sun_path);
	if (opt.verbose)
	log_info ("redirecting socket '%s' to '%s'\n", name, *r_redir_name);
	}
	}

	len = SUN_LEN (unaddr);

	rc = assuan_sock_bind (fd, addr, len);
	if (rc == -1 && errno == EADDRINUSE)
	{
	gnupg_remove (unaddr->sun_path);
	rc = assuan_sock_bind (fd, addr, len);
	}
	if (rc != -1
	&& (rc=assuan_sock_get_nonce (addr, len, nonce)))
	log_error (_("error getting nonce for the socket\n"));
	if (rc == -1)
	{
	log_error (_("error binding socket to '%s': %s\n"),
	unaddr->sun_path,
	gpg_strerror (gpg_error_from_syserror ()));
	assuan_sock_close (fd);
	scd_exit (2);
	}

	if (gnupg_chmod (unaddr->sun_path, "-rwx"))
	log_error (_("can't set permissions of '%s': %s\n"),
	unaddr->sun_path, strerror (errno));

	if (listen (FD2INT(fd), listen_backlog) == -1)
	{
	log_error ("listen(fd, %d) failed: %s\n",
	listen_backlog, gpg_strerror (gpg_error_from_syserror ()));
	assuan_sock_close (fd);
	scd_exit (2);
	}

	if (opt.verbose)
	log_info (_("listening on socket '%s'\n"), unaddr->sun_path);

	return fd;
	}



	/* This is the standard connection thread's main function. */
	static void *
	start_connection_thread (void *arg)
	{
	ctrl_t ctrl = arg;

	if (ctrl->thread_startup.fd != GNUPG_INVALID_FD
	&& assuan_sock_check_nonce (ctrl->thread_startup.fd, &socket_nonce))
	{
	log_info (_("error reading nonce on fd %d: %s\n"),
	FD2INT(ctrl->thread_startup.fd), strerror (errno));
	assuan_sock_close (ctrl->thread_startup.fd);
	xfree (ctrl);
	return NULL;
	}

	active_connections++;

	scd_init_default_ctrl (ctrl);
	if (opt.verbose)
	log_info (_("handler for fd %d started\n"),
	FD2INT(ctrl->thread_startup.fd));

	/* If this is a pipe server, we request a shutdown if the command
	handler asked for it. With the next ticker event and given that
	no other connections are running the shutdown will then
	happen. */
	if (scd_command_handler (ctrl, FD2INT(ctrl->thread_startup.fd))
	&& pipe_server)
	shutdown_pending = 1;

	if (opt.verbose)
	log_info (_("handler for fd %d terminated\n"),
	FD2INT (ctrl->thread_startup.fd));

	scd_deinit_default_ctrl (ctrl);
	xfree (ctrl);

	if (--active_connections == 0)
	scd_kick_the_loop ();

	return NULL;
	}


	void
	scd_kick_the_loop (void)
	{
	/* Kick the select loop. */
	#ifdef HAVE_W32_SYSTEM
	int ret = SetEvent (the_event);
	if (ret == 0)
	log_error ("SetEvent for scd_kick_the_loop failed: %s\n",
	w32_strerror (-1));
	#elif defined(HAVE_PSELECT_NO_EINTR)
	write (notify_fd, "", 1);
	#else
	int ret = kill (main_thread_pid, SIGCONT);
	if (ret < 0)
	log_error ("SetEvent for scd_kick_the_loop failed: %s\n",
	gpg_strerror (gpg_error_from_syserror ()));
	#endif
	}

	/* Connection handler loop. Wait for connection requests and spawn a
	thread after accepting a connection. LISTEN_FD is allowed to be -1
	in which case this code will only do regular timeouts and handle
	signals. */
	static void
	handle_connections (int listen_fd)
	{
	npth_attr_t tattr;
	struct sockaddr_un paddr;
	socklen_t plen;
	fd_set fdset, read_fdset;
	int nfd;
	int ret;
	int fd;
	struct timespec timeout;
	struct timespec *t;
	int saved_errno;
	#ifdef HAVE_W32_SYSTEM
	HANDLE events[2];
	unsigned int events_set;
	#else
	int signo;
	#endif
	#ifdef HAVE_PSELECT_NO_EINTR
	int pipe_fd[2];

	ret = gnupg_create_pipe (pipe_fd);
	if (ret)
	{
	log_error ("pipe creation failed: %s\n", gpg_strerror (ret));
	return;
	}
	notify_fd = pipe_fd[1];
	#endif

	ret = npth_attr_init(&tattr);
	if (ret)
	{
	log_error ("npth_attr_init failed: %s\n", strerror (ret));
	return;
	}

	npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);

	#ifdef HAVE_W32_SYSTEM
	{
	HANDLE h, h2;
	SECURITY_ATTRIBUTES sa = { sizeof (SECURITY_ATTRIBUTES), NULL, TRUE};

	events[0] = the_event = INVALID_HANDLE_VALUE;
	events[1] = INVALID_HANDLE_VALUE;
	h = CreateEvent (&sa, TRUE, FALSE, NULL);
	if (!h)
	log_error ("can't create scd event: %s\n", w32_strerror (-1) );
	else if (!DuplicateHandle (GetCurrentProcess(), h,
	GetCurrentProcess(), &h2,
	EVENT_MODIFY_STATE\|SYNCHRONIZE, TRUE, 0))
	{
	log_error ("setting synchronize for scd_kick_the_loop failed: %s\n",
	w32_strerror (-1) );
	CloseHandle (h);
	}
	else
	{
	CloseHandle (h);
	events[0] = the_event = h2;
	}
	}
	#endif

	FD_ZERO (&fdset);
	nfd = 0;
	if (listen_fd != -1)
	{
	FD_SET (listen_fd, &fdset);
	nfd = listen_fd;
	}

	for (;;)
	{
	int periodical_check;
	int max_fd = nfd;

	if (shutdown_pending)
	{
	if (active_connections == 0)
	break; /* ready */

	/* Do not accept anymore connections but wait for existing
	connections to terminate. We do this by clearing out all
	file descriptors to wait for, so that the select will be
	used to just wait on a signal or timeout event. */
	FD_ZERO (&fdset);
	listen_fd = -1;
	}

	periodical_check = scd_update_reader_status_file ();

	timeout.tv_sec = TIMERTICK_INTERVAL_SEC;
	timeout.tv_nsec = TIMERTICK_INTERVAL_USEC * 1000;

	if (shutdown_pending \|\| periodical_check)
	t = &timeout;
	else
	t = NULL;

	/* POSIX says that fd_set should be implemented as a structure,
	thus a simple assignment is fine to copy the entire set. */
	read_fdset = fdset;

	#ifdef HAVE_PSELECT_NO_EINTR
	FD_SET (pipe_fd[0], &read_fdset);
	if (max_fd < pipe_fd[0])
	max_fd = pipe_fd[0];
	#else
	(void)max_fd;
	#endif

	#ifndef HAVE_W32_SYSTEM
	ret = npth_pselect (max_fd+1, &read_fdset, NULL, NULL, t,
	npth_sigev_sigmask ());
	saved_errno = errno;

	while (npth_sigev_get_pending(&signo))
	handle_signal (signo);
	#else
	ret = npth_eselect (nfd+1, &read_fdset, NULL, NULL, t,
	events, &events_set);
	saved_errno = errno;
	if (events_set & 1)
	continue;
	#endif

	if (ret == -1 && saved_errno != EINTR)
	{
	log_error (_("npth_pselect failed: %s - waiting 1s\n"),
	strerror (saved_errno));
	npth_sleep (1);
	continue;
	}

	if (ret <= 0)
	/* Timeout. Will be handled when calculating the next timeout. */
	continue;

	#ifdef HAVE_PSELECT_NO_EINTR
	if (FD_ISSET (pipe_fd[0], &read_fdset))
	{
	char buf[256];

	read (pipe_fd[0], buf, sizeof buf);
	}
	#endif

	if (listen_fd != -1 && FD_ISSET (listen_fd, &read_fdset))
	{
	ctrl_t ctrl;

	plen = sizeof paddr;
	fd = npth_accept (listen_fd, (struct sockaddr *)&paddr, &plen);
	if (fd == -1)
	{
	log_error ("accept failed: %s\n", strerror (errno));
	}
	else if ( !(ctrl = xtrycalloc (1, sizeof *ctrl)) )
	{
	log_error ("error allocating connection control data: %s\n",
	strerror (errno) );
	close (fd);
	}
	else
	{
	char threadname[50];
	npth_t thread;

	snprintf (threadname, sizeof threadname, "conn fd=%d", fd);
	ctrl->thread_startup.fd = INT2FD (fd);
	ret = npth_create (&thread, &tattr, start_connection_thread, ctrl);
	if (ret)
	{
	log_error ("error spawning connection handler: %s\n",
	strerror (ret));
	xfree (ctrl);
	close (fd);
	}
	else
	npth_setname_np (thread, threadname);
	}
	}
	}

	#ifdef HAVE_W32_SYSTEM
	if (the_event != INVALID_HANDLE_VALUE)
	CloseHandle (the_event);
	#endif
	#ifdef HAVE_PSELECT_NO_EINTR
	close (pipe_fd[0]);
	close (pipe_fd[1]);
	#endif
	cleanup ();
	log_info (_("%s %s stopped\n"), strusage(11), strusage(13));
	npth_attr_destroy (&tattr);
	}

	/* Return the number of active connections. */
	int
	get_active_connection_count (void)
	{
	return active_connections;
	}

File Metadata

Mime Type: text/x-diff
Expires: Sat, May 10, 8:33 AM (1 d, 8 h)
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: 79/0b/723a813a44cc986ff15bb10c5726

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions