2001-12-30 21:17:34 +00:00
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
#include <config.h>
|
|
|
|
#endif
|
2001-12-29 12:03:18 +00:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
2002-02-21 18:53:23 +00:00
|
|
|
#include <stdarg.h>
|
2001-12-29 12:03:18 +00:00
|
|
|
#include <ctype.h>
|
|
|
|
#include "util.h"
|
|
|
|
|
2008-03-06 16:06:59 +00:00
|
|
|
int util_connect_card(sc_context_t *ctx, sc_card_t **cardp,
|
2004-06-13 20:13:12 +00:00
|
|
|
int reader_id, int slot_id, int wait, int verbose)
|
2003-01-03 16:57:46 +00:00
|
|
|
{
|
2003-12-29 13:06:28 +00:00
|
|
|
sc_reader_t *reader;
|
|
|
|
sc_card_t *card;
|
2003-01-03 16:57:46 +00:00
|
|
|
int r;
|
|
|
|
|
|
|
|
if (wait) {
|
2005-03-09 00:04:44 +00:00
|
|
|
sc_reader_t *readers[16];
|
2003-01-03 16:57:46 +00:00
|
|
|
int slots[16];
|
2006-02-15 17:29:40 +00:00
|
|
|
unsigned int i;
|
|
|
|
int j, k, found;
|
2003-01-03 16:57:46 +00:00
|
|
|
unsigned int event;
|
|
|
|
|
2006-02-15 17:29:40 +00:00
|
|
|
for (i = k = 0; i < sc_ctx_get_reader_count(ctx); i++) {
|
|
|
|
if (reader_id >= 0 && (unsigned int)reader_id != i)
|
2003-01-03 16:57:46 +00:00
|
|
|
continue;
|
2006-02-15 17:29:40 +00:00
|
|
|
reader = sc_ctx_get_reader(ctx, i);
|
2003-01-03 16:57:46 +00:00
|
|
|
for (j = 0; j < reader->slot_count; j++, k++) {
|
|
|
|
readers[k] = reader;
|
|
|
|
slots[k] = j;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
printf("Waiting for card to be inserted...\n");
|
|
|
|
r = sc_wait_for_event(readers, slots, k,
|
|
|
|
SC_EVENT_CARD_INSERTED,
|
|
|
|
&found, &event, -1);
|
|
|
|
if (r < 0) {
|
|
|
|
fprintf(stderr,
|
|
|
|
"Error while waiting for card: %s\n",
|
|
|
|
sc_strerror(r));
|
|
|
|
return 3;
|
|
|
|
}
|
|
|
|
|
|
|
|
reader = readers[found];
|
|
|
|
slot_id = slots[found];
|
|
|
|
} else {
|
|
|
|
if (reader_id < 0)
|
|
|
|
reader_id = 0;
|
2006-02-15 17:29:40 +00:00
|
|
|
if (sc_ctx_get_reader_count(ctx) == 0) {
|
2003-01-03 16:57:46 +00:00
|
|
|
fprintf(stderr,
|
|
|
|
"No smart card readers configured.\n");
|
|
|
|
return 1;
|
|
|
|
}
|
2006-02-15 17:29:40 +00:00
|
|
|
if ((unsigned int)reader_id >= sc_ctx_get_reader_count(ctx)) {
|
2003-01-03 16:57:46 +00:00
|
|
|
fprintf(stderr,
|
|
|
|
"Illegal reader number. "
|
|
|
|
"Only %d reader(s) configured.\n",
|
2006-02-15 17:29:40 +00:00
|
|
|
sc_ctx_get_reader_count(ctx));
|
2003-01-03 16:57:46 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2006-02-15 17:29:40 +00:00
|
|
|
reader = sc_ctx_get_reader(ctx, reader_id);
|
2003-01-03 16:57:46 +00:00
|
|
|
slot_id = 0;
|
2003-01-19 17:47:07 +00:00
|
|
|
if (sc_detect_card_presence(reader, 0) <= 0) {
|
2003-01-03 16:57:46 +00:00
|
|
|
fprintf(stderr, "Card not present.\n");
|
|
|
|
return 3;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-06-13 20:13:12 +00:00
|
|
|
if (verbose)
|
2003-12-29 13:06:28 +00:00
|
|
|
printf("Connecting to card in reader %s...\n", reader->name);
|
|
|
|
if ((r = sc_connect_card(reader, slot_id, &card)) < 0) {
|
2003-01-03 16:57:46 +00:00
|
|
|
fprintf(stderr,
|
|
|
|
"Failed to connect to card: %s\n",
|
|
|
|
sc_strerror(r));
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2004-06-13 20:13:12 +00:00
|
|
|
if (verbose)
|
2003-12-29 13:06:28 +00:00
|
|
|
printf("Using card driver %s.\n", card->driver->name);
|
|
|
|
|
|
|
|
if ((r = sc_lock(card)) < 0) {
|
|
|
|
fprintf(stderr,
|
|
|
|
"Failed to lock card: %s\n",
|
|
|
|
sc_strerror(r));
|
|
|
|
sc_disconnect_card(card, 0);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
*cardp = card;
|
2003-01-03 16:57:46 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-03-06 16:06:59 +00:00
|
|
|
void util_print_binary(FILE *f, const u8 *buf, int count)
|
2001-12-29 12:03:18 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < count; i++) {
|
|
|
|
unsigned char c = buf[i];
|
|
|
|
const char *format;
|
2008-01-04 13:13:53 +00:00
|
|
|
if (!isprint(c))
|
2001-12-29 12:03:18 +00:00
|
|
|
format = "\\x%02X";
|
|
|
|
else
|
|
|
|
format = "%c";
|
|
|
|
fprintf(f, format, c);
|
|
|
|
}
|
|
|
|
(void) fflush(f);
|
|
|
|
}
|
|
|
|
|
2008-03-06 16:06:59 +00:00
|
|
|
void util_hex_dump(FILE *f, const u8 *in, int len, const char *sep)
|
2001-12-29 12:03:18 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2002-01-24 16:02:54 +00:00
|
|
|
for (i = 0; i < len; i++) {
|
|
|
|
if (sep != NULL && i)
|
|
|
|
fprintf(f, "%s", sep);
|
|
|
|
fprintf(f, "%02X", in[i]);
|
|
|
|
}
|
2001-12-29 12:03:18 +00:00
|
|
|
}
|
|
|
|
|
2008-03-06 16:06:59 +00:00
|
|
|
void util_hex_dump_asc(FILE *f, const u8 *in, size_t count, int addr)
|
2001-12-29 12:03:18 +00:00
|
|
|
{
|
|
|
|
int lines = 0;
|
|
|
|
|
|
|
|
while (count) {
|
|
|
|
char ascbuf[17];
|
2006-02-14 22:04:47 +00:00
|
|
|
size_t i;
|
2002-01-09 01:03:10 +00:00
|
|
|
|
|
|
|
if (addr >= 0) {
|
|
|
|
fprintf(f, "%08X: ", addr);
|
|
|
|
addr += 16;
|
|
|
|
}
|
2001-12-29 12:03:18 +00:00
|
|
|
for (i = 0; i < count && i < 16; i++) {
|
|
|
|
fprintf(f, "%02X ", *in);
|
|
|
|
if (isprint(*in))
|
|
|
|
ascbuf[i] = *in;
|
|
|
|
else
|
|
|
|
ascbuf[i] = '.';
|
|
|
|
in++;
|
|
|
|
}
|
|
|
|
count -= i;
|
|
|
|
ascbuf[i] = 0;
|
|
|
|
for (; i < 16 && lines; i++)
|
|
|
|
fprintf(f, " ");
|
|
|
|
fprintf(f, "%s\n", ascbuf);
|
|
|
|
lines++;
|
|
|
|
}
|
|
|
|
}
|
2002-01-08 13:56:50 +00:00
|
|
|
|
2008-03-06 16:06:59 +00:00
|
|
|
void util_print_usage_and_die(const char *app_name, const struct option options[],
|
2007-06-21 13:46:08 +00:00
|
|
|
const char *option_help[])
|
2002-01-08 13:56:50 +00:00
|
|
|
{
|
|
|
|
int i = 0;
|
2002-03-24 14:12:38 +00:00
|
|
|
printf("Usage: %s [OPTIONS]\nOptions:\n", app_name);
|
2002-01-08 13:56:50 +00:00
|
|
|
|
|
|
|
while (options[i].name) {
|
|
|
|
char buf[40], tmp[5];
|
|
|
|
const char *arg_str;
|
|
|
|
|
2003-05-16 16:41:53 +00:00
|
|
|
/* Skip "hidden" options */
|
2003-05-16 19:11:38 +00:00
|
|
|
if (option_help[i] == NULL) {
|
|
|
|
i++;
|
2003-05-16 16:41:53 +00:00
|
|
|
continue;
|
2003-05-16 19:11:38 +00:00
|
|
|
}
|
2003-05-16 16:41:53 +00:00
|
|
|
|
2002-01-08 13:56:50 +00:00
|
|
|
if (options[i].val > 0 && options[i].val < 128)
|
|
|
|
sprintf(tmp, ", -%c", options[i].val);
|
|
|
|
else
|
|
|
|
tmp[0] = 0;
|
|
|
|
switch (options[i].has_arg) {
|
|
|
|
case 1:
|
|
|
|
arg_str = " <arg>";
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
arg_str = " [arg]";
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
arg_str = "";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
sprintf(buf, "--%s%s%s", options[i].name, tmp, arg_str);
|
2003-01-09 09:09:01 +00:00
|
|
|
if (strlen(buf) > 29) {
|
|
|
|
printf(" %s\n", buf);
|
|
|
|
buf[0] = '\0';
|
|
|
|
}
|
|
|
|
printf(" %-29s %s\n", buf, option_help[i]);
|
2002-01-08 13:56:50 +00:00
|
|
|
i++;
|
|
|
|
}
|
|
|
|
exit(2);
|
|
|
|
}
|
|
|
|
|
2008-03-06 16:06:59 +00:00
|
|
|
const char * util_acl_to_str(const sc_acl_entry_t *e)
|
2002-01-09 01:03:10 +00:00
|
|
|
{
|
2002-02-20 09:56:47 +00:00
|
|
|
static char line[80], buf[10];
|
|
|
|
unsigned int acl;
|
2002-01-09 01:03:10 +00:00
|
|
|
|
2002-02-20 09:56:47 +00:00
|
|
|
if (e == NULL)
|
2002-01-13 23:56:13 +00:00
|
|
|
return "N/A";
|
2002-01-09 01:03:10 +00:00
|
|
|
line[0] = 0;
|
2002-02-20 09:56:47 +00:00
|
|
|
while (e != NULL) {
|
|
|
|
acl = e->method;
|
|
|
|
|
|
|
|
switch (acl) {
|
|
|
|
case SC_AC_UNKNOWN:
|
|
|
|
return "N/A";
|
|
|
|
case SC_AC_NEVER:
|
|
|
|
return "NEVR";
|
|
|
|
case SC_AC_NONE:
|
|
|
|
return "NONE";
|
|
|
|
case SC_AC_CHV:
|
|
|
|
strcpy(buf, "CHV");
|
|
|
|
if (e->key_ref != SC_AC_KEY_REF_NONE)
|
|
|
|
sprintf(buf + 3, "%d", e->key_ref);
|
|
|
|
break;
|
|
|
|
case SC_AC_TERM:
|
|
|
|
strcpy(buf, "TERM");
|
|
|
|
break;
|
|
|
|
case SC_AC_PRO:
|
|
|
|
strcpy(buf, "PROT");
|
|
|
|
break;
|
|
|
|
case SC_AC_AUT:
|
|
|
|
strcpy(buf, "AUTH");
|
|
|
|
if (e->key_ref != SC_AC_KEY_REF_NONE)
|
|
|
|
sprintf(buf + 4, "%d", e->key_ref);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
strcpy(buf, "????");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
strcat(line, buf);
|
|
|
|
strcat(line, " ");
|
|
|
|
e = e->next;
|
|
|
|
}
|
2002-01-09 01:03:10 +00:00
|
|
|
line[strlen(line)-1] = 0; /* get rid of trailing space */
|
|
|
|
return line;
|
|
|
|
}
|
2002-02-21 18:53:23 +00:00
|
|
|
|
|
|
|
void
|
2008-03-06 16:06:59 +00:00
|
|
|
util_fatal(const char *fmt, ...)
|
2002-02-21 18:53:23 +00:00
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
|
|
|
|
va_start(ap, fmt);
|
|
|
|
fprintf(stderr, "error: ");
|
|
|
|
vfprintf(stderr, fmt, ap);
|
|
|
|
fprintf(stderr, "\nAborting.\n");
|
|
|
|
va_end(ap);
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2008-03-06 16:06:59 +00:00
|
|
|
util_error(const char *fmt, ...)
|
2002-02-21 18:53:23 +00:00
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
|
|
|
|
va_start(ap, fmt);
|
|
|
|
fprintf(stderr, "error: ");
|
|
|
|
vfprintf(stderr, fmt, ap);
|
|
|
|
fprintf(stderr, "\n");
|
|
|
|
va_end(ap);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2008-03-06 16:06:59 +00:00
|
|
|
util_warn(const char *fmt, ...)
|
2002-02-21 18:53:23 +00:00
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
|
|
|
|
va_start(ap, fmt);
|
|
|
|
fprintf(stderr, "warning: ");
|
|
|
|
vfprintf(stderr, fmt, ap);
|
|
|
|
fprintf(stderr, "\n");
|
|
|
|
va_end(ap);
|
|
|
|
}
|
2004-07-26 18:47:23 +00:00
|
|
|
|