trunk/Src/wptCardPCSC.c

/* wptCardPCSC.cpp - PC/SC card API interface
 *      Copyright (C) 2003 Timo Schulz
 *
 * This file is part of WinPT.
 *
 * WinPT 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 2 of the License, or
 * (at your option) any later version.
 * 
 * WinPT 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 WinPT; if not, write to the Free Software Foundation, 
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */

#include <stdio.h>
#include <windows.h>
#include <winscard.h>

#include "w32gpgme.h"
#include "wptTypes.h"
#include "wptCard.h"


#define MAX_READERS 8

struct pcsc_reader_s {
    SCARD_READERSTATE_A reader_states[MAX_READERS];
    int nreaders;
    char * readers[MAX_READERS];
};
typedef struct pcsc_reader_s *pcsc_reader_t;


static LONG (WINAPI *pcsc_establish_context) (unsigned long scope,
                                const void *reserved1,
                                const void *reserved2,
                                unsigned long *r_context);
static LONG (WINAPI *pcsc_release_context) (unsigned long context);
static LONG (WINAPI *pcsc_list_readers) (unsigned long context, 
                                         const char *groups,
                                         char *readers, 
                                         unsigned long *readerslen);
static LONG (WINAPI *pcsc_connect) (unsigned long context,
                      const char *reader,
                      unsigned long share_mode,
                      unsigned long preferred_protocols,
                      unsigned long *r_card,
                      unsigned long *r_active_protocol);
static LONG (WINAPI *pcsc_disconnect) (unsigned long card, 
                                       unsigned long disposition);
static LONG (WINAPI *pcsc_status) (unsigned long card,
                     char *reader, unsigned long *readerlen,
                     unsigned long *r_state, unsigned long *r_protocol,
                     unsigned char *atr, unsigned long *atrlen);
static LONG (WINAPI *pcsc_get_status_change)(unsigned long ctx, 
                                             unsigned long timeout,
                                             SCARD_READERSTATE * readerstate,
                                             unsigned long creaders);

static int pcsc_init = 0;


#define load_one_fnc(ptr, hlib, name) do {                          \
    a = ptr = (void *)GetProcAddress (hlib, name);                  \
    if (!a) {                                                       \
        char msg[256];                                              \
        _snprintf (msg, sizeof msg-1, "Could not load '%s'", name); \
        MessageBox (NULL, msg, "PC/SC Driver", MB_ICONERROR|MB_OK); \
        goto fail;                                                  \
    } \
} while (0)


int
pcsc_loadlib (int scard_support)
{
    HMODULE hlib;
    FARPROC a;    

    if (!scard_support || pcsc_init)
        return 0;
    hlib = LoadLibrary ("WINSCARD");
    if (!hlib)
        goto fail;
    load_one_fnc (pcsc_establish_context, hlib, "SCardEstablishContext");
    load_one_fnc (pcsc_release_context, hlib, "SCardReleaseContext");
    load_one_fnc (pcsc_list_readers, hlib, "SCardListReadersA");
    load_one_fnc (pcsc_connect, hlib, "SCardConnectA");
    load_one_fnc (pcsc_disconnect, hlib, "SCardDisconnect");
    load_one_fnc (pcsc_status, hlib, "SCardStatusA");
    load_one_fnc (pcsc_get_status_change, hlib, "SCardGetStatusChangeA");
    goto success;

fail:
    FreeLibrary (hlib);
    return -1;
success:
    pcsc_init = 1;
    FreeLibrary (hlib);
    return 0;
}


void
pcsc_free_readers (pcsc_reader_t rd)
{
    int i;

    if (!rd)
        return;

    for (i=0; i < rd->nreaders; i++)
        safe_free (rd->readers[i]);
    safe_free (rd);
}


const char *
pcsc_get_reader (pcsc_reader_t rd, int idx, int * ret_nrd)
{
    if (!rd)
        return NULL;
    if (idx == -1 && ret_nrd) {
        *ret_nrd = rd->nreaders;
        return NULL;
    }
    if (idx >= rd->nreaders)
        idx=0;
    return rd->readers[idx];
}


