void
chunk_info_print_all(const gchar * domain, const gchar * header, GSList * list)
{
GSList *l;
gchar str_ci[256];
(void) domain, (void) header;
if (!list || !TRACE_ENABLED())
return;
for (l = list; l; l = l->next) {
if (!l->data)
continue;
memset(str_ci, 0x00, sizeof(str_ci));
chunk_info_to_string((chunk_info_t *) (l->data), str_ci, sizeof(str_ci) - 1);
TRACE_DOMAIN(domain, "%s%s", header, str_ci);
}
}
/* Select on the list of fds. Returns: -1 = error, 0 = timeout or
nothing to select, > 0 = number of signaled fds. */
int
_gpgme_io_select (struct io_select_fd_s *fds, size_t nfds, int nonblock)
{
int npollfds;
GPollFD *pollfds;
int *pollfds_map;
int i;
int j;
int any;
int n;
int count;
/* Use a 1s timeout. */
int timeout = 1000;
void *dbg_help = NULL;
TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_select", fds,
"nfds=%u, nonblock=%u", nfds, nonblock);
if (nonblock)
timeout = 0;
pollfds = calloc (nfds, sizeof *pollfds);
if (!pollfds)
return -1;
pollfds_map = calloc (nfds, sizeof *pollfds_map);
if (!pollfds_map)
{
free (pollfds);
return -1;
}
npollfds = 0;
TRACE_SEQ (dbg_help, "select on [ ");
any = 0;
for (i = 0; i < nfds; i++)
{
GIOChannel *chan = NULL;
if (fds[i].fd == -1)
continue;
if ((fds[i].for_read || fds[i].for_write)
&& !(chan = find_channel (fds[i].fd)))
{
TRACE_ADD1 (dbg_help, "[BAD0x%x ", fds[i].fd);
TRACE_END (dbg_help, "]");
assert (!"see log file");
}
else if (fds[i].for_read )
{
assert(chan);
g_io_channel_win32_make_pollfd (chan, G_IO_IN, pollfds + npollfds);
pollfds_map[npollfds] = i;
TRACE_ADD2 (dbg_help, "r0x%x<%d> ", fds[i].fd, pollfds[npollfds].fd);
npollfds++;
any = 1;
}
else if (fds[i].for_write)
{
assert(chan);
g_io_channel_win32_make_pollfd (chan, G_IO_OUT, pollfds + npollfds);
pollfds_map[npollfds] = i;
TRACE_ADD2 (dbg_help, "w0x%x<%d> ", fds[i].fd, pollfds[npollfds].fd);
npollfds++;
any = 1;
}
fds[i].signaled = 0;
}
TRACE_END (dbg_help, "]");
if (!any)
{
count = 0;
goto leave;
}
count = g_io_channel_win32_poll (pollfds, npollfds, timeout);
if (count < 0)
{
int saved_errno = errno;
errno = saved_errno;
goto leave;
}
TRACE_SEQ (dbg_help, "select OK [ ");
if (TRACE_ENABLED (dbg_help))
{
for (i = 0; i < npollfds; i++)
{
if ((pollfds[i].revents & G_IO_IN))
TRACE_ADD1 (dbg_help, "r0x%x ", fds[pollfds_map[i]].fd);
if ((pollfds[i].revents & G_IO_OUT))
TRACE_ADD1 (dbg_help, "w0x%x ", fds[pollfds_map[i]].fd);
}
TRACE_END (dbg_help, "]");
}
/* COUNT is used to stop the lop as soon as possible. */
for (n = count, i = 0; i < npollfds && n; i++)
{
j = pollfds_map[i];
assert (j >= 0 && j < nfds);
if (fds[j].fd == -1)
;
else if (fds[j].for_read)
{
if ((pollfds[i].revents & G_IO_IN))
{
fds[j].signaled = 1;
n--;
}
}
else if (fds[j].for_write)
{
if ((pollfds[i].revents & G_IO_OUT))
{
fds[j].signaled = 1;
n--;
}
}
}
leave:
free (pollfds);
free (pollfds_map);
return TRACE_SYSRES (count);
}
void print_pkt_hdr(char *pkt, size_t len)
{
char str[128];
uint16_t l;
uint8_t t, m;
size_t c = 0;
unsigned int is_tx;
unsigned int hsize;
const char *const*table;
size_t table_size;
if (len < 8) {
DE_TRACE_INT(TR_DATA, "Short packet (" TR_FSIZE_T " bytes)\n",
TR_ASIZE_T(len));
return;
}
l = HIC_MESSAGE_LENGTH_GET(pkt);
t = HIC_MESSAGE_TYPE(pkt);
m = HIC_MESSAGE_ID(pkt);
hsize = HIC_MESSAGE_HDR_SIZE(pkt);
if(t == HIC_MESSAGE_TYPE_DATA && !TRACE_ENABLED(TR_DATA_DUMP))
{
return;
}
c += DE_SNPRINTF(str + c, sizeof(str) - c, "%d,%x.%x", l, t, m);
c = DE_MIN(sizeof(str), c);
if(len >= hsize + 4) {
unsigned int tid = HIC_GET_ULE32(pkt + hsize);
c += DE_SNPRINTF(str + c, sizeof(str) - c, "[%x]", tid);
c = DE_MIN(sizeof(str), c);
}
is_tx = !(t & MAC_API_MSG_DIRECTION_BIT);
t &= ~MAC_API_MSG_DIRECTION_BIT;
m &= ~MAC_API_PRIMITIVE_TYPE_RSP;
if (l < 8 || l > PACKET_MAX) {
DE_TRACE_STRING(TR_DATA, "bad size packet %s\n", str);
return;
}
if (t == HIC_MESSAGE_TYPE_AGGREGATION) {
DE_TRACE_STRING(TR_DATA, "aggregated packet %s\n", str);
return;
}
#define X(N) \
case HIC_MESSAGE_TYPE_##N: \
if(is_tx) { \
table = N##_tx_table; \
table_size = DE_ARRAY_SIZE(N##_tx_table); \
} else { \
table = N##_rx_table; \
table_size = DE_ARRAY_SIZE(N##_rx_table); \
} \
break;
switch(t) {
X(DATA);
X(MGMT);
X(MIB);
X(ECHO);
X(CONSOLE);
X(FLASH_PRG);
X(CTRL);
X(DLM);
default:
DE_TRACE_STRING(TR_DATA, "unknown message type %s\n", str);
return;
}
if(m >= table_size) {
c += DE_SNPRINTF(str + c, sizeof(str) - c, ": UNKNOWN%d", m);
c = DE_MIN(sizeof(str), c);
} else {
c += DE_SNPRINTF(str + c, sizeof(str) - c, ": %s", table[m]);
c = DE_MIN(sizeof(str), c);
}
if(t == HIC_MESSAGE_TYPE_DATA
&& m == (HIC_MAC_DATA_CFM & ~MAC_API_PRIMITIVE_TYPE_RSP)
&& len >= hsize + 8) {
c += DE_SNPRINTF(str + c, sizeof(str) - c, " s%ur%up%xd%u",
HIC_DATA_CFM_STATUS(pkt + hsize),
HIC_DATA_CFM_RATE_USED(pkt + hsize),
HIC_DATA_CFM_RATE_PRIO(pkt + hsize),
HIC_DATA_CFM_DISCARDED_RX(pkt + hsize));
c = DE_MIN(sizeof(str), c);
}
DE_TRACE_STRING(TR_DATA, "pkt: %s\n", str);
}
