uLab
/
xrdp-proprietary
mirror of https://mirror.git.trinitydesktop.org/gitea/uLab/xrdp-proprietary
0
0
Fork 0
Code Issues Releases Wiki Activity

scard: added more messages

Browse Source
ulab-next
Laxmikant Rashinkar 11 years ago
parent 68371ed361
commit a1352b62e3
2 changed files with 658 additions and 11 deletions
Show Stats Download Patch File Download Diff File

742
sesman/chansrv/smartcard.c
Unescape View File

@ -113,7 +113,8 @@ do \
#define SCARD_IOCTL_BEGIN_TRANSACTION 0x000900BC /* BeginTransaction */ #define SCARD_IOCTL_BEGIN_TRANSACTION 0x000900BC /* BeginTransaction */
#define SCARD_IOCTL_END_TRANSACTION 0x000900C0 /* EndTransaction */ #define SCARD_IOCTL_END_TRANSACTION 0x000900C0 /* EndTransaction */
#define SCARD_IOCTL_STATE 0x000900C4 /* State */ #define SCARD_IOCTL_STATE 0x000900C4 /* State */
#define SCARD_IOCTL_STATUS 0x000900C8 /* StatusA */ #define SCARD_IOCTL_STATUS_A 0x000900C8 /* StatusA */
#define SCARD_IOCTL_STATUS_W 0x000900CC /* StatusW */
#define SCARD_IOCTL_TRANSMIT 0x000900D0 /* Transmit */ #define SCARD_IOCTL_TRANSMIT 0x000900D0 /* Transmit */
#define SCARD_IOCTL_CONTROL 0x000900D4 /* Control */ #define SCARD_IOCTL_CONTROL 0x000900D4 /* Control */
#define SCARD_IOCTL_GETATTRIB 0x000900D8 /* GetAttrib */ #define SCARD_IOCTL_GETATTRIB 0x000900D8 /* GetAttrib */
@ -126,6 +127,12 @@ do \
#define SCARD_SCOPE_TERMINAL 0x00000001 #define SCARD_SCOPE_TERMINAL 0x00000001
#define SCARD_SCOPE_SYSTEM 0x00000002 #define SCARD_SCOPE_SYSTEM 0x00000002
/* disposition - action to take on card */
#define SCARD_LEAVE_CARD 0x00000000
#define SCARD_RESET_CARD 0x00000001
#define SCARD_UNPOWER_CARD 0x00000002
#define SCARD_EJECT_CARD 0x00000003
#define MAX_SMARTCARDS 16 #define MAX_SMARTCARDS 16
/* stores info about a smart card */ /* stores info about a smart card */
@ -155,12 +162,17 @@ 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 void scard_send_EstablishContext(IRP* irp, int scope); static void scard_send_EstablishContext(IRP* irp, int scope);
static void scard_send_ReleaseContext(IRP* irp);
static void scard_send_ListReaders(IRP* irp, int wide); static void scard_send_ListReaders(IRP* irp, int wide);
static void scard_send_GetStatusChange(IRP* irp, int wide, tui32 timeout, static void scard_send_GetStatusChange(IRP* irp, int wide, tui32 timeout,
tui32 num_readers, READER_STATE* rsa); tui32 num_readers, READER_STATE* rsa);
static void scard_send_Connect(IRP* irp, int wide, READER_STATE* rs); static void scard_send_Connect(IRP* irp, int wide, READER_STATE* rs);
static void scard_send_BeginTransaction(IRP* irp, tui32 sc_handle);
static void scard_send_EndTransaction(IRP* irp, tui32 sc_handle);
static void scard_send_Status(IRP* irp, int wide, tui32 sc_handle);
static void scard_send_Disconnect(IRP* irp, tui32 sc_handle);
/****************************************************************************** /******************************************************************************
** local callbacks into this module ** ** local callbacks into this module **
@ -170,6 +182,10 @@ static void scard_handle_EstablishContext_Return(struct stream *s, IRP *irp,
tui32 DeviceId, tui32 CompletionId, tui32 DeviceId, tui32 CompletionId,
tui32 IoStatus); tui32 IoStatus);
static void scard_handle_ReleaseContext_Return(struct stream *s, IRP *irp,
tui32 DeviceId, tui32 CompletionId,
tui32 IoStatus);
static void scard_handle_ListReaders_Return(struct stream *s, IRP *irp, static void scard_handle_ListReaders_Return(struct stream *s, IRP *irp,
tui32 DeviceId, tui32 CompletionId, tui32 DeviceId, tui32 CompletionId,
tui32 IoStatus); tui32 IoStatus);
@ -182,6 +198,22 @@ static void scard_handle_Connect_Return(struct stream *s, IRP *irp,
tui32 DeviceId, tui32 CompletionId, tui32 DeviceId, tui32 CompletionId,
tui32 IoStatus); tui32 IoStatus);
static void scard_handle_BeginTransaction_Return(struct stream *s, IRP *irp,
tui32 DeviceId, tui32 CompletionId,
tui32 IoStatus);
static void scard_handle_EndTransaction_Return(struct stream *s, IRP *irp,
tui32 DeviceId, tui32 CompletionId,
tui32 IoStatus);
static void scard_handle_Status_Return(struct stream *s, IRP *irp,
tui32 DeviceId, tui32 CompletionId,
tui32 IoStatus);
static void scard_handle_Disconnect_Return(struct stream *s, IRP *irp,
tui32 DeviceId, tui32 CompletionId,
tui32 IoStatus);
/****************************************************************************** /******************************************************************************
** ** ** **
** externally accessible functions, defined in smartcard.h ** ** externally accessible functions, defined in smartcard.h **
@ -274,6 +306,33 @@ scard_send_irp_establish_context(struct trans *con, int scope)
return 0; return 0;
} }
/**
* Release a previously established Smart Card context
*****************************************************************************/
int
APP_CC scard_send_release_context(struct trans *con)
{
IRP *irp;
/* setup up 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_ReleaseContext_Return;
irp->user_data = con;
/* send IRP to client */
scard_send_ReleaseContext(irp);
return 0;
}
/** /**
* *
*****************************************************************************/ *****************************************************************************/
@ -364,6 +423,127 @@ scard_send_irp_connect(struct trans *con, int wide, READER_STATE* rs)
return 0; return 0;
} }
/**
* Lock smart card reader for exclusive access for specified smart
* card reader handle.
*
* @param con connection to client
*****************************************************************************/
int
APP_CC scard_send_begin_transaction(struct trans *con, tui32 sc_handle)
{
IRP *irp;
/* setup up 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_BeginTransaction_Return;
irp->user_data = con;
/* send IRP to client */
scard_send_BeginTransaction(irp, sc_handle);
return 0;
}
/**
* Release a smart card reader after being locked by a previously
* successful call to Begin Transaction
*
* @param con connection to client
* @param sc_handle handle to smartcard
*****************************************************************************/
int
APP_CC scard_send_end_transaction(struct trans *con, tui32 sc_handle)
{
IRP *irp;
/* setup up 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_EndTransaction_Return;
irp->user_data = con;
/* send IRP to client */
scard_send_EndTransaction(irp, sc_handle);
return 0;
}
/**
* Get the status of a connection for a valid smart card reader handle
*
* @param con connection to client
* @param wide TRUE if unicode string
*****************************************************************************/
int
APP_CC scard_send_status(struct trans *con, int wide, tui32 sc_handle)
{
IRP *irp;
/* setup up 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_Status_Return;
irp->user_data = con;
/* send IRP to client */
scard_send_Status(irp, wide, sc_handle);
return 0;
}
/**
* Release a smart card reader handle that was acquired in ConnectA/ConnectW
*
* @param con connection to client
* @param sc_handle handle to smartcard
*****************************************************************************/
int
APP_CC scard_send_disconnect(struct trans *con, tui32 sc_handle)
{
IRP *irp;
/* setup up 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_Disconnect_Return;
irp->user_data = con;
/* send IRP to client */
scard_send_Disconnect(irp, sc_handle);
return 0;
}
/****************************************************************************** /******************************************************************************
** ** ** **
** static functions local to this file ** ** static functions local to this file **
@ -532,6 +712,58 @@ scard_send_EstablishContext(IRP *irp, int scope)
xstream_free(s); xstream_free(s);
} }
/**
* Release a previously established Smart Card context
*****************************************************************************/
static void
scard_send_ReleaseContext(IRP* irp)
{
/* see [MS-RDPESC] 3.1.4.2 */
SMARTCARD* sc;
struct stream* s;
int bytes;
if ((sc = smartcards[irp->scard_index]) == NULL)
{
log_error("smartcards[%d] is NULL", irp->scard_index);
return;
}
if ((s = scard_make_new_ioctl(irp, SCARD_IOCTL_RELEASE_CONTEXT)) == NULL)
return;
/*
* command format
*
* ......
* 20 bytes padding
* u32 4 bytes len 8, LE, v1
* u32 4 bytes filler
* 4 bytes len - don't know what this is, zero for now
* 12 bytes unused
* u32 4 bytes context len
* 4 bytes context
*/
xstream_wr_u32_le(s, 0);
xstream_seek(s, 12);
/* insert context */
xstream_wr_u32_le(s, sc->Context_len);
xstream_copyin(s, sc->Context, sc->Context_len);
/* get stream len */
bytes = xstream_len(s);
/* InputBufferLength is number of bytes AFTER 20 byte padding */
*(s->data + 28) = bytes - 56;
/* send to client */
send_channel_data(g_rdpdr_chan_id, s->data, bytes);
xstream_free(s);
}
/** /**
* *
*****************************************************************************/ *****************************************************************************/
@ -551,7 +783,7 @@ scard_send_ListReaders(IRP *irp, int wide)
return; return;
} }
ioctl = (wide > 0) ? SCARD_IOCTL_LIST_READERS_W : ioctl = (wide) ? SCARD_IOCTL_LIST_READERS_W :
SCARD_IOCTL_LIST_READERS_A; SCARD_IOCTL_LIST_READERS_A;
if ((s = scard_make_new_ioctl(irp, ioctl)) == NULL) if ((s = scard_make_new_ioctl(irp, ioctl)) == NULL)
@ -654,7 +886,7 @@ scard_send_GetStatusChange(IRP* irp, int wide, tui32 timeout,
return; return;
} }
ioctl = (wide > 0) ? SCARD_IOCTL_GET_STATUS_CHANGE_W : ioctl = (wide) ? SCARD_IOCTL_GET_STATUS_CHANGE_W :
SCARD_IOCTL_GET_STATUS_CHANGE_A; SCARD_IOCTL_GET_STATUS_CHANGE_A;
if ((s = scard_make_new_ioctl(irp, ioctl)) == NULL) if ((s = scard_make_new_ioctl(irp, ioctl)) == NULL)
@ -744,6 +976,9 @@ static void scard_send_Connect(IRP* irp, int wide, READER_STATE* rs)
tui32 ioctl; tui32 ioctl;
int bytes; int bytes;
int len; int len;
int num_chars;
int index;
twchar w_reader_name[100];
if ((sc = smartcards[irp->scard_index]) == NULL) if ((sc = smartcards[irp->scard_index]) == NULL)
{ {
@ -751,8 +986,8 @@ static void scard_send_Connect(IRP* irp, int wide, READER_STATE* rs)
return; return;
} }
ioctl = (wide > 0) ? SCARD_IOCTL_CONNECT_A : ioctl = (wide) ? SCARD_IOCTL_CONNECT_W :
SCARD_IOCTL_CONNECT_W; SCARD_IOCTL_CONNECT_A;
if ((s = scard_make_new_ioctl(irp, ioctl)) == NULL) if ((s = scard_make_new_ioctl(irp, ioctl)) == NULL)
return; return;
@ -764,7 +999,7 @@ static void scard_send_Connect(IRP* irp, int wide, READER_STATE* rs)
* 20 bytes padding * 20 bytes padding
* u32 4 bytes len 8, LE, v1 * u32 4 bytes len 8, LE, v1
* u32 4 bytes filler * u32 4 bytes filler
* 20 bytes unused (s->p is currently pointed here) * 20 bytes unused (s->p currently pointed here at unused[0])
* u32 4 bytes dwShareMode * u32 4 bytes dwShareMode
* u32 4 bytes dwPreferredProtocol * u32 4 bytes dwPreferredProtocol
* xx bytes reader name * xx bytes reader name
@ -777,9 +1012,18 @@ static void scard_send_Connect(IRP* irp, int wide, READER_STATE* rs)
xstream_wr_u32_le(s, rs->preferred_protocol); xstream_wr_u32_le(s, rs->preferred_protocol);
/* insert reader name */ /* insert reader name */
/* LK_TODO need to handle unicode */ num_chars = g_mbstowcs(w_reader_name, rs->reader_name, 99);
len = strlen(rs->reader_name); xstream_wr_u32_le(s, num_chars);
xstream_copyin(s, rs->reader_name, len); if (wide)
{
for (index = 0; index < num_chars; index++)
xstream_wr_u16_le(s, w_reader_name[index]);
}
else
{
for (index = 0; index < num_chars; index++)
xstream_wr_u8(s, w_reader_name[index]);
}
/* insert context */ /* insert context */
xstream_wr_u32_le(s, sc->Context_len); xstream_wr_u32_le(s, sc->Context_len);
@ -796,63 +1040,301 @@ static void scard_send_Connect(IRP* irp, int wide, READER_STATE* rs)
xstream_free(s); xstream_free(s);
} }
/******************************************************************************
** **
** local callbacks into this module **
** **
******************************************************************************/
/** /**
* Lock smart card reader for exclusive access for specified smart
* card reader handle.
* *
* @param con connection to client
*****************************************************************************/ *****************************************************************************/
static void APP_CC static void
scard_handle_EstablishContext_Return(struct stream *s, IRP *irp, scard_send_BeginTransaction(IRP* irp, tui32 sc_handle)
tui32 DeviceId, tui32 CompletionId,
tui32 IoStatus)
{ {
tui32 len; /* see [MS-RDPESC] 4.9 */
int tmp;
SMARTCARD *sc;
log_debug("entered"); SMARTCARD* sc;
struct stream* s;
int bytes;
/* sanity check */ if ((sc = smartcards[irp->scard_index]) == NULL)
if ((DeviceId != irp->DeviceId) || (CompletionId != irp->CompletionId))
{ {
log_error("DeviceId/CompletionId do not match those in IRP"); log_error("smartcards[%d] is NULL", irp->scard_index);
return; return;
} }
if (IoStatus != 0) if ((s = scard_make_new_ioctl(irp, SCARD_IOCTL_BEGIN_TRANSACTION)) == NULL)
{
log_error("failed to establish context - device not usable");
/* LK_TODO delete irp and smartcard entry */
return; return;
}
sc = smartcards[irp->scard_index]; /*
* command format
*
* ......
* 20 bytes padding
* u32 4 bytes len 8, LE, v1
* u32 4 bytes filler
* 36 bytes unused (s->p currently pointed here at unused[0])
* u32 4 bytes len of sc_handle
* 4 bytes sc_handle
*/
/* get OutputBufferLen */ xstream_seek(s, 36);
xstream_rd_u32_le(s, len);
/* LK_TODO */ /* insert handle */
g_hexdump(s->p, len); xstream_wr_u32_le(s, 4);
xstream_wr_u32_le(s, sc_handle);
xstream_rd_u32_le(s, tmp); /* should be len 8, LE, V1 */ /* get stream len */
xstream_rd_u32_le(s, tmp); /* marshalling flag */ bytes = xstream_len(s);
xstream_rd_u32_le(s, tmp); /* ?? */
xstream_rd_u32_le(s, tmp); /* ?? */
xstream_rd_u32_le(s, tmp); /* ?? */
xstream_rd_u32_le(s, tmp); /* ?? */
xstream_rd_u32_le(s, tmp); /* ?? */
xstream_rd_u32_le(s, len); /* len of context in bytes */
sc->Context_len = len;
xstream_copyout(sc->Context, s, len);
if (LOG_LEVEL == LOG_DEBUG) /* InputBufferLength is number of bytes AFTER 20 byte padding */
{ *(s->data + 28) = bytes - 56;
log_debug("dumping context (%d bytes)", sc->Context_len);
g_hexdump(sc->Context, sc->Context_len); /* send to client */
send_channel_data(g_rdpdr_chan_id, s->data, bytes);
xstream_free(s);
}
/**
* Release a smart card reader after being locked by a previously
* successful call to Begin Transaction
*
* @param con connection to client
* @param sc_handle handle to smartcard
*****************************************************************************/
static void
scard_send_EndTransaction(IRP* irp, tui32 sc_handle)
{
/* see [MS-RDPESC] 3.1.4.32 */
SMARTCARD* sc;
struct stream* s;
int bytes;
if ((sc = smartcards[irp->scard_index]) == NULL)
{
log_error("smartcards[%d] is NULL", irp->scard_index);
return;
}
if ((s = scard_make_new_ioctl(irp, SCARD_IOCTL_END_TRANSACTION)) == NULL)
return;
/*
* command format
*
* ......
* 20 bytes padding
* u32 4 bytes len 8, LE, v1
* u32 4 bytes filler
* 24 bytes unused (s->p currently pointed here at unused[0])
* u32 4 bytes disposition
* 8 unused
* u32 4 bytes length of sc_handle
* 4 bytes sc_handle
*/
xstream_seek(s, 24);
xstream_wr_u32_le(s, SCARD_LEAVE_CARD);
xstream_seek(s, 8);
/* insert handle */
xstream_wr_u32_le(s, 4);
xstream_wr_u32_le(s, sc_handle);
/* get stream len */
bytes = xstream_len(s);
/* InputBufferLength is number of bytes AFTER 20 byte padding */
*(s->data + 28) = bytes - 56;
/* send to client */
send_channel_data(g_rdpdr_chan_id, s->data, bytes);
xstream_free(s);
}
/**
* Get the status of a connection for a valid smart card reader handle
*
* @param con connection to client
* @param wide TRUE if unicode string
*****************************************************************************/
static void
scard_send_Status(IRP* irp, int wide, tui32 sc_handle)
{
/* see [MS-RDPESC] 2.2.2.18 */
SMARTCARD* sc;
struct stream* s;
int bytes;
tui32 ioctl;
if ((sc = smartcards[irp->scard_index]) == NULL)
{
log_error("smartcards[%d] is NULL", irp->scard_index);
return;
}
ioctl = (wide) ? SCARD_IOCTL_CONNECT_W :
SCARD_IOCTL_CONNECT_A;
if ((s = scard_make_new_ioctl(irp, ioctl)) == NULL)
return;
/*
* command format
*
* ......
* 20 bytes padding
* u32 4 bytes len 8, LE, v1
* u32 4 bytes filler
* 28 bytes unused (s->p currently pointed here at unused[0])
* u32 4 bytes reader len
* u32 4 bytes ATR len
* 8 bytes unused
* u32 4 bytes len of sc_handle
* 4 bytes sc_handle
* 4 bytes unused
*/
xstream_seek(s, 28);
xstream_wr_u32_le(s, -1); /* readerLen, see [MS-RDPESC] 4.11 */
xstream_wr_u32_le(s, 36); /* atrLen, see [MS-RDPESC] 4.11 */
xstream_seek(s, 8);
/* insert sc_handle */
xstream_wr_u32_le(s, 4);
xstream_wr_u32_le(s, sc_handle);
xstream_wr_u32_le(s, 0);
/* get stream len */
bytes = xstream_len(s);
/* InputBufferLength is number of bytes AFTER 20 byte padding */
*(s->data + 28) = bytes - 56;
/* send to client */
send_channel_data(g_rdpdr_chan_id, s->data, bytes);
xstream_free(s);
}
/**
* Release a smart card reader handle that was acquired in ConnectA/ConnectW
*
* @param con connection to client
* @param sc_handle handle to smartcard
*****************************************************************************/
static void
scard_send_Disconnect(IRP* irp, tui32 sc_handle)
{
/* see [MS-RDPESC] 3.1.4.30 */
SMARTCARD* sc;
struct stream* s;
int bytes;
if ((sc = smartcards[irp->scard_index]) == NULL)
{
log_error("smartcards[%d] is NULL", irp->scard_index);
return;
}
if ((s = scard_make_new_ioctl(irp, SCARD_IOCTL_DISCONNECT)) == NULL)
return;
/*
* command format
*
* ......
* 20 bytes padding
* u32 4 bytes len 8, LE, v1
* u32 4 bytes filler
* 24 bytes unused (s->p currently pointed here at unused[0])
* u32 4 bytes disposition
* u32 4 bytes context len
* 4 bytes context
* u32 4 bytes length of sc_handle
* 4 bytes sc_handle
*/
xstream_seek(s, 24);
xstream_wr_u32_le(s, SCARD_RESET_CARD);
/* insert context */
xstream_wr_u32_le(s, sc->Context_len);
xstream_copyin(s, sc->Context, sc->Context_len);
/* insert handle */
xstream_wr_u32_le(s, 4);
xstream_wr_u32_le(s, sc_handle);
/* get stream len */
bytes = xstream_len(s);
/* InputBufferLength is number of bytes AFTER 20 byte padding */
*(s->data + 28) = bytes - 56;
/* send to client */
send_channel_data(g_rdpdr_chan_id, s->data, bytes);
xstream_free(s);
}
/******************************************************************************
** **
** local callbacks into this module **
** **
******************************************************************************/
/**
*
*****************************************************************************/
static void APP_CC
scard_handle_EstablishContext_Return(struct stream *s, IRP *irp,
tui32 DeviceId, tui32 CompletionId,
tui32 IoStatus)
{
tui32 len;
int tmp;
SMARTCARD *sc;
log_debug("entered");
/* sanity check */
if ((DeviceId != irp->DeviceId) || (CompletionId != irp->CompletionId))
{
log_error("DeviceId/CompletionId do not match those in IRP");
return;
}
if (IoStatus != 0)
{
log_error("failed to establish context - device not usable");
/* LK_TODO delete irp and smartcard entry */
return;
}
sc = smartcards[irp->scard_index];
/* get OutputBufferLen */
xstream_rd_u32_le(s, len);
/* LK_TODO */
g_hexdump(s->p, len);
xstream_rd_u32_le(s, tmp); /* should be len 8, LE, V1 */
xstream_rd_u32_le(s, tmp); /* marshalling flag */
xstream_rd_u32_le(s, tmp); /* ?? */
xstream_rd_u32_le(s, tmp); /* ?? */
xstream_rd_u32_le(s, tmp); /* ?? */
xstream_rd_u32_le(s, tmp); /* ?? */
xstream_rd_u32_le(s, tmp); /* ?? */
xstream_rd_u32_le(s, len); /* len of context in bytes */
sc->Context_len = len;
xstream_copyout(sc->Context, s, len);
if (LOG_LEVEL == LOG_DEBUG)
{
log_debug("dumping context (%d bytes)", sc->Context_len);
g_hexdump(sc->Context, sc->Context_len);
} }
// LK_TODO delete this // LK_TODO delete this
@ -868,6 +1350,38 @@ scard_handle_EstablishContext_Return(struct stream *s, IRP *irp,
log_debug("leaving"); log_debug("leaving");
} }
/**
*
*****************************************************************************/
static void
scard_handle_ReleaseContext_Return(struct stream *s, IRP *irp,
tui32 DeviceId, tui32 CompletionId,
tui32 IoStatus)
{
tui32 len;
log_debug("entered");
/* sanity check */
if ((DeviceId != irp->DeviceId) || (CompletionId != irp->CompletionId))
{
log_error("DeviceId/CompletionId do not match those in IRP");
return;
}
if (IoStatus != 0)
{
log_error("ReleaseContext failed, device not usable");
/* LK_TODO delete irp and smartcard entry */
return;
}
/* get OutputBufferLen */
xstream_rd_u32_le(s, len);
log_debug("leaving");
}
/** /**
* *
*****************************************************************************/ *****************************************************************************/
@ -965,3 +1479,131 @@ scard_handle_Connect_Return(struct stream *s, IRP *irp,
log_debug("leaving"); log_debug("leaving");
} }
/**
*
*****************************************************************************/
static void
scard_handle_BeginTransaction_Return(struct stream *s, IRP *irp,
tui32 DeviceId, tui32 CompletionId,
tui32 IoStatus)
{
tui32 len;
log_debug("entered");
/* sanity check */
if ((DeviceId != irp->DeviceId) || (CompletionId != irp->CompletionId))
{
log_error("DeviceId/CompletionId do not match those in IRP");
return;
}
if (IoStatus != 0)
{
log_error("BeginTransaction failed, device not usable");
/* LK_TODO delete irp and smartcard entry */
return;
}
/* get OutputBufferLen */
xstream_rd_u32_le(s, len);
log_debug("leaving");
}
/**
*
*****************************************************************************/
static void
scard_handle_EndTransaction_Return(struct stream *s, IRP *irp,
tui32 DeviceId, tui32 CompletionId,
tui32 IoStatus)
{
tui32 len;
log_debug("entered");
/* sanity check */
if ((DeviceId != irp->DeviceId) || (CompletionId != irp->CompletionId))
{
log_error("DeviceId/CompletionId do not match those in IRP");
return;
}
if (IoStatus != 0)
{
log_error("EndTransaction failed, device not usable");
/* LK_TODO delete irp and smartcard entry */
return;
}
/* get OutputBufferLen */
xstream_rd_u32_le(s, len);
log_debug("leaving");
}
/**
*
*****************************************************************************/
static void
scard_handle_Status_Return(struct stream *s, IRP *irp,
tui32 DeviceId, tui32 CompletionId,
tui32 IoStatus)
{
tui32 len;
log_debug("entered");
/* sanity check */
if ((DeviceId != irp->DeviceId) || (CompletionId != irp->CompletionId))
{
log_error("DeviceId/CompletionId do not match those in IRP");
return;
}
if (IoStatus != 0)
{
log_error("StatusCall failed, device not usable");
/* LK_TODO delete irp and smartcard entry */
return;
}
/* get OutputBufferLen */
xstream_rd_u32_le(s, len);
log_debug("leaving");
}
/**
*
*****************************************************************************/
static void
scard_handle_Disconnect_Return(struct stream *s, IRP *irp,
tui32 DeviceId, tui32 CompletionId,
tui32 IoStatus)
{
tui32 len;
log_debug("entered");
/* sanity check */
if ((DeviceId != irp->DeviceId) || (CompletionId != irp->CompletionId))
{
log_error("DeviceId/CompletionId do not match those in IRP");
return;
}
if (IoStatus != 0)
{
log_error("Disconnect failed, device not usable");
/* LK_TODO delete irp and smartcard entry */
return;
}
/* get OutputBufferLen */
xstream_rd_u32_le(s, len);
log_debug("leaving");
}

