jh163888/xrdp
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

chansrv: work on smartcard

Browse Source
This commit is contained in:
Jay Sorg 2013-09-08 14:22:53 -07:00
parent d22b8b5ed0
commit a9f37229ac
6 changed files with 418 additions and 146 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
sesman/chansrv/devredir.c
View File

@ -587,53 +587,50 @@ void dev_redir_proc_client_core_cap_resp(struct stream *s)
tui16 cap_type; tui16 cap_type;
tui16 cap_len; tui16 cap_len;
tui32 cap_version; tui32 cap_version;
char* holdp;
xstream_rd_u16_le(s, num_caps); xstream_rd_u16_le(s, num_caps);
xstream_seek(s, 2); /* padding */ xstream_seek(s, 2); /* padding */
for (i = 0; i < num_caps; i++) for (i = 0; i < num_caps; i++)
{ {
holdp = s->p;
xstream_rd_u16_le(s, cap_type); xstream_rd_u16_le(s, cap_type);
xstream_rd_u16_le(s, cap_len); xstream_rd_u16_le(s, cap_len);
xstream_rd_u32_le(s, cap_version); xstream_rd_u32_le(s, cap_version);
/* remove header length and version */
cap_len -= 8;
switch (cap_type) switch (cap_type)
{ {
case CAP_GENERAL_TYPE: case CAP_GENERAL_TYPE:
log_debug("got CAP_GENERAL_TYPE"); log_debug("got CAP_GENERAL_TYPE");
xstream_seek(s, cap_len);
break; break;
case CAP_PRINTER_TYPE: case CAP_PRINTER_TYPE:
log_debug("got CAP_PRINTER_TYPE"); log_debug("got CAP_PRINTER_TYPE");
g_is_printer_redir_supported = 1; g_is_printer_redir_supported = 1;
xstream_seek(s, cap_len);
break; break;
case CAP_PORT_TYPE: case CAP_PORT_TYPE:
log_debug("got CAP_PORT_TYPE"); log_debug("got CAP_PORT_TYPE");
g_is_port_redir_supported = 1; g_is_port_redir_supported = 1;
xstream_seek(s, cap_len);
break; break;
case CAP_DRIVE_TYPE: case CAP_DRIVE_TYPE:
log_debug("got CAP_DRIVE_TYPE"); log_debug("got CAP_DRIVE_TYPE");
g_is_drive_redir_supported = 1; g_is_drive_redir_supported = 1;
if (cap_version == 2) if (cap_version == 2)
{
g_drive_redir_version = 2; g_drive_redir_version = 2;
xstream_seek(s, cap_len); }
break; break;
case CAP_SMARTCARD_TYPE: case CAP_SMARTCARD_TYPE:
log_debug("got CAP_SMARTCARD_TYPE"); log_debug("got CAP_SMARTCARD_TYPE");
g_is_smartcard_redir_supported = 1; g_is_smartcard_redir_supported = 1;
scard_init(); scard_init();
xstream_seek(s, cap_len);
break; break;
} }
s->p = holdp + cap_len;
} }
} }

1
sesman/chansrv/irp.h
View File

@ -52,6 +52,7 @@ struct irp
void (*callback)(struct stream *s, IRP *irp, tui32 DeviceId, void (*callback)(struct stream *s, IRP *irp, tui32 DeviceId,
tui32 CompletionId, tui32 IoStatus); tui32 CompletionId, tui32 IoStatus);
void *user_data;
}; };
IRP * APP_CC devredir_irp_new(void); IRP * APP_CC devredir_irp_new(void);

112
sesman/chansrv/smartcard.c
View File

