/** * Dumps hex characters inline, no newlines inserted * * @param sev The severity * @param data The data to log * @param len The number of bytes to log */ void log_hex(log_sev_t sev, const void *vdata, int len) { const UINT8 *dat = (const UINT8 *)vdata; int idx; char buf[80]; if ((vdata == NULL) || !log_sev_on(sev)) { return; } idx = 0; while (len-- > 0) { buf[idx++] = to_hex_char(*dat >> 4); buf[idx++] = to_hex_char(*dat); dat++; if (idx >= (int)(sizeof(buf) - 3)) { buf[idx] = 0; log_str(sev, buf, idx); idx = 0; } } if (idx > 0) { buf[idx] = 0; log_str(sev, buf, idx); } }
int udp_send_bcast(int fd, int port, char *buf, int size) { int enable; udp_send_bcast_ctx_t ctx; int ret = -1; /* Enable broadcast on this socket */ enable = 1; if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, (void *) &enable, sizeof(enable)) < 0) { log_str("ERROR: setsockopt(BROADCAST): %s", strerror(errno)); return -1; } ctx.fd = fd; ctx.port = port; ctx.buf = buf; ctx.size = size; ret = netif_foreach_interface(&ctx, (netif_func_t) udp_send_bcast_addr); /* Disable broadcast on this socket */ enable = 0; if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, (void *) &enable, sizeof(enable)) < 0) { log_str("ERROR: setsockopt(BROADCAST): %s", strerror(errno)); return -1; } return ret; }
char *let_str_fitt_to(char *dst, char *src, int dst_len, int src_len) { #ifdef DEBUG char log_buff[256]; sprintf(log_buff, "%s [SFT]: src \"%s\" src_len %d dst \"%s\" dst_len %d", __func__, src, src_len, dst, dst_len); log_str(log_buff, LOG_DEBUG); if (src_len <= dst_len) log_str("[SFT] fitting, return", LOG_DEBUG); if (dst_len <= 3) log_str("[SFT] dst_len to smal return NULL!", LOG_DEBUG); #endif if (src_len <= dst_len) return src; if (dst_len <= 3) return NULL; int i; for (i = 0; i < dst_len; i++) { if (i < dst_len - 3) dst[i] = src[i]; else dst[i] = '.'; } dst[i] = (char) 0; #ifdef DEBUG sprintf(log_buff, "[SFT]: %s trimmt to %s", src, dst); log_str(log_buff, LOG_DEBUG); #endif return dst; }
void log_pcf_flags(log_sev_t sev, UINT64 flags) { if (!log_sev_on(sev)) { return; } log_fmt(sev, "[0x%" PRIx64 ":", flags); const char *tolog = NULL; for (int i = 0; i < (int)ARRAY_SIZE(pcf_names); i++) { if ((flags & (1ULL << i)) != 0) { if (tolog != NULL) { log_str(sev, tolog, strlen(tolog)); log_str(sev, ",", 1); } tolog = pcf_names[i]; } } if (tolog != NULL) { log_str(sev, tolog, strlen(tolog)); } log_str(sev, "]\n", 2); }
void HIDDevice::SetReport(const uint8_t* buffer, int bytes, int report_size, uint8_t report_id) { log_str("-- SetRep "); for (int c = 0; c < bytes; ++c) log_str(int2hex(buffer[c]) + " "); log_str("\n"); // alloc and clear the buffer int buff_size = report_size + 1; char sendbuff[buff_size]; memset(sendbuff, 0, buff_size); // set the report ID and the data sendbuff[0] = report_id; memcpy(sendbuff + 1, buffer, bytes); int result = usbhidSetReport(hHIDDev, sendbuff, buff_size); if (result != USBOPEN_SUCCESS) { log_str("Unable to send data to programmer.\n"); throw std::string("Unable to send data to programmer."); } log_str("-- out of SetRep\n"); }
static void monitor_sink_event(void *user_data, char *name, char *value) { if (value == NULL) { log_str("-- New sink: %s", name); } else { log_str("-- %s='%s'", name, value); } }
int main(int argc, char *argv[]) { char *app; int use_ssl = 1; // 0 = disable SSL, 2 = allow insecure SSL if (options_parse(&argc, argv) != 0) { exit(1); } if (opt_daemon) { run_as_daemon(); } /* Init exec environment */ env_init(argc, argv); /* Init log management */ log_init("hakit"); log_str(options_summary); log_str("Using libwebsockets version " LWS_LIBRARY_VERSION " build " LWS_BUILD_HASH); /* Init system runtime */ sys_init(); /* Init communication engine */ if (opt_no_ssl) { use_ssl = 0; } else if (opt_insecure_ssl) { use_ssl = 2; } if (comm_init(use_ssl, opt_no_hkcp ? 0:1, opt_hosts)) { return 2; } if (opt_monitor) { comm_monitor((comm_sink_func_t) monitor_sink_event, NULL); } /* Init module management */ if (hk_mod_init(opt_class_path)) { return 2; } app = env_app(); if (app != NULL) { if (hk_mod_load(app)) { return 3; } hk_obj_start_all(); } sys_run(); return 0; }
static void log_args(int argc, char *argv[]) { int i; ssize_t r; pid_t parent; char buf[80]; FILE *fp; char caller_buf[PATH_MAX]; log_open(); /* delimiter */ log_str(NULL, "##### LOG #####"); /* Can we tell who called us? */ parent = getppid(); snprintf(buf, sizeof(buf), "/proc/%d/exe", parent); r = readlink(buf, caller_buf, sizeof(caller_buf) - 1); if (r >= 0) { caller_buf[r] = '\0'; log_str("CALLER:", caller_buf); } /* From where? */ snprintf(buf, sizeof(buf), "/proc/%d/cwd", parent); r = readlink(buf, caller_buf, sizeof(caller_buf) - 1); if (r >= 0) { caller_buf[r] = '\0'; log_str("DIR:", caller_buf); } /* And maybe the args? */ snprintf(buf, sizeof(buf), "/proc/%d/cmdline", parent); fp = fopen(buf, "r"); if (fp) { memset(caller_buf, 0, sizeof(caller_buf)); r = fread(caller_buf, 1, sizeof(caller_buf) - 1, fp); if (r > 0) { char *s = caller_buf; for (i = 0; i < r && *s; ) { log_str("CMDLINE:", s); while (i < r && *s) i++, s++; i++, s++; } } fclose(fp); } /* Now log the stuff about ourselves */ for (i = 0; i < argc; i++) log_str(NULL, argv[i]); log_close(); }
static int tcp_srv_csock_event(tcp_srv_t *srv, int fd) { if (tcp_srv_csock_accept(srv) < 0) { log_str("WARNING: Service connection socket shut down"); log_str("WARNING: Remote clients won't be able to connect any more"); tcp_sock_shutdown(&srv->csock); return 0; } return 1; }
/* *** External visible functions *** */ void elect() { // Delete current if terminated (so a terminated process does not wait at the end of list) if (current_process->status == TERMINATED) { terminate_if_last_process(); current_process->previous->next = current_process->next; current_process->next->previous = current_process->previous; struct pcb_s* process_to_delete = current_process; choose_next_process(); free_process(process_to_delete); } else if (current_process->status == BLOCKED) { choose_next_process(); } else { current_process->status = READY; choose_next_process(); } #if DEBUG #if FB fb_print_char('\n'); fb_print_text("The process with PID "); fb_print_int(current_process->pid); fb_print_text(" chosen with priority "); fb_print_int(current_process->priority); fb_print_char('\n'); #else log_str("\n The process with PID "); log_int(current_process->pid); log_str(" chosen with priority "); log_int(current_process->priority); log_str("\n"); #endif #endif if (current_process->status == TERMINATED || current_process->status == BLOCKED) elect(); // Elect the next one, and delete the current one else current_process->status = RUNNING; // Else, this one is now running }
static int netif_watch_event(netif_watch_t *w, int fd) { struct iovec iov; struct msghdr smsg; struct cmsghdr *cmsg; struct ucred *cred; char cred_msg[CMSG_SPACE(sizeof(struct ucred))]; ssize_t bytes; log_debug(3, "netif_watch_event"); iov.iov_base = w->buf; iov.iov_len = sizeof(w->buf); smsg.msg_name = NULL; smsg.msg_namelen = 0; smsg.msg_iov = &iov; smsg.msg_iovlen = 1; smsg.msg_control = cred_msg; smsg.msg_controllen = sizeof(cred_msg); smsg.msg_flags = MSG_DONTWAIT; if ((bytes = recvmsg(fd, &smsg, 0)) < 0) { if ((errno == EAGAIN) || (errno == EINTR)) { return 1; } log_str("ERROR: netlink recvmsg(): %s", strerror(errno)); return 0; } cmsg = CMSG_FIRSTHDR(&smsg); if ((cmsg == NULL) || (cmsg->cmsg_type != SCM_CREDENTIALS)) { log_str("WARNING: netlink recvmsg(): No sender credentials received, ignoring data."); return 1; } cred = (struct ucred*) CMSG_DATA(cmsg); if (cred->pid != 0) { return 1; } /* Throw event with lowpass filtering */ if (w->timeout_tag) { sys_remove(w->timeout_tag); } w->timeout_tag = sys_timeout(NETIF_WATCH_LOWPASS_DELAY, (sys_func_t) netif_watch_process, w); return 1; }
static int uevent_init(void) { #ifdef HAKIT_UEVENT_ENABLED int sock; int buffersize; struct sockaddr_nl snl; /* Do nothing if uevent listening is already initialised */ if (uevent_tag > 0) { return 0; } sock = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_KOBJECT_UEVENT); if (sock == -1) { log_str("ERROR: uevent socket: %s", strerror(errno)); return -1; } /* We're trying to override buffer size. If we fail, we attempt to set a big buffer and pray */ buffersize = 16 * 1024 * 1024; if (setsockopt(sock, SOL_SOCKET, SO_RCVBUFFORCE, &buffersize, sizeof(buffersize))) { /* Somewhat safe default. */ buffersize = 106496; if (setsockopt(sock, SOL_SOCKET, SO_RCVBUF, &buffersize, sizeof(buffersize))) { close(sock); log_str("ERROR: uevent setsockopt: %s", strerror(errno)); return -1; } } memset(&snl, 0x00, sizeof(struct sockaddr_nl)); snl.nl_family = AF_NETLINK; snl.nl_pid = getpid(); snl.nl_groups = 1; if (bind(sock, (struct sockaddr *) &snl, sizeof(struct sockaddr_nl))) { close(sock); log_str("ERROR: uevent bind: %s", strerror(errno)); return -1; } uevent_tag = sys_io_watch(sock, uevent_event, NULL); return 0; #else log_str("ERROR: Netlink uevent not supported by this kernel"); return -1; #endif /* HAKIT_UEVENT_ENABLED */ }
static void log_msg(struct logmsg_struct *msg) { unsigned char msgtxt[5]; int mpos = 0; switch (msg->ctrl & LOG_TYPE_MASK) { case LOG_TYPE_CHAR: { uint32_t ch; ch = msg->log_data; while (ch != 0) { msgtxt[mpos++] = ch&0xFF; ch >>= 8; } msgtxt[mpos] = 0; log_str(msgtxt); break; } case LOG_TYPE_INTEGER: { dbg_raw_nro(msg->ctrl, msg->log_data); break; } default: break; } if (msg->ctrl & LOG_EOL) log_eol(); }
static int udp_srv_event(udp_srv_t *srv, int fd) { unsigned int iremote_size = sizeof(srv->iremote); char buf[1500]; int len; memset(&srv->iremote, 0, iremote_size); len = recvfrom(fd, buf, sizeof(buf), 0, (struct sockaddr *) &srv->iremote, &iremote_size); if (len < 0) { log_str("ERROR: recvfrom: %s", strerror(errno)); return 0; } /* Reject datagrams from myself */ if (netif_foreach_interface(&srv->iremote, udp_srv_local_addr)) { log_debug(2, "udp_srv_event: filtered packet from %s", ip_addr(NULL, &srv->iremote)); return 1; } log_debug(2, "udp_srv_event: %d bytes from %s", len, ip_addr(NULL, &srv->iremote)); if (srv->chan.func != NULL) { srv->chan.func(srv->chan.user_data, buf, len); } return 1; }
bool DebugLayer::create_test_triangle(void) { HRESULT res; D3D11_BUFFER_DESC buf_desc; D3D11_SUBRESOURCE_DATA initial_data; Vector3 verts[3]; buf_desc.BindFlags = D3D11_BIND_VERTEX_BUFFER; buf_desc.ByteWidth = sizeof(Vector3) * 3; buf_desc.CPUAccessFlags = 0; buf_desc.MiscFlags = 0; buf_desc.StructureByteStride = 0; buf_desc.Usage = D3D11_USAGE_DEFAULT; memset(&initial_data, 0, sizeof(D3D11_SUBRESOURCE_DATA)); initial_data.pSysMem = &verts; if (FAILED(res = this->renderer->GetDevice()->CreateBuffer( &buf_desc, &initial_data, &this->test_tri_vbuffer))) { log_str("CreateBuffer error: %s\n", get_err_str(res)); return false; } }
int get_ncpus() { FILE * fp; char * line = NULL; size_t len = 0; ssize_t read; int i, cpu; cpu = 0; fp = fopen("/proc/stat", "r"); if (fp == NULL){ log_str("failed to read /proc/stat", LOG_WARNING); return; } while ((read = getline(&line, &len, fp)) != -1) { if(line[0] == 'c' && line[3] != ' ') cpu++; else if(line[3] == ' ') continue; else break; } if (line) free(line); fclose(fp); return cpu; }
int main(int argc, char *argv[]) { log_init(NAME); if (options_parse(&argc, argv) != 0) { exit(1); } sys_init(); if (comm_init()) { exit(2); } log_str("Test mode: %d", opt_mode); if (opt_mode) { comm_sink_register("A", (comm_sink_func_t) sink_event, NULL); comm_source_register("B", 0); } else { comm_sink_register("B", (comm_sink_func_t) sink_event, NULL); comm_source_register("A", 0); } sys_run(); return 0; }
int usbhidSetReport(usbDevice_t* device, char* buffer, int len) { BOOLEAN rval = HidD_SetFeature((HANDLE)device, buffer, len); if (rval == FALSE) log_str("--- HidD_SetFeature(); GetLastError() == " + GetErrorString(GetLastError()) + "\n"); return rval == 0 ? USBOPEN_ERR_IO : USBOPEN_SUCCESS; }
int udp_srv_init(udp_srv_t *srv, int port, io_func_t func, void *user_data) { struct sockaddr_in ilocal; int fd; udp_srv_clear(srv); /* Create network socket */ fd = socket(PF_INET, SOCK_DGRAM, 0); if (fd < 0) { log_str("ERROR: socket(PF_INET, SOCK_DGRAM): %s", strerror(errno)); return -1; } int optval = 1; setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval)); /* Bind network socket */ memset(&ilocal, 0, sizeof(ilocal)); ilocal.sin_family = AF_INET; ilocal.sin_addr.s_addr = htonl(INADDR_ANY); ilocal.sin_port = htons(port); if (bind(fd, (struct sockaddr *) &ilocal, sizeof(ilocal)) == -1) { log_str("ERROR: bind(%d): %s", port, strerror(errno)); close(fd); return -1; } log_str("Listening to UDP datagrams from port %d", port); /* Prevent child processes from inheriting this socket */ fcntl(fd, F_SETFD, FD_CLOEXEC); io_blocking(fd, 0); srv->chan.fd = fd; srv->chan.tag = sys_io_watch(fd, (sys_io_func_t) udp_srv_event, srv); srv->chan.func = func; srv->chan.user_data = user_data; srv->port = port; return 0; }
int tcp_srv_init(tcp_srv_t *srv, int port, tcp_func_t func, void *user_data) { struct sockaddr_in ilocal; tcp_srv_clear(srv); /* Create network socket */ if ((srv->csock.chan.fd = socket(PF_INET, SOCK_STREAM, 0)) == -1) { log_str("ERROR: socket(PF_INET, SOCK_STREAM): %s", strerror(errno)); return -1; } setsockopt_int(srv->csock.chan.fd, SOL_SOCKET, SO_REUSEADDR, 1); /* Bind network socket */ ilocal.sin_family = AF_INET; ilocal.sin_addr.s_addr = htonl(INADDR_ANY); ilocal.sin_port = htons(port); if (bind(srv->csock.chan.fd, (struct sockaddr *) &ilocal, sizeof(ilocal)) == -1) { log_str("ERROR: bind(%d): %s", port, strerror(errno)); close(srv->csock.chan.fd); srv->csock.chan.fd = -1; return -1; } /* Listen to network connection (with backlog of maximum 1 pending connection) */ if (listen(srv->csock.chan.fd, 1) == -1) { log_str("ERROR: listen: %s", strerror(errno)); close(srv->csock.chan.fd); srv->csock.chan.fd = -1; return -1; } log_str("Listening to TCP connections from port %d", port); /* Prevent child processes from inheriting this socket */ fcntl(srv->csock.chan.fd, F_SETFD, FD_CLOEXEC); srv->csock.chan.tag = sys_io_watch(srv->csock.chan.fd, (sys_io_func_t) tcp_srv_csock_event, srv); srv->func = func; srv->user_data = user_data; return 0; }
static int setsockopt_int(int sock, int level, int optname, int optval) { int ret = setsockopt(sock, level, optname, &optval, sizeof(optval)); if (ret < 0) { log_str("ERROR: setsockopt: %s", strerror(errno)); } return ret; }
void msg_str(const char* buf) { if(buf[0]=='<') { char*z = "fewnvdt"; char*x = strchr(z,buf[1]); if(x && (x-z)>maxloglevel) return; } log_str(buf); }
static int uevent_event(void *arg, int fd) { uevent_data_t d; char *action = NULL; char *subsystem = NULL; int i; d.size = recv(fd, &d.buf, sizeof(d.buf), 0); if (d.size < 0) { log_str("ERROR: uevent recv: %s", strerror(errno)); close(fd); return 0; } log_debug(3, "uevent_event: %d bytes received", d.size); i = 0; while (i < d.size) { char *str = d.buf + i; int len = strlen(str); log_debug(3, " %s", str); if (strncmp(str, "ACTION=", 7) == 0) { action = str + 7; } else if (strncmp(str, "SUBSYSTEM=", 10) == 0) { subsystem = str + 10; } i += len + 1; } log_debug(2, "uevent_event: action='%s' subsystem='%s'", action, subsystem); for (i = 0; i < uevent_nhooks; i++) { uevent_hook_t *hook = &uevent_hooks[i]; if (hook->action != NULL) { if ((action == NULL) || strcmp(action, hook->action)) { continue; } } if (hook->subsystem != NULL) { if ((subsystem == NULL) || strcmp(subsystem, hook->subsystem)) { continue; } } if (hook->func != NULL) { hook->func(hook->user_data, &d); } } return 1; }
static int tcp_srv_csock_accept(tcp_srv_t *srv) { int sock; socklen_t size; int dnum; /* Accept client connection */ size = sizeof(srv->iremote); sock = accept(srv->csock.chan.fd, (struct sockaddr *) &srv->iremote, &size); if ( sock < 0 ) { log_str("ERROR: accept [%d]: %s", srv->csock.chan.fd, strerror(errno)); return -1; } /* Find an available data socket */ for (dnum = 0; dnum < SRV_DSOCK_MAX; dnum++) { if (srv->dsock[dnum].chan.fd < 0) break; } if (dnum >= SRV_DSOCK_MAX) { log_str("WARNING: Too many connections"); close(sock); return -1; } /* Prevent child processes from inheriting this socket */ fcntl(sock, F_SETFD, FD_CLOEXEC); /* Hook an IO watch on this socket */ tcp_sock_setup(&srv->dsock[dnum], sock, srv->func, srv->user_data); /* Signal connection */ char *s_addr = ip_addr(NULL, &srv->iremote); log_str("Incomming connection [%d] established from %s", sock, s_addr); if (srv->func != NULL) { srv->func(&srv->dsock[dnum], TCP_IO_CONNECT, s_addr, strlen(s_addr)); } return 0; }
int udp_srv_send_bcast(udp_srv_t *srv, char *buf, int size) { int ssize; ssize = udp_send_bcast(srv->chan.fd, srv->port, buf, size); if (ssize < 0) { log_str("ERROR: udp_srv_bcast(%d): %s", srv->port, strerror(errno)); return -1; } return 0; }
int udp_srv_send_reply(udp_srv_t *srv, char *buf, int size) { int ssize; ssize = sendto(srv->chan.fd, buf, size, 0, (struct sockaddr *) &srv->iremote, sizeof(srv->iremote)); if (ssize < 0) { log_str("ERROR: udp_srv_write(%s): %s", ip_addr(NULL, &srv->iremote), strerror(errno)); return -1; } return 0; }
static void tcp_sock_event(tcp_sock_t *tcp_sock, char *buf, int len) { if (tcp_sock->func != NULL) { tcp_io_t io = buf ? TCP_IO_DATA : TCP_IO_HUP; tcp_sock->func(tcp_sock, io, buf, len); } if (buf == NULL) { log_str("Connection [%d] closed by peer", tcp_sock->chan.fd); tcp_sock_shutdown_(tcp_sock, 1); } }
int netif_watch_init(netif_watch_t *w, netif_watch_callback_t watch_callback, void *user_data) { const int on = 1; struct sockaddr_nl addr; w->sock = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE); if (w->sock < 0) { log_str("ERROR: netif netlink socket: %s", strerror(errno)); goto failed; } memset(&addr, 0, sizeof(addr)); addr.nl_family = AF_NETLINK; addr.nl_groups = RTMGRP_LINK|RTMGRP_IPV4_IFADDR|RTMGRP_IPV6_IFADDR; addr.nl_pid = 0; if (bind(w->sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) { log_str("ERROR: netif netlink bind: %s", strerror(errno)); goto failed; } if (setsockopt(w->sock, SOL_SOCKET, SO_PASSCRED, &on, sizeof(on)) < 0) { log_str("ERROR: netif netlink setsockopt: %s", strerror(errno)); goto failed; } w->io_tag = sys_io_watch(w->sock, (sys_io_func_t) netif_watch_event, w); w->callback = watch_callback; w->user_data = user_data; return 0; failed: if (w->sock >= 0) { close(w->sock); w->sock = -1; } return -1; }
int tcp_sock_connect(tcp_sock_t *tcp_sock, char *host, int port, tcp_func_t func, void *user_data) { struct hostent *hp; struct sockaddr_in iremote; int sock; log_debug(2, "tcp_sock_connect: host='%s' port=%d", host, port); /* Retrieve server address */ if ((hp = gethostbyname(host)) == NULL ) { log_str("ERROR: Unknown host name: %s", host); return -1; } /* Create network socket */ sock = socket(AF_INET, SOCK_STREAM, 0); if (sock == -1 ) { log_str("ERROR: socket: %s", strerror(errno)); return -1; } /* Connect to server */ iremote.sin_family = AF_INET; memcpy(&iremote.sin_addr.s_addr, hp->h_addr, hp->h_length); iremote.sin_port = htons(port); if (connect(sock, (struct sockaddr *) &iremote, sizeof(iremote)) == -1 ) { log_str("ERROR: connect(%s:%d): %s", host, port, strerror(errno)); close(sock); return -1; } /* Signal connection */ char *s_addr = ip_addr(NULL, &iremote); log_str("Outgoing connection [%d] established to %s", sock, s_addr); tcp_sock_setup(tcp_sock, sock, func, user_data); return sock; }
/** * Logs a block of data in a pretty hex format * Numbers on the left, characters on the right, just like I like it. * * @param sev The severity * @param data The data to log * @param len The number of bytes to log */ void log_hex_blk(log_sev_t sev, const void *data, int len) { static char buf[80] = "nnn | XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX | cccccccccccccccc\n"; const UINT8 *dat = (const UINT8 *)data; int idx; int count; int str_idx = 0; int chr_idx = 0; int tmp; int total; if ((data == NULL) || (len <= 0) || !log_sev_on(sev)) { return; } /* * Dump the specified number of bytes in hex, 16 byte per line by * creating a string and then calling log_str() */ /* Loop through the data of the current iov */ count = 0; total = 0; for (idx = 0; idx < len; idx++) { if (count == 0) { str_idx = 6; chr_idx = 56; buf[0] = to_hex_char(total >> 12); buf[1] = to_hex_char(total >> 8); buf[2] = to_hex_char(total >> 4); } tmp = dat[idx]; buf[str_idx] = to_hex_char(tmp >> 4); buf[str_idx + 1] = to_hex_char(tmp); str_idx += 3; buf[chr_idx++] = unc_isprint(tmp) ? tmp : '.'; total++; count++; if (count >= 16) { count = 0; log_str(sev, buf, 73); } }