5
sesman/chansrv/smartcard.h
Unescape View File

@ -74,11 +74,16 @@ int APP_CC scard_check_wait_objs(void);
int APP_CC scard_init(void); int APP_CC scard_init(void);
int APP_CC scard_deinit(void); int APP_CC scard_deinit(void);
int APP_CC scard_send_irp_establish_context(struct trans *con, int scope); int APP_CC scard_send_irp_establish_context(struct trans *con, int scope);
int APP_CC scard_send_release_context(struct trans *con);
int APP_CC scard_send_irp_list_readers(struct trans *con); int APP_CC scard_send_irp_list_readers(struct trans *con);
int APP_CC scard_send_irp_get_status_change(struct trans *con, int wide, tui32 timeout, int APP_CC scard_send_irp_get_status_change(struct trans *con, int wide, tui32 timeout,
tui32 num_readers, READER_STATE* rsa); tui32 num_readers, READER_STATE* rsa);
int APP_CC scard_send_irp_connect(struct trans *con, int wide, READER_STATE* rs); int APP_CC scard_send_irp_connect(struct trans *con, int wide, READER_STATE* rs);
int APP_CC scard_send_begin_transaction(struct trans *con, tui32 sc_handle);
int APP_CC scard_send_end_transaction(struct trans *con, tui32 sc_handle);
int APP_CC scard_send_status(struct trans *con, int wide, tui32 sc_handle);
int APP_CC scard_send_disconnect(struct trans *con, tui32 sc_handle);
#endif /* end #ifndef _SMARTCARD_C */ #endif /* end #ifndef _SMARTCARD_C */

Write Preview
Loading…
Cancel
Save