@ -137,13 +137,58 @@ extern tui32 g_completion_id;
extern int g_rdpdr_chan_id; /* in chansrv.c */ extern int g_rdpdr_chan_id; /* in chansrv.c */
/* forward declarations specific to this file */ /* forward declarations specific to this file */
static void scard_send_EstablishContext(IRP *irp); static void scard_send_EstablishContext(IRP *irp, int scope);
static void scard_send_ListReaders(IRP *irp, int wide); static void scard_send_ListReaders(IRP *irp, int wide);
static struct stream *scard_make_new_ioctl(IRP *irp, tui32 ioctl); static struct stream *scard_make_new_ioctl(IRP *irp, tui32 ioctl);
static int scard_add_new_device(tui32 device_id); static int scard_add_new_device(tui32 device_id);
static int scard_get_free_slot(void); static int scard_get_free_slot(void);
static void scard_release_resources(void); static void scard_release_resources(void);
static tui32 g_device_id = 0;
static int g_scard_index = 0;
/*****************************************************************************/
int APP_CC
scard_send_irp_establish_context(struct trans *con, int scope)
{
IRP *irp;
if ((irp = devredir_irp_new()) == NULL)
{
log_error("system out of memory");
return 1;
}
irp->scard_index = g_scard_index;
irp->CompletionId = g_completion_id++;
irp->DeviceId = g_device_id;
irp->callback = scard_handle_EstablishContext_Return;
irp->user_data = con;
scard_send_EstablishContext(irp, scope);
log_debug("leaving");
return 0;
}
/*****************************************************************************/
int APP_CC
scard_send_irp_list_readers(struct trans *con)
{
IRP *irp;
if ((irp = devredir_irp_new()) == NULL)
{
log_error("system out of memory");
return 1;
}
irp->scard_index = g_scard_index;
irp->CompletionId = g_completion_id++;
irp->DeviceId = g_device_id;
irp->callback = scard_handle_ListReaders_Return;
irp->user_data = con;
scard_send_ListReaders(irp, 1);
log_debug("leaving");
return 0;
}
/****************************************************************************** /******************************************************************************
** non static functions ** ** non static functions **
******************************************************************************/ ******************************************************************************/
@ -151,38 +196,24 @@ static void scard_release_resources(void);
void APP_CC void APP_CC
scard_device_announce(tui32 device_id) scard_device_announce(tui32 device_id)
{ {
IRP *irp;
log_debug("entered: device_id=%d", device_id); log_debug("entered: device_id=%d", device_id);
if (g_smartcards_inited)
if (!g_smartcards_inited)
{ {
g_memset(&smartcards, 0, sizeof(smartcards));
g_smartcards_inited = 1;
}
if ((irp = devredir_irp_new()) == NULL)
{
log_error("system out of memory");
return; return;
} }
g_memset(&smartcards, 0, sizeof(smartcards));
irp->scard_index = scard_add_new_device(device_id); g_smartcards_inited = 1;
if (irp->scard_index < 0) g_device_id = device_id;
g_scard_index = scard_add_new_device(device_id);
if (g_scard_index < 0)
{ {
log_debug("NOT adding smartcard with DeviceId=%d to list", device_id); log_debug("scard_add_new_device failed with DeviceId=%d", g_device_id);
devredir_irp_delete(irp);
return;
} }
else
log_debug("added smartcard with DeviceId=%d to list", device_id); {
log_debug("added smartcard with DeviceId=%d to list", g_device_id);
irp->CompletionId = g_completion_id++; }
irp->DeviceId = device_id; //scard_send_establish_context();
irp->callback = scard_handle_EstablishContext_Return;
scard_send_EstablishContext(irp);
log_debug("leaving");
} }
/****************************************************************************** /******************************************************************************
@ -239,13 +270,19 @@ scard_handle_EstablishContext_Return(struct stream *s, IRP *irp,
g_hexdump(sc->Context, sc->Context_len); g_hexdump(sc->Context, sc->Context_len);
} }
irp->callback = scard_handle_ListReaders_Return; //irp->callback = scard_handle_ListReaders_Return;
scard_send_ListReaders(irp, 1); //scard_send_ListReaders(irp, 1);
scard_function_establish_context_return((struct trans *) (irp->user_data),
((int*)(sc->Context))[0]);
devredir_irp_delete(irp);
/* LK_TODO need to delete IRP */ /* LK_TODO need to delete IRP */
log_debug("leaving"); log_debug("leaving");
} }
/******************************************************************************/
void APP_CC void APP_CC
scard_handle_ListReaders_Return(struct stream *s, IRP *irp, scard_handle_ListReaders_Return(struct stream *s, IRP *irp,
tui32 DeviceId, tui32 CompletionId, tui32 DeviceId, tui32 CompletionId,
@ -272,9 +309,12 @@ scard_handle_ListReaders_Return(struct stream *s, IRP *irp,
/* get OutputBufferLen */ /* get OutputBufferLen */
xstream_rd_u32_le(s, len); xstream_rd_u32_le(s, len);
scard_function_get_readers_state_return((struct trans *) (irp->user_data),
s, len);
/* LK_TODO */ /* LK_TODO */
log_debug("dumping %d bytes", len); //log_debug("dumping %d bytes", len);
g_hexdump(s->p, len); //g_hexdump(s->p, len);
log_debug("leaving"); log_debug("leaving");
} }
@ -288,17 +328,20 @@ scard_handle_ListReaders_Return(struct stream *s, IRP *irp,
*****************************************************************************/ *****************************************************************************/
static void APP_CC static void APP_CC
scard_send_EstablishContext(IRP *irp) scard_send_EstablishContext(IRP *irp, int scope)
{ {
struct stream *s; struct stream *s;
int bytes; int bytes;
if ((s = scard_make_new_ioctl(irp, SCARD_IOCTL_ESTABLISH_CONTEXT)) == NULL) if ((s = scard_make_new_ioctl(irp, SCARD_IOCTL_ESTABLISH_CONTEXT)) == NULL)
{
log_error("scard_make_new_ioctl failed");
return; return;
}
xstream_wr_u32_le(s, 0x08); /* len */ xstream_wr_u32_le(s, 0x08); /* len */
xstream_wr_u32_le(s, 0); /* unused */ xstream_wr_u32_le(s, 0); /* unused */
xstream_wr_u32_le(s, SCARD_SCOPE_SYSTEM); /* Ioctl specific data */ xstream_wr_u32_le(s, scope); /* Ioctl specific data */
xstream_wr_u32_le(s, 0); /* don't know what this is, */ xstream_wr_u32_le(s, 0); /* don't know what this is, */
/* but Win7 is sending it */ /* but Win7 is sending it */
/* get stream len */ /* get stream len */
@ -476,7 +519,10 @@ scard_add_new_device(tui32 device_id)
SMARTCARD *sc; SMARTCARD *sc;
if ((index = scard_get_free_slot()) < 0) if ((index = scard_get_free_slot()) < 0)
{
log_error("scard_get_free_slot failed");
return -1; return -1;
}
if ((sc = g_malloc(sizeof(SMARTCARD), 1)) == NULL) if ((sc = g_malloc(sizeof(SMARTCARD), 1)) == NULL)
{ {

6
sesman/chansrv/smartcard.h
View File

@ -26,6 +26,7 @@
#include "parse.h" #include "parse.h"
#include "irp.h" #include "irp.h"
#include "trans.h"
/* forward declarations */ /* forward declarations */
void scard_device_announce(tui32 device_id); void scard_device_announce(tui32 device_id);
@ -48,4 +49,9 @@ scard_init(void);
int APP_CC int APP_CC
scard_deinit(void); scard_deinit(void);
int APP_CC
scard_send_irp_establish_context(struct trans *con, int scope);
int APP_CC
scard_send_irp_list_readers(struct trans *con);
#endif /* end #ifndef _SMARTCARD_C */ #endif /* end #ifndef _SMARTCARD_C */

426
sesman/chansrv/smartcard_pcsc.c
View File

@ -20,11 +20,11 @@
/* /*
* smartcard redirection support, PCSC daemon standin * smartcard redirection support, PCSC daemon standin
* this will act like pcsc daemon * this will act like pcsc daemon
* pcsc lib and daemon write struct on unix domain socket for communication
*/ */
#define PCSC_STANDIN 1 #define PCSC_STANDIN 1
#include "chansrv.h"
#include "os_calls.h" #include "os_calls.h"
#include "smartcard.h" #include "smartcard.h"
#include "log.h" #include "log.h"
@ -34,48 +34,37 @@
#if PCSC_STANDIN #if PCSC_STANDIN
/* module based logging */ #define LLOG_LEVEL 11
#define LOG_ERROR 0 #define LLOGLN(_level, _args) \
#define LOG_INFO 1 do \
#define LOG_DEBUG 2 { \
#define LOG_LEVEL LOG_ERROR if (_level < LLOG_LEVEL) \
{ \
g_write("chansrv:smartcard [%10.10u]: ", g_time3()); \
g_writeln _args ; \
} \
} \
while (0)
#define log_error(_params...) \ /* using pcsc-lite-1.7.4 */
{ \
g_write("[%10.10u]: PCSC %s: %d : ERROR: ", \
g_time3(), __func__, __LINE__); \
g_writeln (_params); \
}
#define log_always(_params...) \ struct establish_struct
{ \ {
g_write("[%10.10u]: PCSC %s: %d : ALWAYS: ", \ tui32 dwScope;
g_time3(), __func__, __LINE__); \ tui32 hContext;
g_writeln (_params); \ tui32 rv;
} };
#define log_info(_params...) \ struct release_struct
{ \ {
if (LOG_INFO <= LOG_LEVEL) \ tui32 hContext;
{ \ tui32 rv;
g_write("[%10.10u]: PCSC %s: %d : ", \ };
g_time3(), __func__, __LINE__); \
g_writeln (_params); \
} \
}
#define log_debug(_params...) \ /** Major version of the current message protocol */
{ \ #define PROTOCOL_VERSION_MAJOR 4
if (LOG_DEBUG <= LOG_LEVEL) \ /** Minor version of the current message protocol */
{ \ #define PROTOCOL_VERSION_MINOR 2
g_write("[%10.10u]: PCSC %s: %d : ", \
g_time3(), __func__, __LINE__); \
g_writeln (_params); \
} \
}
#define PCSCLITE_MSG_KEY_LEN 16
#define PCSCLITE_MAX_MESSAGE_SIZE 2048
struct version_struct struct version_struct
{ {
@ -83,25 +72,42 @@ struct version_struct
tsi32 minor; /**< IPC minor \ref PROTOCOL_VERSION_MINOR */ tsi32 minor; /**< IPC minor \ref PROTOCOL_VERSION_MINOR */
tui32 rv; tui32 rv;
}; };
typedef struct version_struct version_struct;
struct rxSharedSegment #define SCARD_S_SUCCESS 0x00000000 /**< No error was encountered. */
#define SCARD_F_INTERNAL_ERROR 0x80100001 /**< An internal consistency
* check failed. */
#define SCARD_E_TIMEOUT 0x8010000A /**< The user-specified timeout
* value has expired. */
#define MAX_READERNAME 100
#define MAX_ATR_SIZE 33
struct pubReaderStatesList
{ {
tui32 mtype; /** one of the \c pcsc_adm_commands */ char readerName[MAX_READERNAME]; /**< reader name */
tui32 user_id; tui32 eventCounter; /**< number of card events */
tui32 group_id; tui32 readerState; /**< SCARD_* bit field */
tui32 command; /** one of the \c pcsc_msg_commands */ tsi32 readerSharing; /**< PCSCLITE_SHARING_* sharing status */
tui64 date; tui8 cardAtr[MAX_ATR_SIZE]; /**< ATR */
tui8 key[PCSCLITE_MSG_KEY_LEN]; /* 16 bytes */ tui32 cardAtrLength; /**< ATR length */
union _u tui32 cardProtocol; /**< SCARD_PROTOCOL_* value */
{
tui8 data[PCSCLITE_MAX_MESSAGE_SIZE];
struct version_struct veStr;
} u;
}; };
typedef struct rxSharedSegment sharedSegmentMsg, *psharedSegmentMsg;
#define RXSHAREDSEGMENT_BYTES 2088 #define PCSCLITE_MAX_READERS_CONTEXTS 16
static struct pubReaderStatesList
g_reader_states[PCSCLITE_MAX_READERS_CONTEXTS];
struct wait_reader_state_change
{
tui32 timeOut; /**< timeout in ms */
tui32 rv;
};
#define XRDP_PCSC_STATE_NONE 0
#define XRDP_PCSC_STATE_GOT_RSC 1
static int g_xrdp_pcsc_state = XRDP_PCSC_STATE_NONE;
extern int g_display_num; /* in chansrv.c */ extern int g_display_num; /* in chansrv.c */
@ -116,15 +122,15 @@ static struct pcsc_client *g_tail = 0;
static struct trans *g_lis = 0; static struct trans *g_lis = 0;
static struct trans *g_con = 0; /* todo, remove this */ static struct trans *g_con = 0; /* todo, remove this */
static char g_pcsclite_ipc_dir[256] = "";
static char g_pcsc_directory[256] = ""; static int g_pub_file_fd = 0;
static char g_pub_file_name[256] = "";
/*****************************************************************************/ /*****************************************************************************/
int APP_CC int APP_CC
scard_pcsc_get_wait_objs(tbus *objs, int *count, int *timeout) scard_pcsc_get_wait_objs(tbus *objs, int *count, int *timeout)
{ {
log_debug("scard_pcsc_get_wait_objs"); LLOGLN(0, ("scard_pcsc_get_wait_objs"));
if (g_lis != 0) if (g_lis != 0)
{ {
trans_get_wait_objs(g_lis, objs, count); trans_get_wait_objs(g_lis, objs, count);
@ -140,8 +146,7 @@ scard_pcsc_get_wait_objs(tbus *objs, int *count, int *timeout)
int APP_CC int APP_CC
scard_pcsc_check_wait_objs(void) scard_pcsc_check_wait_objs(void)
{ {
log_debug("scard_pcsc_check_wait_objs"); LLOGLN(0, ("scard_pcsc_check_wait_objs"));
if (g_lis != 0) if (g_lis != 0)
{ {
trans_check_wait_objs(g_lis); trans_check_wait_objs(g_lis);
@ -156,34 +161,218 @@ scard_pcsc_check_wait_objs(void)
/*****************************************************************************/ /*****************************************************************************/
/* returns error */ /* returns error */
int APP_CC int APP_CC
scard_process_version(psharedSegmentMsg msg) scard_process_establish_context(struct trans *con, struct stream *in_s)
{ {
struct establish_struct in_es;
LLOGLN(0, ("scard_process_establish_context:"));
in_uint8a(in_s, &in_es, sizeof(in_es));
LLOGLN(0, ("scard_process_establish_context: dwScope 0x%8.8x",
in_es.dwScope));
scard_send_irp_establish_context(con, in_es.dwScope);
return 0; return 0;
} }
/*****************************************************************************/ /*****************************************************************************/
/* returns error */ /* returns error */
int APP_CC int APP_CC
scard_process_msg(struct stream *s) scard_function_establish_context_return(struct trans *con, int context)
{
struct establish_struct out_es;
struct stream *out_s;
LLOGLN(0, ("scard_function_establish_context_return: context %d",
context));
out_es.dwScope = 0;
out_es.hContext = context;
out_es.rv = SCARD_S_SUCCESS;
out_s = trans_get_out_s(con, 8192);
out_uint8a(out_s, &out_es, sizeof(out_es));
s_mark_end(out_s);
return trans_force_write(con);
}
/*****************************************************************************/
/* returns error */
int APP_CC
scard_proess_release_context(struct stream *in_s)
{
struct release_struct in_rs;
struct release_struct out_rs;
struct stream *out_s;
LLOGLN(0, ("scard_proess_release_context:"));
in_uint8a(in_s, &in_rs, sizeof(in_rs));
LLOGLN(0, ("scard_proess_release_context: hContext %d", in_rs.hContext));
out_rs.hContext = in_rs.hContext;
out_rs.rv = SCARD_S_SUCCESS;
out_s = trans_get_out_s(g_con, 8192);
out_uint8a(out_s, &out_rs, sizeof(out_rs));
s_mark_end(out_s);
return trans_force_write(g_con);
}
/*****************************************************************************/
/* returns error */
int APP_CC
scard_process_version(struct trans *con, struct stream *in_s)
{
struct stream *out_s;
struct version_struct in_version;
struct version_struct out_version;
LLOGLN(0, ("scard_process_version:"));
in_uint8a(in_s, &in_version, sizeof(in_version));
/* todo: check if version is compatible */
LLOGLN(0, ("scard_process_version: version major %d minor %d",
in_version.major, in_version.minor));
out_s = trans_get_out_s(con, 8192);
out_version.major = PROTOCOL_VERSION_MAJOR;
out_version.minor = PROTOCOL_VERSION_MINOR;
out_version.rv = SCARD_S_SUCCESS;
out_uint8a(out_s, &out_version, sizeof(out_version));
s_mark_end(out_s);
return trans_force_write(con);
}
/*****************************************************************************/
/* returns error */
int APP_CC
scard_process_get_readers_state(struct stream *in_s)
{
LLOGLN(0, ("scard_process_get_readers_state:"));
scard_send_irp_list_readers(g_con);
return 0;
}
/*****************************************************************************/
/* returns error */
int APP_CC
scard_function_get_readers_state_return(struct trans *con,
struct stream *in_s,
int len)
{
struct stream *out_s;
g_hexdump(in_s->p, len);
out_s = trans_get_out_s(con, 8192);
out_uint8a(out_s, g_reader_states, sizeof(g_reader_states));
s_mark_end(out_s);
return trans_force_write(con);
}
/*****************************************************************************/
/* callback from chansrv when timeout occurs */
void DEFAULT_CC
scard_read_state_chage_timeout(void* data)
{
struct trans *con;
struct stream *out_s;
struct wait_reader_state_change out_rsc;
LLOGLN(0, ("scard_read_state_chage_timeout:"));
con = (struct trans *) data;
if (g_xrdp_pcsc_state & XRDP_PCSC_STATE_GOT_RSC)
{
out_s = trans_get_out_s(con, 8192);
out_rsc.timeOut = 0;
out_rsc.rv = SCARD_S_SUCCESS;
out_uint8a(out_s, &out_rsc, sizeof(out_rsc));
g_xrdp_pcsc_state &= ~XRDP_PCSC_STATE_GOT_RSC;
s_mark_end(out_s);
trans_force_write(con);
}
else
{
LLOGLN(0, ("scard_read_state_chage_timeout: already stopped"));
}
}
/*****************************************************************************/
/* returns error */
int APP_CC
scard_process_read_state_change(struct trans *con, struct stream *in_s)
{
struct wait_reader_state_change in_rsc;
struct stream *out_s;
LLOGLN(0, ("scard_process_read_state_change:"));
in_uint8a(in_s, &in_rsc, sizeof(in_rsc));
g_xrdp_pcsc_state |= XRDP_PCSC_STATE_GOT_RSC;
LLOGLN(0, ("scard_process_read_state_change: timeout %d rv %d",
in_rsc.timeOut, in_rsc.rv));
add_timeout(in_rsc.timeOut, scard_read_state_chage_timeout, con);
return 0;
}
/*****************************************************************************/
/* returns error */
int APP_CC
scard_process_stop_read_state_change(struct stream *in_s)
{
struct wait_reader_state_change in_rsc;
struct wait_reader_state_change out_rsc;
struct stream *out_s;
LLOGLN(0, ("scard_process_stop_read_state_change:"));
in_uint8a(in_s, &in_rsc, sizeof(in_rsc));
LLOGLN(0, ("scard_process_stop_read_state_change: timeout %d rv %d",
in_rsc.timeOut, in_rsc.rv));
if (g_xrdp_pcsc_state & XRDP_PCSC_STATE_GOT_RSC)
{
out_s = trans_get_out_s(g_con, 8192);
out_rsc.timeOut = in_rsc.timeOut;
out_rsc.rv = SCARD_S_SUCCESS;
out_uint8a(out_s, &out_rsc, sizeof(out_rsc));
g_xrdp_pcsc_state &= ~XRDP_PCSC_STATE_GOT_RSC;
s_mark_end(out_s);
return trans_force_write(g_con);
}
else
{
LLOGLN(0, ("scard_process_stop_read_state_change: already stopped"));
}
return 0;
}
/*****************************************************************************/
/* returns error */
int APP_CC
scard_process_msg(struct trans *con, struct stream *in_s, int command)
{ {
sharedSegmentMsg msg;
int rv; int rv;
g_memset(&msg, 0, sizeof(msg)); LLOGLN(0, ("scard_process_msg: command 0x%4.4x", command));
in_uint32_le(s, msg.mtype);
in_uint32_le(s, msg.user_id);
in_uint32_le(s, msg.group_id);
in_uint32_le(s, msg.command);
in_uint64_le(s, msg.date);
log_debug("scard_process_msg: mtype 0x%2.2x command 0x%2.2x",
msg.mtype, msg.command);
rv = 0; rv = 0;
switch (msg.mtype) switch (command)
{ {
case 0xF8: /* CMD_VERSION */ case 0x01: /* SCARD_ESTABLISH_CONTEXT */
rv = scard_process_version(&msg); LLOGLN(0, ("scard_process_msg: SCARD_ESTABLISH_CONTEXT"));
rv = scard_process_establish_context(con, in_s);
break;
case 0x02: /* SCARD_RELEASE_CONTEXT */
LLOGLN(0, ("scard_process_msg: SCARD_RELEASE_CONTEXT"));
rv = scard_proess_release_context(in_s);
break;
case 0x11: /* CMD_VERSION */
LLOGLN(0, ("scard_process_msg: CMD_VERSION"));
rv = scard_process_version(con, in_s);
break;
case 0x12: /* CMD_GET_READERS_STATE */
LLOGLN(0, ("scard_process_msg: CMD_GET_READERS_STATE"));
rv = scard_process_get_readers_state(in_s);
break;
case 0x13: /* CMD_WAIT_READER_STATE_CHANGE */
LLOGLN(0, ("scard_process_msg: CMD_WAIT_READER_STATE_CHANGE"));
rv = scard_process_read_state_change(con, in_s);
break;
case 0x14: /* CMD_STOP_WAITING_READER_STATE_CHANGE */
LLOGLN(0, ("scard_process_msg: CMD_STOP_WAITING_READER_STATE_CHANGE"));
rv = scard_process_stop_read_state_change(in_s);
break;
default:
LLOGLN(0, ("scard_process_msg: unknown mtype 0x%4.4x", command));
rv = 1;
break; break;
} }
return rv; return rv;
@ -197,22 +386,27 @@ my_pcsc_trans_data_in(struct trans *trans)
struct stream *s; struct stream *s;
int id; int id;
int size; int size;
int command;
int error; int error;
log_debug("my_pcsc_trans_data_in:"); LLOGLN(0, ("my_pcsc_trans_data_in:"));
if (trans == 0) if (trans == 0)
{ {
return 0; return 0;
} }
if (trans != g_con) if (trans != g_con)
{ {
return 1; return 1;
} }
s = trans_get_in_s(trans); s = trans_get_in_s(trans);
g_hexdump(s->p, 64); in_uint32_le(s, size);
error = scard_process_msg(s); in_uint32_le(s, command);
LLOGLN(0, ("my_pcsc_trans_data_in: size %d command %d", size, command));
error = trans_force_read(trans, size);
if (error == 0)
{
error = scard_process_msg(g_con, s, command);
}
return error; return error;
} }
@ -221,7 +415,7 @@ my_pcsc_trans_data_in(struct trans *trans)
int DEFAULT_CC int DEFAULT_CC
my_pcsc_trans_conn_in(struct trans *trans, struct trans *new_trans) my_pcsc_trans_conn_in(struct trans *trans, struct trans *new_trans)
{ {
log_debug("my_pcsc_trans_conn_in:"); LLOGLN(0, ("my_pcsc_trans_conn_in:"));
if (trans == 0) if (trans == 0)
{ {
@ -240,11 +434,13 @@ my_pcsc_trans_conn_in(struct trans *trans, struct trans *new_trans)
g_con = new_trans; g_con = new_trans;
g_con->trans_data_in = my_pcsc_trans_data_in; g_con->trans_data_in = my_pcsc_trans_data_in;
#if 1
g_con->header_size = 8;
#else
g_con->header_size = RXSHAREDSEGMENT_BYTES; g_con->header_size = RXSHAREDSEGMENT_BYTES;
LLOGLN(0, ("my_pcsc_trans_conn_in: sizeof sharedSegmentMsg is %d",
log_debug("my_pcsc_trans_conn_in: sizeof sharedSegmentMsg is %d", sizeof(sharedSegmentMsg)));
sizeof(sharedSegmentMsg)); #endif
return 0; return 0;
} }
@ -253,36 +449,51 @@ int APP_CC
scard_pcsc_init(void) scard_pcsc_init(void)
{ {
char port[256]; char port[256];
char *home;
int disp;
int error; int error;
int index;
log_debug("scard_pcsc_init:"); LLOGLN(0, ("scard_pcsc_init:"));
g_memset(g_reader_states, 0, sizeof(g_reader_states));
if (g_lis == 0) if (g_lis == 0)
{ {
g_lis = trans_create(TRANS_MODE_UNIX, 8192, 8192); g_lis = trans_create(2, 8192, 8192);
g_lis->is_term = g_is_term;
g_snprintf(g_pcsc_directory, 255, "/tmp/.xrdp/pcsc%d", g_display_num); //g_snprintf(g_pcsclite_ipc_dir, 255, "/tmp/.xrdp/pcsc%d", g_display_num);
if (g_directory_exist(g_pcsc_directory)) home = g_getenv("HOME");
disp = g_display_num;
g_snprintf(g_pcsclite_ipc_dir, 255, "%s/.pcsc%d", home, disp);
if (g_directory_exist(g_pcsclite_ipc_dir))
{ {
if (g_remove_dir(g_pcsc_directory) != 0) if (g_remove_dir(g_pcsclite_ipc_dir) != 0)
{ {
log_error("scard_pcsc_init: g_remove_dir failed"); LLOGLN(0, ("scard_pcsc_init: g_remove_dir failed"));
} }
} }
if (g_create_dir(g_pcsc_directory) != 0) if (!g_create_dir(g_pcsclite_ipc_dir))
{ {
log_error("scard_pcsc_init: g_create_dir failed"); LLOGLN(0, ("scard_pcsc_init: g_create_dir failed"));
} }
g_chmod_hex(g_pcsc_directory, 0x1777); g_chmod_hex(g_pcsclite_ipc_dir, 0x1777);
g_snprintf(port, 255, "%s/pcscd.comm", g_pcsc_directory); g_snprintf(port, 255, "%s/pcscd.comm", g_pcsclite_ipc_dir);
g_lis->trans_conn_in = my_pcsc_trans_conn_in; g_lis->trans_conn_in = my_pcsc_trans_conn_in;
error = trans_listen(g_lis, port); error = trans_listen(g_lis, port);
if (error != 0) if (error != 0)
{ {
log_error("scard_pcsc_init: trans_listen failed for port %s", LLOGLN(0, ("scard_pcsc_init: trans_listen failed for port %s",
port); port));
return 1; return 1;
} }
g_snprintf(g_pub_file_name, 255, "%s/pcscd.pub", g_pcsclite_ipc_dir);
g_pub_file_fd = g_file_open(g_pub_file_name);
index = 0;
while (index < 65537)
{
g_file_write(g_pub_file_fd, "", 1);
index++;
}
} }
return 0; return 0;
} }
@ -291,17 +502,22 @@ scard_pcsc_init(void)
int APP_CC int APP_CC
scard_pcsc_deinit(void) scard_pcsc_deinit(void)
{ {
log_debug("scard_pcsc_deinit:"); LLOGLN(0, ("scard_pcsc_deinit:"));
if (g_lis != 0) if (g_lis != 0)
{ {
trans_delete(g_lis); trans_delete(g_lis);
g_lis = 0; g_lis = 0;
if (g_remove_dir(g_pcsc_directory) != 0)
g_file_close(g_pub_file_fd);
g_pub_file_fd = 0;
g_file_delete(g_pub_file_name);
g_pub_file_name[0] = 0;
if (g_remove_dir(g_pcsclite_ipc_dir) != 0)
{ {
log_error("scard_pcsc_deinit: g_remove_dir failed"); LLOGLN(0, ("scard_pcsc_deinit: g_remove_dir failed"));
} }
g_pcsc_directory[0] = 0; g_pcsclite_ipc_dir[0] = 0;
} }
return 0; return 0;
} }

6
sesman/chansrv/smartcard_pcsc.h
View File

@ -33,4 +33,10 @@ scard_pcsc_init(void);
int APP_CC int APP_CC
scard_pcsc_deinit(void); scard_pcsc_deinit(void);
int APP_CC
scard_function_establish_context_return(struct trans *con, int context);
int APP_CC
scard_function_get_readers_state_return(struct trans *con, struct stream *in_s,
int len);
#endif /* end #ifndef _SMARTCARD_PCSC_H */ #endif /* end #ifndef _SMARTCARD_PCSC_H */