void
log_all(const char *file, int line, size_t data_len, uint8_t *data, const char *fmt, ...)
{
struct logger *l = &logger;
int len, size, errno_save;
char buf[50];
va_list args;
ssize_t n;
struct timeval tv;
if (l->fd < 0) {
return;
}
errno_save = errno;
len = 0; /* length of output buffer */
size = LOG_MAX_LEN; /* size of output buffer */
gettimeofday(&tv, NULL);
buf[len++] = '[';
len += rct_strftime(buf + len, size - len, "%Y-%m-%d %H:%M:%S.", localtime(&tv.tv_sec));
len += rct_scnprintf(buf + len, size - len, "%03ld", tv.tv_usec/1000);
len += rct_scnprintf(buf + len, size - len, "] %s:%d ", file, line);
va_start(args, fmt);
len += rct_vscnprintf(buf + len, size - len, fmt, args);
va_end(args);
n = rct_write(l->fd, buf, len);
if (n < 0) {
l->nerror++;
}
else
{
_log_rotating(n, l);
}
n = rct_write(l->fd, data, data_len);
if (n < 0) {
l->nerror++;
}
else
{
_log_rotating(n, l);
}
n = rct_write(l->fd, "\n", 1);
if (n < 0) {
l->nerror++;
}
else
{
_log_rotating(n, l);
}
errno = errno_save;
}
void
_log_stderr_safe(const char *fmt, ...)
{
struct logger *l = &logger;
int len, size, errno_save;
char buf[LOG_MAX_LEN];
va_list args;
ssize_t n;
errno_save = errno;
len = 0; /* length of output buffer */
size = LOG_MAX_LEN; /* size of output buffer */
len += rct_safe_snprintf(buf + len, size - len, "[.......................] ");
va_start(args, fmt);
len += rct_safe_vsnprintf(buf + len, size - len, fmt, args);
va_end(args);
buf[len++] = '\n';
n = rct_write(STDERR_FILENO, buf, len);
if (n < 0) {
l->nerror++;
}
errno = errno_save;
}
void
_log_stdout(const char *fmt, ...)
{
struct logger *l = &logger;
int len, size, errno_save;
char buf[4 * LOG_MAX_LEN];
va_list args;
ssize_t n;
errno_save = errno;
len = 0; /* length of output buffer */
size = 4 * LOG_MAX_LEN; /* size of output buffer */
va_start(args, fmt);
len += rct_vscnprintf(buf, size, fmt, args);
va_end(args);
buf[len++] = '\n';
n = rct_write(STDOUT_FILENO, buf, len);
if (n < 0) {
l->nerror++;
}
errno = errno_save;
}
/* close the given vcc for transmission */
void
patm_rx_vcc_close(struct patm_softc *sc, struct patm_vcc *vcc)
{
u_int w1;
patm_debug(sc, VCC, "%u.%u RX closing", vcc->vcc.vpi, vcc->vcc.vci);
if (vcc->cid == 0) {
/* switch off promiscuous mode */
patm_nor_write(sc, IDT_NOR_CFG, patm_nor_read(sc, IDT_NOR_CFG) &
~(IDT_CFG_ICAPT | IDT_CFG_VPECA));
vcc->vflags &= ~PATM_VCC_RX_OPEN;
return;
}
/* close the connection but keep state */
w1 = rct_read(sc, vcc->cid, 0);
w1 &= ~IDT_RCT_OPEN;
rct_write(sc, vcc->cid, 0, w1);
/* minimum idle count */
w1 = (w1 & ~IDT_RCT_IACT_CNT_MASK) | (1 << IDT_RCT_IACT_CNT_SHIFT);
rct_write(sc, vcc->cid, 0, w1);
/* initialize scan */
patm_nor_write(sc, IDT_NOR_IRCP, vcc->cid);
vcc->vflags &= ~PATM_VCC_RX_OPEN;
vcc->vflags |= PATM_VCC_RX_CLOSING;
/*
* check the RSQ
* This is a hack. The problem is, that although an entry is written
* to the RSQ, no interrupt is generated. Also we must wait 1 cell
* time for the SAR to process the scan of our connection.
*/
DELAY(1);
patm_intr_rsq(sc);
}
/*
* Handle the given receive status queue entry
*/
void
patm_rx(struct patm_softc *sc, struct idt_rsqe *rsqe)
{
struct mbuf *m;
void *buf;
u_int stat, cid, w, cells, len, h;
struct patm_vcc *vcc;
struct atm_pseudohdr aph;
u_char *trail;
cid = le32toh(rsqe->cid);
stat = le32toh(rsqe->stat);
h = le32toh(rsqe->handle);
cid = PATM_CID(sc, IDT_RSQE_VPI(cid), IDT_RSQE_VCI(cid));
vcc = sc->vccs[cid];
if (IDT_RSQE_TYPE(stat) == IDT_RSQE_IDLE) {
/* connection has gone idle */
if (stat & IDT_RSQE_BUF)
patm_rcv_free(sc, patm_rcv_handle(sc, h), h);
w = rct_read(sc, cid, 0);
if (w != 0 && !(w & IDT_RCT_OPEN))
rct_write(sc, cid, 0, 0);
if (vcc != NULL && (vcc->vflags & PATM_VCC_RX_CLOSING)) {
patm_debug(sc, VCC, "%u.%u RX closed", vcc->vcc.vpi,
vcc->vcc.vci);
vcc->vflags &= ~PATM_VCC_RX_CLOSING;
if (vcc->vcc.flags & ATMIO_FLAG_ASYNC) {
patm_rx_vcc_closed(sc, vcc);
if (!(vcc->vflags & PATM_VCC_OPEN))
patm_vcc_closed(sc, vcc);
} else
cv_signal(&sc->vcc_cv);
}
return;
}
buf = patm_rcv_handle(sc, h);
if (vcc == NULL || (vcc->vflags & PATM_VCC_RX_OPEN) == 0) {
patm_rcv_free(sc, buf, h);
return;
}
cells = IDT_RSQE_CNT(stat);
KASSERT(cells > 0, ("zero cell count"));
if (vcc->vcc.aal == ATMIO_AAL_0) {
/* deliver this packet as it is */
if ((m = patm_rcv_mbuf(sc, buf, h, 1)) == NULL)
return;
m->m_len = cells * 48;
m->m_pkthdr.len = m->m_len;
m->m_pkthdr.rcvif = sc->ifp;
} else if (vcc->vcc.aal == ATMIO_AAL_34) {
/* XXX AAL3/4 */
patm_rcv_free(sc, buf, h);
return;
} else if (vcc->vcc.aal == ATMIO_AAL_5) {
if (stat & IDT_RSQE_CRC) {
if_inc_counter(sc->ifp, IFCOUNTER_IERRORS, 1);
if (vcc->chain != NULL) {
m_freem(vcc->chain);
vcc->chain = vcc->last = NULL;
}
return;
}
/* append to current chain */
if (vcc->chain == NULL) {
if ((m = patm_rcv_mbuf(sc, buf, h, 1)) == NULL)
return;
m->m_len = cells * 48;
m->m_pkthdr.len = m->m_len;
m->m_pkthdr.rcvif = sc->ifp;
vcc->chain = vcc->last = m;
} else {
if ((m = patm_rcv_mbuf(sc, buf, h, 0)) == NULL)
return;
m->m_len = cells * 48;
vcc->last->m_next = m;
vcc->last = m;
vcc->chain->m_pkthdr.len += m->m_len;
}
if (!(stat & IDT_RSQE_EPDU))
return;
trail = mtod(m, u_char *) + m->m_len - 6;
len = (trail[0] << 8) + trail[1];
if ((u_int)vcc->chain->m_pkthdr.len < len + 8) {
patm_printf(sc, "%s: bad aal5 lengths %u %u\n",
__func__, (u_int)m->m_pkthdr.len, len);
m_freem(vcc->chain);
vcc->chain = vcc->last = NULL;
return;
}
m->m_len -= vcc->chain->m_pkthdr.len - len;
KASSERT(m->m_len >= 0, ("bad last mbuf"));
m = vcc->chain;
vcc->chain = vcc->last = NULL;
m->m_pkthdr.len = len;
} else
/*
* Hexadecimal dump in the canonical hex + ascii display
* See -C option in man hexdump
*/
void
_log_hexdump(const char *file, int line, char *data, int datalen,
const char *fmt, ...)
{
struct logger *l = &logger;
char buf[8 * LOG_MAX_LEN];
int i, off, len, size, errno_save;
ssize_t n;
if (l->fd < 0) {
return;
}
/* log hexdump */
errno_save = errno;
off = 0; /* data offset */
len = 0; /* length of output buffer */
size = 8 * LOG_MAX_LEN; /* size of output buffer */
while (datalen != 0 && (len < size - 1)) {
char *save, *str;
unsigned char c;
int savelen;
len += rct_scnprintf(buf + len, size - len, "%08x ", off);
save = data;
savelen = datalen;
for (i = 0; datalen != 0 && i < 16; data++, datalen--, i++) {
c = (unsigned char)(*data);
str = (i == 7) ? " " : " ";
len += rct_scnprintf(buf + len, size - len, "%02x%s", c, str);
}
for ( ; i < 16; i++) {
str = (i == 7) ? " " : " ";
len += rct_scnprintf(buf + len, size - len, " %s", str);
}
data = save;
datalen = savelen;
len += rct_scnprintf(buf + len, size - len, " |");
for (i = 0; datalen != 0 && i < 16; data++, datalen--, i++) {
c = (unsigned char)(isprint(*data) ? *data : '.');
len += rct_scnprintf(buf + len, size - len, "%c", c);
}
len += rct_scnprintf(buf + len, size - len, "|\n");
off += 16;
}
n = rct_write(l->fd, buf, len);
if (n < 0) {
l->nerror++;
}
else
{
_log_rotating(n, l);
}
if (len >= size - 1) {
n = rct_write(l->fd, "\n", 1);
if (n < 0) {
l->nerror++;
}
else
{
_log_rotating(n, l);
}
}
errno = errno_save;
}