int
pcsc_scan_readers (pcsc_reader_t * ret_rd)
{
    pcsc_reader_t rd;
    SCARDCONTEXT hctx;
    SCARD_READERSTATE_A rdstat;
    DWORD readers;
    LPSTR rdrstr;
    char * p;
    int i;
    int rc, curr_rd=0;

    *ret_rd = NULL;
    if (!pcsc_init)
        return -1;

    rc = pcsc_establish_context (SCARD_SCOPE_SYSTEM, NULL, NULL, &hctx);
    if (rc != SCARD_S_SUCCESS)
        return -1;

    rc = pcsc_list_readers (hctx, NULL, NULL, &readers);
    if (rc != SCARD_S_SUCCESS)
        return -1;

    rdrstr = malloc (sizeof(char)*readers);
    if (!rdrstr)
        BUG (0);

    rc = pcsc_list_readers (hctx, NULL, rdrstr, &readers);
    if (rc != SCARD_S_SUCCESS) {
        safe_free (rdrstr);
        return -1;
    }

    rd = calloc (1, sizeof *rd);
    if (!rd)
        BUG (0);
        
    p = rdrstr;
    while ((*p != '\0') && (rd->nreaders < MAX_READERS)) {      
        rd->readers[rd->nreaders] = strdup (p);
        p += strlen (p)+1;
        rd->nreaders++; 
    }

    if (!rd->nreaders) {
        safe_free (rdrstr);
        safe_free (rd);
        return 0;
    }

    /* set the initial states */
    for (i=0; i<rd->nreaders; i++) {
        rd->reader_states[i].szReader = rd->readers[i];
        rd->reader_states[i].dwCurrentState = SCARD_STATE_EMPTY;
    }

    while (1) {
        rdstat = rd->reader_states[curr_rd];            
        rc = pcsc_get_status_change (hctx, 0, &rdstat, 1);
        if (rc == SCARD_E_TIMEOUT)
            continue;
        if (rc != SCARD_S_SUCCESS)
            ;

        /* next reader */
        curr_rd++;
        if (curr_rd >= rd->nreaders)
            curr_rd = 0;
    }
    
    safe_free (rdrstr);
    *ret_rd = rd;
    rc = pcsc_release_context (hctx);
    if (rc != SCARD_S_SUCCESS)
        return -1;
    return 0;
}


