SCF_Card_lock(3SMARTCARD)				    Smartcard Library Functions 				 SCF_Card_lock(3SMARTCARD)

NAME

       SCF_Card_lock, SCF_Card_unlock - perform mutex locking on a card

SYNOPSIS

       cc [ flag... ] file... -lsmartcard [ library...]
       #include <smartcard/scf.h>

       SCF_Status_t SCF_Card_lock(SCF_Card_t card, unsigned int timeout);

       SCF_Status_t SCF_Card_unlock(SCF_Card_t card);

PARAMETERS

       card	       The card (from SCF_Terminal_getCard(3SMARTCARD)) to be locked.

       timeout	       The  maximum  number  of seconds SCF_Card_lock() should wait for a card locked by another application to become unlocked. A
		       value of 0 results in SCF_Card_lock() returning immediately if a lock cannot be immediately obtained. A value of  SCF_TIME-
		       OUT_MAX results in SCF_Card_lock() waiting forever to obtain a lock.

DESCRIPTION

       Locking	a  card  allows  an application to perform a multi-APDU transaction (that is, multiple calls to SCF_Card_exchangeAPDU(3SMARTCARD))
       without interference from other smartcard applications. The lock is enforced by the server, so that other applications that attempt to call
       SCF_Card_exchangeAPDU()	or SCF_Card_reset(3SMARTCARD) will be denied access to the card. Applications should restrict use of locks only to
       brief critical sections. Otherwise it becomes difficult for multiple applications to share the same card.

       When a lock is granted to a specific SCF_Card_t card object, only that object can be used to access the card and  subsquently  release  the
       lock.  If  a misbehaving application holds a lock for an extended period, the lock can be broken by having the user remove and reinsert the
       smartcard.

       It is an error to attempt to lock a card when the caller already holds a lock on the card (that is, calling SCF_Card_lock() twice in a suc-
       cession). Unlocking a card that is not locked (or was already unlocked) can be performed without causing an error.

       An  application	might  find  that  it  is  unable to lock the card, or communicate with it because SCF_Card_exchangeAPDU() keeps returning
       SCF_STATUS_CARDLOCKED. If this situation persists, it might indicate that another application has not released its lock on  the	card.  The
       user  is  able  to  forcably  break a lock by removing the card and reinserting it, after which the application must call SCF_Terminal_get-
       Card(3SMARTCARD) to access the "new" card. In this situation an application should retry for a reasonable period of time,  and  then  alert
       the  user  that the operation could not be completed because the card is in use by another application and that removing or reinserting the
       card will resolve the problem.

RETURN VALUES

       If the card is successfully locked or unlocked, SCF_STATUS_SUCCESS is returned. Otherwise, the lock status of the  card	remains  unchanged
       and an error value is returned.

ERRORS

       The SCF_Card_lock() and SCF_Card_lock() functions will fail if:

       SCF_STATUS_BADHANDLE    The specified card has been closed or is invalid.

       SCF_STATUS_CARDLOCKED   There  is  a  lock present on the card, but it is not held by the specified card object. For example, the caller is
			       attempting to unlock a card locked by another application.

       SCF_STATUS_CARDREMOVED  The card object cannot be used because the card represented by the SCF_Card_t has been removed.

       SCF_STATUS_COMMERROR    The connection to the server was lost.

       SCF_STATUS_DOUBLELOCK   The caller has already locked this card and is attempting to lock it again.

       SCF_STATUS_FAILED       An internal error occured.

       SCF_STATUS_TIMEOUT      The timeout expired before the call was able to obtain the lock.

EXAMPLES

       Example 1: Use a card lock.

       SCF_Status_t status;
       SCF_Card_t myCard;

       /* (...call SCF_Terminal_getCard to open myCard...) */

       status = SCF_Card_lock(myCard, 15);
       if (status == SCF_STATUS_TIMEOUT) {
	   printf("Unable to get a card lock, someone else has a lock.
");
	   exit(0);
       }
       else if (status != SCF_STATUS_SUCCESS) exit(1);

       /* Send the first APDU */
       SCF_Card_exchangeAPDU(myCard, ...);

       /* Send the second APDU */
       SCF_Card_exchangeAPDU(myCard, ...);

       status = SCF_Card_unlock(myCard);

       /* ... */

ATTRIBUTES

       See attributes(5) for descriptions of the following attributes:

       +-----------------------------+-----------------------------+
       |      ATTRIBUTE TYPE	     |	    ATTRIBUTE VALUE	   |
       +-----------------------------+-----------------------------+
       |Interface Stability	     |Evolving			   |
       +-----------------------------+-----------------------------+
       |MT-Level		     |MT-Safe			   |
       +-----------------------------+-----------------------------+

SEE ALSO

       libsmartcard(3LIB), SCF_Card_exchangeAPDU(3SMARTCARD), SCF_Card_reset(3SMARTCARD), SCF_Terminal_getCard(3SMARTCARD), attributes(5)

SunOS 5.10							    15 May 2002 					 SCF_Card_lock(3SMARTCARD)