/**
* 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);
}
}