int
pcsc_get_card_status (void)
{
    pcsc_reader_t rd;
    SCARD_READERSTATE_A rdstat;
    int rc, stat=0;

    rc = pcsc_scan_readers (&rd);
    if (rc)
        return -1;
    rdstat = rd->reader_states[0];
    if (rdstat.dwCurrentState & SCARD_STATE_UNAVAILABLE)
        stat |= CARD_STATE_UNAVAIL;
    if (rdstat.dwCurrentState & SCARD_STATE_EMPTY)
        stat |= CARD_STATE_EMPTY;
    if (rdstat.dwCurrentState & SCARD_STATE_INUSE)
        stat |= CARD_STATE_INUSE;
    if (rdstat.dwCurrentState & SCARD_STATE_EXCLUSIVE)
        stat |= CARD_STATE_EXCLUSI;
    return stat;
}
1	/* wptCardPCSC.cpp - PC/SC card API interface
2	* Copyright (C) 2003 Timo Schulz
3	*
4	* This file is part of WinPT.
5	*
6	* WinPT is free software; you can redistribute it and/or modify
7	* it under the terms of the GNU General Public License as published by
8	* the Free Software Foundation; either version 2 of the License, or
9	* (at your option) any later version.
10	*
11	* WinPT is distributed in the hope that it will be useful,
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	* GNU General Public License for more details.
15	*
16	* You should have received a copy of the GNU General Public License
17	* along with WinPT; if not, write to the Free Software Foundation,
18	* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19	*/
20
21	#include <stdio.h>
22	#include <windows.h>
23	#include <winscard.h>
24
25	#include "w32gpgme.h"
26	#include "wptTypes.h"
27	#include "wptCard.h"
28
29
30	#define MAX_READERS 8
31
32	struct pcsc_reader_s {
33	SCARD_READERSTATE_A reader_states[MAX_READERS];
34	int nreaders;
35	char * readers[MAX_READERS];
36	};
37	typedef struct pcsc_reader_s *pcsc_reader_t;
38
39
40	static LONG (WINAPI *pcsc_establish_context) (unsigned long scope,
41	const void *reserved1,
42	const void *reserved2,
43	unsigned long *r_context);
44	static LONG (WINAPI *pcsc_release_context) (unsigned long context);
45	static LONG (WINAPI *pcsc_list_readers) (unsigned long context,
46	const char *groups,
47	char *readers,
48	unsigned long *readerslen);
49	static LONG (WINAPI *pcsc_connect) (unsigned long context,
50	const char *reader,
51	unsigned long share_mode,
52	unsigned long preferred_protocols,
53	unsigned long *r_card,
54	unsigned long *r_active_protocol);
55	static LONG (WINAPI *pcsc_disconnect) (unsigned long card,
56	unsigned long disposition);
57	static LONG (WINAPI *pcsc_status) (unsigned long card,
58	char reader, unsigned long readerlen,
59	unsigned long r_state, unsigned long r_protocol,
60	unsigned char atr, unsigned long atrlen);
61	static LONG (WINAPI *pcsc_get_status_change)(unsigned long ctx,
62	unsigned long timeout,
63	SCARD_READERSTATE * readerstate,
64	unsigned long creaders);
65
66	static int pcsc_init = 0;
67
68
69	#define load_one_fnc(ptr, hlib, name) do { \
70	a = ptr = (void *)GetProcAddress (hlib, name); \
71	if (!a) { \
72	char msg[256]; \
73	_snprintf (msg, sizeof msg-1, "Could not load '%s'", name); \
74	MessageBox (NULL, msg, "PC/SC Driver", MB_ICONERROR\|MB_OK); \
75	goto fail; \
76	} \
77	} while (0)
78
79
80	int
81	pcsc_loadlib (int scard_support)
82	{
83	HMODULE hlib;
84	FARPROC a;
85
86	if (!scard_support \|\| pcsc_init)
87	return 0;
88	hlib = LoadLibrary ("WINSCARD");
89	if (!hlib)
90	goto fail;
91	load_one_fnc (pcsc_establish_context, hlib, "SCardEstablishContext");
92	load_one_fnc (pcsc_release_context, hlib, "SCardReleaseContext");
93	load_one_fnc (pcsc_list_readers, hlib, "SCardListReadersA");
94	load_one_fnc (pcsc_connect, hlib, "SCardConnectA");
95	load_one_fnc (pcsc_disconnect, hlib, "SCardDisconnect");
96	load_one_fnc (pcsc_status, hlib, "SCardStatusA");
97	load_one_fnc (pcsc_get_status_change, hlib, "SCardGetStatusChangeA");
98	goto success;
99
100	fail:
101	FreeLibrary (hlib);
102	return -1;
103	success:
104	pcsc_init = 1;
105	FreeLibrary (hlib);
106	return 0;
107	}
108
109
110	void
111	pcsc_free_readers (pcsc_reader_t rd)
112	{
113	int i;
114
115	if (!rd)
116	return;
117
118	for (i=0; i < rd->nreaders; i++)
119	safe_free (rd->readers[i]);
120	safe_free (rd);
121	}
122
123
124	const char *
125	pcsc_get_reader (pcsc_reader_t rd, int idx, int * ret_nrd)
126	{
127	if (!rd)
128	return NULL;
129	if (idx == -1 && ret_nrd) {
130	*ret_nrd = rd->nreaders;
131	return NULL;
132	}
133	if (idx >= rd->nreaders)
134	idx=0;
135	return rd->readers[idx];
136	}
137
138
139	int
140	pcsc_scan_readers (pcsc_reader_t * ret_rd)
141	{
142	pcsc_reader_t rd;
143	SCARDCONTEXT hctx;
144	SCARD_READERSTATE_A rdstat;
145	DWORD readers;
146	LPSTR rdrstr;
147	char * p;
148	int i;
149	int rc, curr_rd=0;
150
151	*ret_rd = NULL;
152	if (!pcsc_init)
153	return -1;
154
155	rc = pcsc_establish_context (SCARD_SCOPE_SYSTEM, NULL, NULL, &hctx);
156	if (rc != SCARD_S_SUCCESS)
157	return -1;
158
159	rc = pcsc_list_readers (hctx, NULL, NULL, &readers);
160	if (rc != SCARD_S_SUCCESS)
161	return -1;
162
163	rdrstr = malloc (sizeof(char)*readers);
164	if (!rdrstr)
165	BUG (0);
166
167	rc = pcsc_list_readers (hctx, NULL, rdrstr, &readers);
168	if (rc != SCARD_S_SUCCESS) {
169	safe_free (rdrstr);
170	return -1;
171	}
172
173	rd = calloc (1, sizeof *rd);
174	if (!rd)
175	BUG (0);
176
177	p = rdrstr;
178	while ((*p != '\0') && (rd->nreaders < MAX_READERS)) {
179	rd->readers[rd->nreaders] = strdup (p);
180	p += strlen (p)+1;
181	rd->nreaders++;
182	}
183
184	if (!rd->nreaders) {
185	safe_free (rdrstr);
186	safe_free (rd);
187	return 0;
188	}
189
190	/* set the initial states */
191	for (i=0; i<rd->nreaders; i++) {
192	rd->reader_states[i].szReader = rd->readers[i];
193	rd->reader_states[i].dwCurrentState = SCARD_STATE_EMPTY;
194	}
195
196	while (1) {
197	rdstat = rd->reader_states[curr_rd];
198	rc = pcsc_get_status_change (hctx, 0, &rdstat, 1);
199	if (rc == SCARD_E_TIMEOUT)
200	continue;
201	if (rc != SCARD_S_SUCCESS)
202	;
203
204	/* next reader */
205	curr_rd++;
206	if (curr_rd >= rd->nreaders)
207	curr_rd = 0;
208	}
209
210	safe_free (rdrstr);
211	*ret_rd = rd;
212	rc = pcsc_release_context (hctx);
213	if (rc != SCARD_S_SUCCESS)
214	return -1;
215	return 0;
216	}
217
218
219	int
220	pcsc_get_card_status (void)
221	{
222	pcsc_reader_t rd;
223	SCARD_READERSTATE_A rdstat;
224	int rc, stat=0;
225
226	rc = pcsc_scan_readers (&rd);
227	if (rc)
228	return -1;
229	rdstat = rd->reader_states[0];
230	if (rdstat.dwCurrentState & SCARD_STATE_UNAVAILABLE)
231	stat \|= CARD_STATE_UNAVAIL;
232	if (rdstat.dwCurrentState & SCARD_STATE_EMPTY)
233	stat \|= CARD_STATE_EMPTY;
234	if (rdstat.dwCurrentState & SCARD_STATE_INUSE)
235	stat \|= CARD_STATE_INUSE;
236	if (rdstat.dwCurrentState & SCARD_STATE_EXCLUSIVE)
237	stat \|= CARD_STATE_EXCLUSI;
238	return stat;
239	}