void handle_pcap_read_result(mspool *ms, msevent *nse, enum nse_status status) {
msiod *iod = nse->iod;
mspcap *mp = (mspcap *)iod->pcap;
if (status == NSE_STATUS_TIMEOUT) {
nse->status = NSE_STATUS_TIMEOUT;
nse->event_done = 1;
} else if (status == NSE_STATUS_CANCELLED) {
nse->status = NSE_STATUS_CANCELLED;
nse->event_done = 1;
} else if (status == NSE_STATUS_SUCCESS) {
/* check if we already have something read */
if (FILESPACE_LENGTH(&(nse->iobuf)) == 0) {
nse->status = NSE_STATUS_TIMEOUT;
nse->event_done = 0;
} else {
nse->status = NSE_STATUS_SUCCESS; /* we have full buffer */
nse->event_done = 1;
}
} else {
assert(0); /* Currently we only know about TIMEOUT, CANCELLED, and SUCCESS callbacks */
}
/* If there are no more read events, we are done reading on the socket so we
* can take it off the descriptor list... */
if (nse->event_done && mp->pcap_desc >= 0) {
int ev;
ev = socket_count_readpcap_dec(iod);
update_events(iod, ms, EV_NONE, ev);
}
}
// three_hz_loop - 3.3hz loop
void Sub::three_hz_loop()
{
set_leak_status(leak_detector.update());
failsafe_internal_pressure_check();
failsafe_internal_temperature_check();
// check if we've lost contact with the ground station
failsafe_gcs_check();
// check if we've lost terrain data
failsafe_terrain_check();
#if AC_FENCE == ENABLED
// check if we have breached a fence
fence_check();
#endif // AC_FENCE_ENABLED
update_events();
#if CH6_TUNE_ENABLED == ENABLED
// update ch6 in flight tuning
tuning();
#endif
}
static void
htsp_channelAddUpdate(htsp_connection_t *hc, htsmsg_t *m, int create)
{
uint32_t id, next;
int chnum;
char txt[200];
const char *title, *icon;
htsp_channel_t *ch;
if(htsmsg_get_u32(m, "channelId", &id))
return;
title = htsmsg_get_str(m, "channelName");
icon = htsmsg_get_str(m, "channelIcon");
chnum = htsmsg_get_s32_or_default(m, "channelNumber", -1);
snprintf(txt, sizeof(txt), "%d", id);
hts_mutex_lock(&hc->hc_meta_mutex);
if(create) {
ch = htsp_channel_get(hc, id, 1);
if(prop_set_parent(ch->ch_root, hc->hc_channels_nodes))
abort();
} else {
ch = htsp_channel_get(hc, id, 0);
if(ch == NULL) {
TRACE(TRACE_ERROR, "HTSP", "Got update for unknown channel %d", id);
hts_mutex_unlock(&hc->hc_meta_mutex);
return;
}
}
hts_mutex_unlock(&hc->hc_meta_mutex);
if(icon != NULL)
prop_set_string(ch->ch_prop_icon, icon);
if(title != NULL) {
mystrset(&ch->ch_title, title);
prop_set_string(ch->ch_prop_title, title);
}
if(chnum != -1)
prop_set_int(ch->ch_prop_channelNumber, chnum);
if(htsmsg_get_u32(m, "eventId", &id))
id = 0;
if(htsmsg_get_u32(m, "nextEventId", &next))
next = 0;
update_events(hc, ch->ch_prop_events, id, next);
}
bool AP_ServoRelayEvents::do_repeat_relay(uint8_t relay_num, int16_t _repeat, uint32_t _delay_ms)
{
if (!relay.enabled(relay_num)) {
return false;
}
type = EVENT_TYPE_RELAY;
channel = relay_num;
start_time_ms = 0;
delay_ms = _delay_ms/2; // half cycle time
repeat = _repeat*2; // number of full cycles
update_events();
return true;
}
static void client_io(evutil_socket_t fd, short events, void *private_data)
{
struct client *client = private_data;
struct server *server;
int revents = 0;
if (events & EV_READ) {
revents |= POLLIN;
}
if (events & EV_WRITE) {
revents |= POLLOUT;
}
if (rpc_service(client->rpc, revents) < 0) {
fprintf(stderr, "rpc_service failed\n");
exit(10);
}
update_events(client->rpc, client->read_event, client->write_event);
if (client->is_finished) {
/*
* Stop listening for new connections.
*/
event_free(client->listen_event);
client->listen_event = NULL;
/*
* Stop listening for events on the client context.
*/
event_free(client->read_event);
client->read_event = NULL;
event_free(client->write_event);
client->write_event = NULL;
/*
* Stop listening to server connections.
*/
for (server = server_list; server; server = server->next) {
if (server->read_event) {
event_free(server->read_event);
server->read_event = NULL;
}
if (server->write_event) {
event_free(server->write_event);
server->write_event = NULL;
}
}
}
}
bool AP_ServoRelayEvents::do_repeat_servo(uint8_t _channel, uint16_t _servo_value,
int16_t _repeat, uint16_t _delay_ms)
{
if (!(mask & 1U<<(_channel-1))) {
// not allowed
return false;
}
channel = _channel;
type = EVENT_TYPE_SERVO;
start_time_ms = 0;
delay_ms = _delay_ms / 2;
repeat = _repeat * 2;
servo_value = _servo_value;
update_events();
return true;
}
static void save_settings(struct trace_capture *cap, const char *filename)
{
struct shark_info *info = cap->info;
struct tracecmd_xml_handle *handle;
const char *file;
const char *command;
handle = tracecmd_xml_create(filename, VERSION_STRING);
if (!handle) {
warning("Could not create %s", filename);
return;
}
update_events(cap);
tracecmd_xml_start_system(handle, "CaptureSettings");
tracecmd_xml_start_sub_system(handle, "Events");
if (info->cap_all_events)
tracecmd_xml_write_element(handle, "CaptureType", "all events");
else if ((info->cap_systems && info->cap_systems[0]) ||
(info->cap_events && info->cap_events[0] >= 0)) {
save_events(cap, handle);
}
tracecmd_xml_end_sub_system(handle);
update_plugin(cap);
if (info->cap_plugin)
tracecmd_xml_write_element(handle, "Plugin", info->cap_plugin);
command = gtk_entry_get_text(GTK_ENTRY(cap->command_entry));
if (command && strlen(command) && !is_just_ws(command))
tracecmd_xml_write_element(handle, "Command", command);
file = gtk_entry_get_text(GTK_ENTRY(cap->file_entry));
if (file && strlen(file) && !is_just_ws(file))
tracecmd_xml_write_element(handle, "File", file);
tracecmd_xml_end_system(handle);
tracecmd_xml_close(handle);
}
static void server_io(evutil_socket_t fd, short events, void *private_data)
{
struct server *server = private_data;
int revents = 0;
if (events & EV_READ) {
revents |= POLLIN;
}
if (events & EV_WRITE) {
revents |= POLLOUT;
}
if (rpc_service(server->rpc, revents) < 0) {
fprintf(stderr, "rpc_service() failed for server\n");
exit(10);
}
update_events(server->rpc, server->read_event, server->write_event);
}
// three_hz_loop - 3.3hz loop
void Copter::three_hz_loop()
{
// check if we've lost contact with the ground station
failsafe_gcs_check();
#if AC_FENCE == ENABLED
// check if we have breached a fence
fence_check();
#endif // AC_FENCE_ENABLED
#if SPRAYER == ENABLED
sprayer.update();
#endif
update_events();
// update ch6 in flight tuning
tuning();
}
/*
* This callback is invoked when others (the nfsv4 server) initiates a
* NFSv4 CALLBACK sessions to us.
* We accept() the connection and create a local rpc server context
* for the callback protocol.
*/
static void client_accept(evutil_socket_t s, short events, void *private_data)
{
struct client *client = private_data;
struct server *server;
struct sockaddr_storage ss;
socklen_t len = sizeof(ss);
int fd;
server = malloc(sizeof(struct server));
if (server == NULL) {
fprintf(stderr, "failed to malloc server structure\n");
exit(10);
}
memset(server, 0, sizeof(*server));
server->next = server_list;
server_list = server;
if ((fd = accept(s, (struct sockaddr *)&ss, &len)) < 0) {
free_server(server);
fprintf(stderr, "accept failed\n");
exit(10);
}
evutil_make_socket_nonblocking(fd);
server->rpc = rpc_init_server_context(fd);
if (server->rpc == NULL) {
free_server(server);
fprintf(stderr, "Failed to create server rpc context\n");
exit(10);
}
rpc_register_service(server->rpc, NFS4_CALLBACK, NFS_CB,
pt, sizeof(pt) / sizeof(pt[0]));
server->read_event = event_new(base, fd, EV_READ|EV_PERSIST,
server_io, server);
server->write_event = event_new(base, fd, EV_WRITE|EV_PERSIST,
server_io, server);
update_events(server->rpc, server->read_event, server->write_event);
}
void handle_pcap_read_result(struct npool *ms, struct nevent *nse, enum nse_status status) {
struct niod *iod = nse->iod;
mspcap *mp = (mspcap *)iod->pcap;
switch (status) {
case NSE_STATUS_TIMEOUT:
nse->status = NSE_STATUS_TIMEOUT;
nse->event_done = 1;
break;
case NSE_STATUS_CANCELLED:
nse->status = NSE_STATUS_CANCELLED;
nse->event_done = 1;
break;
case NSE_STATUS_SUCCESS:
/* check if we already have something read */
if (fs_length(&(nse->iobuf)) == 0) {
nse->status = NSE_STATUS_TIMEOUT;
nse->event_done = 0;
} else {
nse->status = NSE_STATUS_SUCCESS; /* we have full buffer */
nse->event_done = 1;
}
break;
default:
fatal("Unknown status (%d) for nsock event #%lu", status, nse->id);
}
/* If there are no more read events, we are done reading on the socket so we
* can take it off the descriptor list... */
if (nse->event_done && mp->pcap_desc >= 0) {
int ev;
ev = socket_count_readpcap_dec(iod);
update_events(iod, ms, EV_NONE, ev);
}
}
static PDDebugState update(void* user_data, PDAction action, PDReader* reader, PDWriter* writer) {
PluginData* plugin = (PluginData*)user_data;
plugin->has_updated_registers = false;
plugin->has_updated_exception_location = false;
on_action(plugin, action);
process_events(plugin, reader, writer);
update_events(plugin);
if (plugin->has_updated_registers) {
log_debug("sending registens\n", "");
PDWrite_event_begin(writer, PDEventType_SetRegisters);
PDWrite_array_begin(writer, "registers");
write_status_registers(writer, "flags", plugin->regs.flags);
write_register(writer, "pc", 2, plugin->regs.pc, 1);
write_register(writer, "sp", 1, plugin->regs.sp, 0);
write_register(writer, "a", 1, plugin->regs.a, 0);
write_register(writer, "x", 1, plugin->regs.x, 0);
write_register(writer, "y", 1, plugin->regs.y, 0);
PDWrite_array_end(writer);
PDWrite_event_end(writer);
}
if (plugin->has_updated_exception_location) {
PDWrite_event_begin(writer, PDEventType_SetExceptionLocation);
PDWrite_u64(writer, "address", plugin->regs.pc);
PDWrite_u8(writer, "address_size", 2);
PDWrite_event_end(writer);
}
return plugin->state;
}
void handle_read_result(struct npool *ms, struct nevent *nse, enum nse_status status) {
unsigned int count;
char *str;
int rc, len;
struct niod *iod = nse->iod;
if (status == NSE_STATUS_TIMEOUT) {
nse->event_done = 1;
if (fs_length(&nse->iobuf) > 0)
nse->status = NSE_STATUS_SUCCESS;
else
nse->status = NSE_STATUS_TIMEOUT;
} else if (status == NSE_STATUS_CANCELLED) {
nse->status = status;
nse->event_done = 1;
} else if (status == NSE_STATUS_SUCCESS) {
rc = do_actual_read(ms, nse);
/* printf("DBG: Just read %d new bytes%s.\n", rc, iod->ssl? "( SSL!)" : ""); */
if (rc > 0) {
nse->iod->read_count += rc;
/* We decide whether we have read enough to return */
switch (nse->readinfo.read_type) {
case NSOCK_READ:
nse->status = NSE_STATUS_SUCCESS;
nse->event_done = 1;
break;
case NSOCK_READBYTES:
if (fs_length(&nse->iobuf) >= nse->readinfo.num) {
nse->status = NSE_STATUS_SUCCESS;
nse->event_done = 1;
}
/* else we are not done */
break;
case NSOCK_READLINES:
/* Lets count the number of lines we have ... */
count = 0;
len = fs_length(&nse->iobuf) -1;
str = fs_str(&nse->iobuf);
for (count=0; len >= 0; len--) {
if (str[len] == '\n') {
count++;
if ((int)count >= nse->readinfo.num)
break;
}
}
if ((int) count >= nse->readinfo.num) {
nse->event_done = 1;
nse->status = NSE_STATUS_SUCCESS;
}
/* Else we are not done */
break;
default:
fatal("Unknown operation type (%d)", (int)nse->readinfo.read_type);
}
}
} else {
fatal("Unknown status (%d)", status);
}
/* If there are no more reads for this IOD, we are done reading on the socket
* so we can take it off the descriptor list ... */
if (nse->event_done && iod->sd >= 0) {
int ev = EV_NONE;
#if HAVE_OPENSSL
if (nse->iod->ssl != NULL)
ev |= socket_count_dec_ssl_desire(nse);
else
#endif
ev |= socket_count_read_dec(nse->iod);
update_events(nse->iod, ms, EV_NONE, ev);
}
}
/* Returns -1 if an error, otherwise the number of newly written bytes */
static int do_actual_read(struct npool *ms, struct nevent *nse) {
char buf[8192];
int buflen = 0;
struct niod *iod = nse->iod;
int err = 0;
int max_chunk = NSOCK_READ_CHUNK_SIZE;
int startlen = fs_length(&nse->iobuf);
if (nse->readinfo.read_type == NSOCK_READBYTES)
max_chunk = nse->readinfo.num;
if (!iod->ssl) {
do {
struct sockaddr_storage peer;
socklen_t peerlen;
peerlen = sizeof(peer);
buflen = recvfrom(iod->sd, buf, sizeof(buf), 0, (struct sockaddr *)&peer, &peerlen);
/* Using recv() was failing, at least on UNIX, for non-network sockets
* (i.e. stdin) in this case, a read() is done - as on ENOTSOCK we may
* have a non-network socket */
if (buflen == -1) {
if (socket_errno() == ENOTSOCK) {
peer.ss_family = AF_UNSPEC;
peerlen = 0;
buflen = read(iod->sd, buf, sizeof(buf));
}
}
if (buflen == -1) {
err = socket_errno();
break;
}
if (peerlen > 0) {
assert(peerlen <= sizeof(iod->peer));
memcpy(&iod->peer, &peer, peerlen);
iod->peerlen = peerlen;
}
if (buflen > 0) {
if (fs_cat(&nse->iobuf, buf, buflen) == -1) {
nse->event_done = 1;
nse->status = NSE_STATUS_ERROR;
nse->errnum = ENOMEM;
return -1;
}
/* Sometimes a service just spews and spews data. So we return after a
* somewhat large amount to avoid monopolizing resources and avoid DOS
* attacks. */
if (fs_length(&nse->iobuf) > max_chunk)
return fs_length(&nse->iobuf) - startlen;
/* No good reason to read again if we we were successful in the read but
* didn't fill up the buffer. Especially for UDP, where we want to
* return only one datagram at a time. The consistency of the above
* assignment of iod->peer depends on not consolidating more than one
* UDP read buffer. */
if (buflen > 0 && buflen < sizeof(buf))
return fs_length(&nse->iobuf) - startlen;
}
} while (buflen > 0 || (buflen == -1 && err == EINTR));
if (buflen == -1) {
if (err != EINTR && err != EAGAIN) {
nse->event_done = 1;
nse->status = NSE_STATUS_ERROR;
nse->errnum = err;
return -1;
}
}
} else {
#if HAVE_OPENSSL
/* OpenSSL read */
while ((buflen = SSL_read(iod->ssl, buf, sizeof(buf))) > 0) {
if (fs_cat(&nse->iobuf, buf, buflen) == -1) {
nse->event_done = 1;
nse->status = NSE_STATUS_ERROR;
nse->errnum = ENOMEM;
return -1;
}
/* Sometimes a service just spews and spews data. So we return
* after a somewhat large amount to avoid monopolizing resources
* and avoid DOS attacks. */
if (fs_length(&nse->iobuf) > max_chunk)
return fs_length(&nse->iobuf) - startlen;
}
if (buflen == -1) {
err = SSL_get_error(iod->ssl, buflen);
if (err == SSL_ERROR_WANT_READ) {
int evclr;
evclr = socket_count_dec_ssl_desire(nse);
socket_count_read_inc(iod);
update_events(iod, ms, EV_READ, evclr);
nse->sslinfo.ssl_desire = err;
} else if (err == SSL_ERROR_WANT_WRITE) {
int evclr;
evclr = socket_count_dec_ssl_desire(nse);
socket_count_write_inc(iod);
update_events(iod, ms, EV_WRITE, evclr);
nse->sslinfo.ssl_desire = err;
} else {
/* Unexpected error */
nse->event_done = 1;
nse->status = NSE_STATUS_ERROR;
nse->errnum = EIO;
nsock_log_info("SSL_read() failed for reason %s on NSI %li",
ERR_error_string(err, NULL), iod->id);
return -1;
}
}
#endif /* HAVE_OPENSSL */
}
if (buflen == 0) {
nse->event_done = 1;
nse->eof = 1;
if (fs_length(&nse->iobuf) > 0) {
nse->status = NSE_STATUS_SUCCESS;
return fs_length(&nse->iobuf) - startlen;
} else {
nse->status = NSE_STATUS_EOF;
return 0;
}
}
return fs_length(&nse->iobuf) - startlen;
}
void handle_write_result(struct npool *ms, struct nevent *nse, enum nse_status status) {
int bytesleft;
char *str;
int res;
int err;
struct niod *iod = nse->iod;
if (status == NSE_STATUS_TIMEOUT || status == NSE_STATUS_CANCELLED) {
nse->event_done = 1;
nse->status = status;
} else if (status == NSE_STATUS_SUCCESS) {
str = fs_str(&nse->iobuf) + nse->writeinfo.written_so_far;
bytesleft = fs_length(&nse->iobuf) - nse->writeinfo.written_so_far;
if (nse->writeinfo.written_so_far > 0)
assert(bytesleft > 0);
#if HAVE_OPENSSL
if (iod->ssl)
res = SSL_write(iod->ssl, str, bytesleft);
else
#endif
if (nse->writeinfo.dest.ss_family == AF_UNSPEC)
res = send(nse->iod->sd, str, bytesleft, 0);
else
res = sendto(nse->iod->sd, str, bytesleft, 0, (struct sockaddr *)&nse->writeinfo.dest, (int)nse->writeinfo.destlen);
if (res == bytesleft) {
nse->event_done = 1;
nse->status = NSE_STATUS_SUCCESS;
} else if (res >= 0) {
nse->writeinfo.written_so_far += res;
} else {
assert(res == -1);
if (iod->ssl) {
#if HAVE_OPENSSL
err = SSL_get_error(iod->ssl, res);
if (err == SSL_ERROR_WANT_READ) {
int evclr;
evclr = socket_count_dec_ssl_desire(nse);
socket_count_read_inc(iod);
update_events(iod, ms, EV_READ, evclr);
nse->sslinfo.ssl_desire = err;
} else if (err == SSL_ERROR_WANT_WRITE) {
int evclr;
evclr = socket_count_dec_ssl_desire(nse);
socket_count_write_inc(iod);
update_events(iod, ms, EV_WRITE, evclr);
nse->sslinfo.ssl_desire = err;
} else {
/* Unexpected error */
nse->event_done = 1;
nse->status = NSE_STATUS_ERROR;
nse->errnum = EIO;
}
#endif
} else {
err = socket_errno();
if (errcode_is_failure(err)) {
nse->event_done = 1;
nse->status = NSE_STATUS_ERROR;
nse->errnum = err;
}
}
}
if (res >= 0)
nse->iod->write_count += res;
}
if (nse->event_done && nse->iod->sd != -1) {
int ev = EV_NONE;
#if HAVE_OPENSSL
if (nse->iod->ssl != NULL)
ev |= socket_count_dec_ssl_desire(nse);
else
#endif
ev |= socket_count_write_dec(nse->iod);
update_events(nse->iod, ms, EV_NONE, ev);
}
}
/* handle_connect_results assumes that select or poll have already shown the
* descriptor to be active */
void handle_connect_result(struct npool *ms, struct nevent *nse, enum nse_status status) {
int optval;
socklen_t optlen = sizeof(int);
struct niod *iod = nse->iod;
#if HAVE_OPENSSL
int sslerr;
int rc = 0;
int sslconnect_inprogress = nse->type == NSE_TYPE_CONNECT_SSL && nse->iod &&
(nse->sslinfo.ssl_desire == SSL_ERROR_WANT_READ ||
nse->sslinfo.ssl_desire == SSL_ERROR_WANT_WRITE);
#else
int sslconnect_inprogress = 0;
#endif
if (status == NSE_STATUS_TIMEOUT || status == NSE_STATUS_CANCELLED) {
nse->status = status;
nse->event_done = 1;
} else if (sslconnect_inprogress) {
/* Do nothing */
} else if (status == NSE_STATUS_SUCCESS) {
/* First we want to determine whether the socket really is connected */
if (getsockopt(iod->sd, SOL_SOCKET, SO_ERROR, (char *)&optval, &optlen) != 0)
optval = socket_errno(); /* Stupid Solaris */
switch (optval) {
case 0:
nse->status = NSE_STATUS_SUCCESS;
break;
/* EACCES can be caused by ICMPv6 dest-unreach-admin, or when a port is
blocked by Windows Firewall (WSAEACCES). */
case EACCES:
case ECONNREFUSED:
case EHOSTUNREACH:
case ENETDOWN:
case ENETUNREACH:
case ENETRESET:
case ECONNABORTED:
case ETIMEDOUT:
case EHOSTDOWN:
case ECONNRESET:
#ifdef WIN32
case WSAEADDRINUSE:
case WSAEADDRNOTAVAIL:
#endif
#ifndef WIN32
case EPIPE: /* Has been seen after connect on Linux. */
case ENOPROTOOPT: /* Also seen on Linux, perhaps in response to protocol unreachable. */
#endif
nse->status = NSE_STATUS_ERROR;
nse->errnum = optval;
break;
default:
/* I'd like for someone to report it */
fatal("Strange connect error from %s (%d): %s",
inet_ntop_ez(&iod->peer, iod->peerlen), optval,
socket_strerror(optval));
}
/* Now special code for the SSL case where the TCP connection was successful. */
if (nse->type == NSE_TYPE_CONNECT_SSL &&
nse->status == NSE_STATUS_SUCCESS) {
#if HAVE_OPENSSL
assert(ms->sslctx != NULL);
/* Reuse iod->ssl if present. If set, this is the second try at connection
without the SSL_OP_NO_SSLv2 option set. */
if (iod->ssl == NULL) {
iod->ssl = SSL_new(ms->sslctx);
if (!iod->ssl)
fatal("SSL_new failed: %s", ERR_error_string(ERR_get_error(), NULL));
}
#if HAVE_SSL_SET_TLSEXT_HOST_NAME
if (iod->hostname != NULL) {
if (SSL_set_tlsext_host_name(iod->ssl, iod->hostname) != 1)
fatal("SSL_set_tlsext_host_name failed: %s", ERR_error_string(ERR_get_error(), NULL));
}
#endif
/* Associate our new SSL with the connected socket. It will inherit the
* non-blocking nature of the sd */
if (SSL_set_fd(iod->ssl, iod->sd) != 1)
fatal("SSL_set_fd failed: %s", ERR_error_string(ERR_get_error(), NULL));
/* Event not done -- need to do SSL connect below */
nse->sslinfo.ssl_desire = SSL_ERROR_WANT_CONNECT;
#endif
} else {
/* This is not an SSL connect (in which case we are always done), or the
* TCP connect() underlying the SSL failed (in which case we are also done */
nse->event_done = 1;
}
} else {
fatal("Unknown status (%d)", status);
}
/* At this point the TCP connection is done, whether successful or not.
* Therefore decrease the read/write listen counts that were incremented in
* nsock_pool_add_event. In the SSL case, we may increase one of the counts depending
* on whether SSL_connect returns an error of SSL_ERROR_WANT_READ or
* SSL_ERROR_WANT_WRITE. In that case we will re-enter this function, but we
* don't want to execute this block again. */
if (iod->sd != -1 && !sslconnect_inprogress) {
int ev = EV_NONE;
ev |= socket_count_read_dec(iod);
ev |= socket_count_write_dec(iod);
ev |= EV_EXCEPT;
update_events(iod, ms, EV_NONE, ev);
}
#if HAVE_OPENSSL
if (nse->type == NSE_TYPE_CONNECT_SSL && !nse->event_done) {
/* Lets now start/continue/finish the connect! */
if (iod->ssl_session) {
rc = SSL_set_session(iod->ssl, iod->ssl_session);
if (rc == 0)
nsock_log_error("Uh-oh: SSL_set_session() failed - please tell [email protected]");
iod->ssl_session = NULL; /* No need for this any more */
}
/* If this is a reinvocation of handle_connect_result, clear out the listen
* bits that caused it, based on the previous SSL desire. */
if (sslconnect_inprogress) {
int ev;
ev = socket_count_dec_ssl_desire(nse);
update_events(iod, ms, EV_NONE, ev);
}
rc = SSL_connect(iod->ssl);
if (rc == 1) {
/* Woop! Connect is done! */
nse->event_done = 1;
/* Check that certificate verification was okay, if requested. */
if (nsi_ssl_post_connect_verify(iod)) {
nse->status = NSE_STATUS_SUCCESS;
} else {
nsock_log_error("certificate verification error for EID %li: %s",
nse->id, ERR_error_string(ERR_get_error(), NULL));
nse->status = NSE_STATUS_ERROR;
}
} else {
long options = SSL_get_options(iod->ssl);
sslerr = SSL_get_error(iod->ssl, rc);
if (rc == -1 && sslerr == SSL_ERROR_WANT_READ) {
nse->sslinfo.ssl_desire = sslerr;
socket_count_read_inc(iod);
update_events(iod, ms, EV_READ, EV_NONE);
} else if (rc == -1 && sslerr == SSL_ERROR_WANT_WRITE) {
nse->sslinfo.ssl_desire = sslerr;
socket_count_write_inc(iod);
update_events(iod, ms, EV_WRITE, EV_NONE);
} else if (!(options & SSL_OP_NO_SSLv2)) {
int saved_ev;
/* SSLv3-only and TLSv1-only servers can't be connected to when the
* SSL_OP_NO_SSLv2 option is not set, which is the case when the pool
* was initialized with nsock_pool_ssl_init_max_speed. Try reconnecting
* with SSL_OP_NO_SSLv2. Never downgrade a NO_SSLv2 connection to one
* that might use SSLv2. */
nsock_log_info("EID %li reconnecting with SSL_OP_NO_SSLv2", nse->id);
saved_ev = iod->watched_events;
nsock_engine_iod_unregister(ms, iod);
close(iod->sd);
nsock_connect_internal(ms, nse, SOCK_STREAM, iod->lastproto, &iod->peer,
iod->peerlen, nsock_iod_get_peerport(iod));
nsock_engine_iod_register(ms, iod, saved_ev);
SSL_clear(iod->ssl);
if(!SSL_clear(iod->ssl))
fatal("SSL_clear failed: %s", ERR_error_string(ERR_get_error(), NULL));
SSL_set_options(iod->ssl, options | SSL_OP_NO_SSLv2);
socket_count_read_inc(nse->iod);
socket_count_write_inc(nse->iod);
update_events(iod, ms, EV_READ|EV_WRITE, EV_NONE);
nse->sslinfo.ssl_desire = SSL_ERROR_WANT_CONNECT;
} else {
nsock_log_info("EID %li %s",
nse->id, ERR_error_string(ERR_get_error(), NULL));
nse->event_done = 1;
nse->status = NSE_STATUS_ERROR;
nse->errnum = EIO;
}
}
}
#endif
}
/* Adds an event to the appropriate nsp event list, handles housekeeping such as
* adjusting the descriptor select/poll lists, registering the timeout value,
* etc. */
void nsock_pool_add_event(struct npool *nsp, struct nevent *nse) {
nsock_log_debug("NSE #%lu: Adding event (timeout in %ldms)",
nse->id,
(long)TIMEVAL_MSEC_SUBTRACT(nse->timeout, nsock_tod));
nsp->events_pending++;
if (!nse->event_done && nse->timeout.tv_sec) {
/* This event is expirable, add it to the queue */
gh_heap_push(&nsp->expirables, &nse->expire);
}
/* Now we do the event type specific actions */
switch (nse->type) {
case NSE_TYPE_CONNECT:
case NSE_TYPE_CONNECT_SSL:
if (!nse->event_done) {
assert(nse->iod->sd >= 0);
socket_count_read_inc(nse->iod);
socket_count_write_inc(nse->iod);
update_events(nse->iod, nsp, EV_READ|EV_WRITE|EV_EXCEPT, EV_NONE);
}
iod_add_event(nse->iod, nse);
break;
case NSE_TYPE_READ:
if (!nse->event_done) {
assert(nse->iod->sd >= 0);
socket_count_read_inc(nse->iod);
update_events(nse->iod, nsp, EV_READ, EV_NONE);
#if HAVE_OPENSSL
if (nse->iod->ssl)
nse->sslinfo.ssl_desire = SSL_ERROR_WANT_READ;
#endif
}
iod_add_event(nse->iod, nse);
break;
case NSE_TYPE_WRITE:
if (!nse->event_done) {
assert(nse->iod->sd >= 0);
socket_count_write_inc(nse->iod);
update_events(nse->iod, nsp, EV_WRITE, EV_NONE);
#if HAVE_OPENSSL
if (nse->iod->ssl)
nse->sslinfo.ssl_desire = SSL_ERROR_WANT_WRITE;
#endif
}
iod_add_event(nse->iod, nse);
break;
case NSE_TYPE_TIMER:
/* nothing to do */
break;
#if HAVE_PCAP
case NSE_TYPE_PCAP_READ: {
mspcap *mp = (mspcap *)nse->iod->pcap;
assert(mp);
if (mp->pcap_desc >= 0) { /* pcap descriptor present */
if (!nse->event_done) {
socket_count_readpcap_inc(nse->iod);
update_events(nse->iod, nsp, EV_READ, EV_NONE);
}
nsock_log_debug_all("PCAP NSE #%lu: Adding event to READ_EVENTS", nse->id);
#if PCAP_BSD_SELECT_HACK
/* when using BSD hack we must do pcap_next() after select().
* Let's insert this pcap to bot queues, to selectable and nonselectable.
* This will result in doing pcap_next_ex() just before select() */
nsock_log_debug_all("PCAP NSE #%lu: Adding event to PCAP_READ_EVENTS", nse->id);
#endif
} else {
/* pcap isn't selectable. Add it to pcap-specific queue. */
nsock_log_debug_all("PCAP NSE #%lu: Adding event to PCAP_READ_EVENTS", nse->id);
}
iod_add_event(nse->iod, nse);
break;
}
#endif
default:
fatal("Unknown nsock event type (%d)", nse->type);
}
/* It can happen that the event already completed. In which case we can
* already deliver it, even though we're probably not inside nsock_loop(). */
if (nse->event_done) {
event_dispatch_and_delete(nsp, nse, 1);
update_first_events(nse);
nevent_unref(nsp, nse);
}
}
static void execute_command(struct trace_capture *cap)
{
const gchar *ccommand;
gchar *command;
gchar **args;
gboolean space;
int words;
int tc_words;
int i;
update_plugin(cap);
update_events(cap);
ccommand = gtk_entry_get_text(GTK_ENTRY(cap->command_entry));
if (!ccommand || !strlen(ccommand) || is_just_ws(ccommand)) {
words = 0;
command = NULL;
} else {
command = strdup(ccommand);
space = TRUE;
words = 0;
for (i = 0; command[i]; i++) {
if (isspace(command[i]))
space = TRUE;
else {
if (space)
words++;
space = FALSE;
}
}
}
tc_words = calculate_trace_cmd_words(cap);
args = malloc_or_die(sizeof(*args) * (tc_words + words + 1));
add_trace_cmd_words(cap, args);
words = tc_words;
space = TRUE;
for (i = 0; command && command[i]; i++) {
if (isspace(command[i])) {
space = TRUE;
command[i] = 0;
} else {
if (space) {
args[words] = &command[i];
words++;
}
space = FALSE;
}
}
args[words] = NULL;
write(1, "# ", 2);
for (i = 0; args[i]; i++) {
write(1, args[i], strlen(args[i]));
write(1, " ", 1);
}
write(1, "\n", 1);
execvp(args[0], args);
perror("execvp");
for (i = 0; args[i]; i++)
free(args[i]);
free(args);
g_free(cap->info->cap_plugin);
}
/* Adds an event to the appropriate nsp event list, handles housekeeping such as
* adjusting the descriptor select/poll lists, registering the timeout value,
* etc. */
void nsp_add_event(mspool *nsp, msevent *nse) {
if (nsp->tracelevel > 5)
nsock_trace(nsp, "NSE #%lu: Adding event", nse->id);
/* First lets do the event-type independent stuff, starting with timeouts */
if (nse->event_done) {
nsp->next_ev = nsock_tod;
} else {
if (nse->timeout.tv_sec != 0) {
if (nsp->next_ev.tv_sec == 0)
nsp->next_ev = nse->timeout;
else if (TIMEVAL_AFTER(nsp->next_ev, nse->timeout))
nsp->next_ev = nse->timeout;
}
}
nsp->events_pending++;
/* Now we do the event type specific actions */
switch(nse->type) {
case NSE_TYPE_CONNECT:
case NSE_TYPE_CONNECT_SSL:
if (!nse->event_done) {
assert(nse->iod->sd >= 0);
socket_count_read_inc(nse->iod);
socket_count_write_inc(nse->iod);
update_events(nse->iod, nsp, EV_READ|EV_WRITE|EV_EXCEPT, EV_NONE);
}
iod_add_event(nse->iod, nse);
break;
case NSE_TYPE_READ:
if (!nse->event_done) {
assert(nse->iod->sd >= 0);
socket_count_read_inc(nse->iod);
update_events(nse->iod, nsp, EV_READ, EV_NONE);
#if HAVE_OPENSSL
if (nse->iod->ssl)
nse->sslinfo.ssl_desire = SSL_ERROR_WANT_READ;
#endif
}
iod_add_event(nse->iod, nse);
break;
case NSE_TYPE_WRITE:
if (!nse->event_done) {
assert(nse->iod->sd >= 0);
socket_count_write_inc(nse->iod);
update_events(nse->iod, nsp, EV_WRITE, EV_NONE);
#if HAVE_OPENSSL
if (nse->iod->ssl)
nse->sslinfo.ssl_desire = SSL_ERROR_WANT_WRITE;
#endif
}
iod_add_event(nse->iod, nse);
break;
case NSE_TYPE_TIMER:
gh_list_append(&nsp->timer_events, nse);
break;
#if HAVE_PCAP
case NSE_TYPE_PCAP_READ: {
mspcap *mp = (mspcap *)nse->iod->pcap;
assert(mp);
if (mp->pcap_desc >= 0) { /* pcap descriptor present */
if (!nse->event_done) {
socket_count_readpcap_inc(nse->iod);
update_events(nse->iod, nsp, EV_READ, EV_NONE);
}
if (nsp->tracelevel > 8)
nsock_trace(nsp, "PCAP NSE #%lu: Adding event to READ_EVENTS", nse->id);
#if PCAP_BSD_SELECT_HACK
/* when using BSD hack we must do pcap_next() after select().
* Let's insert this pcap to bot queues, to selectable and nonselectable.
* This will result in doing pcap_next_ex() just before select() */
if (nsp->tracelevel > 8)
nsock_trace(nsp, "PCAP NSE #%lu: Adding event to PCAP_READ_EVENTS", nse->id);
#endif
} else {
/* pcap isn't selectable. Add it to pcap-specific queue. */
if (nsp->tracelevel > 8)
nsock_trace(nsp, "PCAP NSE #%lu: Adding event to PCAP_READ_EVENTS", nse->id);
}
iod_add_event(nse->iod, nse);
break;
}
#endif
default:
assert(0);
break; /* unreached */
}
}
static void
htsp_channelAddUpdate(htsp_connection_t *hc, htsmsg_t *m, int create)
{
uint32_t id, next;
int chnum;
prop_t *p;
char txt[200];
const char *title, *icon;
htsp_channel_t *ch, *n;
if(htsmsg_get_u32(m, "channelId", &id))
return;
title = htsmsg_get_str(m, "channelName");
icon = htsmsg_get_str(m, "channelIcon");
chnum = htsmsg_get_s32_or_default(m, "channelNumber", -1);
if(chnum == 0)
chnum = INT32_MAX;
snprintf(txt, sizeof(txt), "%d", id);
hts_mutex_lock(&hc->hc_meta_mutex);
if(create) {
ch = calloc(1, sizeof(htsp_channel_t));
p = ch->ch_root = prop_create_root(txt);
prop_t *m = prop_create(p, "metadata");
ch->ch_prop_icon = prop_create(m, "icon");
ch->ch_prop_title = prop_create(m, "title");
ch->ch_prop_channelNumber = prop_create(m, "channelNumber");
ch->ch_prop_events = prop_create(m, "events");
ch->ch_id = id;
snprintf(txt, sizeof(txt), "htsp://%s:%d/channel/%d",
hc->hc_hostname, hc->hc_port, id);
prop_set_string(prop_create(p, "url"), txt);
prop_set_string(prop_create(p, "type"), "tvchannel");
ch->ch_channel_num = chnum;
mystrset(&ch->ch_title, title);
TAILQ_INSERT_SORTED(&hc->hc_channels, ch, ch_link, channel_compar);
n = TAILQ_NEXT(ch, ch_link);
if(prop_set_parent_ex(p, hc->hc_channels_nodes,
n ? n->ch_root : NULL, NULL))
abort();
} else {
int move = 0;
ch = htsp_channel_get(hc, id);
if(ch == NULL) {
TRACE(TRACE_ERROR, "HTSP", "Got update for unknown channel %d", id);
hts_mutex_unlock(&hc->hc_meta_mutex);
return;
}
p = ch->ch_root;
if(title != NULL) {
move = 1;
mystrset(&ch->ch_title, title);
}
if(chnum != -1) {
move = 1;
ch->ch_channel_num = chnum;
}
if(move) {
TAILQ_REMOVE(&hc->hc_channels, ch, ch_link);
TAILQ_INSERT_SORTED(&hc->hc_channels, ch, ch_link, channel_compar);
n = TAILQ_NEXT(ch, ch_link);
prop_move(p, n ? n->ch_root : NULL);
}
}
hts_mutex_unlock(&hc->hc_meta_mutex);
if(icon != NULL)
prop_set_string(ch->ch_prop_icon, icon);
if(title != NULL)
prop_set_string(ch->ch_prop_title, title);
if(chnum != -1)
prop_set_int(ch->ch_prop_channelNumber, chnum);
if(htsmsg_get_u32(m, "eventId", &id))
id = 0;
if(htsmsg_get_u32(m, "nextEventId", &next))
next = 0;
update_events(hc, ch->ch_prop_events, id, next);
}
/*
* Trace Capture Dialog Window
*
* +--------------------------------------------------------------------+
* | Dialog Window |
* | +-------------------------------+-------------------------------+ |
* | | Paned Window | +---------------------------+ | |
* | | +---------------------------+ | | Scroll window | | |
* | | | Hbox | | | +-----------------------+ | | |
* | | | Label Plugin Combo | | | | Event Tree | | | |
* | | +---------------------------+ | | | | | | |
* | | | | | | | | |
* | | | | +-----------------------+ | | |
* | | | +---------------------------+ | |
* | +-------------------------------+-------------------------------+ |
* +--------------------------------------------------------------------+
*/
static void tracing_dialog(struct shark_info *info, const char *tracing)
{
struct pevent *pevent;
GtkWidget *dialog;
GtkWidget *button;
GtkWidget *combo;
GtkWidget *label;
GtkWidget *entry;
GtkWidget *frame;
GtkWidget *vbox;
GtkWidget *scrollwin;
GtkWidget *table;
GtkWidget *table2;
GtkWidget *event_tree;
GtkWidget *viewport;
GtkWidget *textview;
GtkWidget *hbox;
GtkTextBuffer *buffer;
GtkTextIter start_iter;
GtkTextIter end_iter;
char **plugins;
int nr_plugins;
struct trace_capture cap;
const gchar *file;
const char *command;
const char *val;
GString *str;
gint result;
memset(&cap, 0, sizeof(cap));
cap.info = info;
plugins = tracecmd_local_plugins(tracing);
/* Skip latency plugins */
nr_plugins = trim_plugins(plugins);
if (!nr_plugins && plugins) {
tracecmd_free_list(plugins);
plugins = NULL;
}
/* Send parse warnings to status display */
trace_dialog_register_alt_warning(vpr_stat);
pevent = tracecmd_local_events(tracing);
trace_dialog_register_alt_warning(NULL);
cap.pevent = pevent;
if (!pevent && !nr_plugins) {
warning("No events or plugins found");
return;
}
dialog = gtk_dialog_new();
gtk_window_set_title(GTK_WINDOW(dialog), "Capture");
button = gtk_button_new_with_label("Run");
gtk_dialog_add_action_widget(GTK_DIALOG(dialog), button,
GTK_RESPONSE_ACCEPT);
gtk_widget_show(button);
cap.run_button = button;
gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CLOSE,
GTK_RESPONSE_REJECT);
cap.main_dialog = dialog;
/* --- Top Level Hpaned --- */
table = gtk_table_new(4, 2, FALSE);
/* It is possible that no pevents exist. */
if (pevent) {
scrollwin = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_table_attach(GTK_TABLE(table), scrollwin, 0, 1, 1, 2,
GTK_FILL, GTK_FILL|GTK_EXPAND, 0, 0);
gtk_widget_show(scrollwin);
event_tree = trace_create_event_list_view(pevent, NULL,
cap.info->cap_all_events,
cap.info->cap_systems,
cap.info->cap_events);
gtk_container_add(GTK_CONTAINER(scrollwin), event_tree);
gtk_widget_show(event_tree);
cap.event_view = event_tree;
} else {
/* No events */
label = gtk_label_new("No events enabled on system");
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 1, 2,
GTK_FILL, GTK_EXPAND|GTK_FILL,
0, 10);
gtk_widget_show(label);
cap.event_view = NULL;
}
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), table, TRUE, TRUE, 0);
gtk_widget_show(table);
/*------------------ Frame Settings --------------------------- */
frame = gtk_frame_new("Settings");
gtk_table_attach(GTK_TABLE(table), frame, 0, 1, 0, 1,
GTK_FILL, 0, 0, 10);
gtk_widget_show(frame);
table2 = gtk_table_new(2, 3, FALSE);
gtk_container_add(GTK_CONTAINER(frame), table2);
gtk_widget_show(table2);
gtk_table_set_col_spacings(GTK_TABLE(table2), 5);
button = gtk_button_new_with_label("Save Settings");
gtk_table_attach_defaults(GTK_TABLE(table2), button, 0, 1, 0, 1);
gtk_widget_show(button);
g_signal_connect (button, "clicked",
G_CALLBACK (save_settings_clicked),
(gpointer)&cap);
button = gtk_button_new_with_label("Import Settings");
gtk_table_attach_defaults(GTK_TABLE(table2), button, 1, 2, 0, 1);
gtk_widget_show(button);
g_signal_connect (button, "clicked",
G_CALLBACK (import_settings_clicked),
(gpointer)&cap);
button = gtk_button_new_with_label("Export Settings");
gtk_table_attach_defaults(GTK_TABLE(table2), button, 2, 3, 0, 1);
gtk_widget_show(button);
g_signal_connect (button, "clicked",
G_CALLBACK (export_settings_clicked),
(gpointer)&cap);
if (cap.info->cap_settings_name)
set_settings(&cap);
label = gtk_label_new("Available Settings: ");
gtk_table_attach_defaults(GTK_TABLE(table2), label, 0, 1, 1, 2);
gtk_widget_show(label);
combo = trace_create_combo_box(NULL, NULL,
create_settings_model, NULL);
gtk_table_attach_defaults(GTK_TABLE(table2), combo, 1, 3, 1, 2);
cap.settings_combo = combo;
g_signal_connect (combo, "changed",
G_CALLBACK (settings_changed),
(gpointer)&cap);
/*------------------ Frame Settings --------------------------- */
frame = gtk_frame_new("Execute");
gtk_table_attach(GTK_TABLE(table), frame, 0, 1, 3, 4,
GTK_FILL, 0, 0, 10);
gtk_widget_show(frame);
table2 = gtk_table_new(3, 3, FALSE);
gtk_container_add(GTK_CONTAINER(frame), table2);
gtk_widget_show(table2);
label = gtk_label_new("Plugin: ");
gtk_table_attach_defaults(GTK_TABLE(table2), label, 0, 1, 0, 1);
gtk_widget_show(label);
combo = trace_create_combo_box(NULL, NULL, create_plugin_combo_model, plugins);
cap.plugin_combo = combo;
gtk_table_attach_defaults(GTK_TABLE(table2), combo, 1, 3, 0, 1);
if (cap.info->cap_plugin)
set_plugin(&cap);
label = gtk_label_new("Command:");
gtk_table_attach_defaults(GTK_TABLE(table2), label, 0, 1, 1, 2);
gtk_widget_show(label);
entry = gtk_entry_new();
gtk_table_attach_defaults(GTK_TABLE(table2), entry, 1, 3, 1, 2);
gtk_widget_show(entry);
cap.command_entry = entry;
if (cap.info->cap_command)
gtk_entry_set_text(GTK_ENTRY(entry), cap.info->cap_command);
label = gtk_label_new("Output file: ");
gtk_table_attach_defaults(GTK_TABLE(table2), label, 0, 1, 2, 3);
gtk_widget_show(label);
entry = gtk_entry_new();
gtk_table_attach_defaults(GTK_TABLE(table2), entry, 1, 2, 2, 3);
gtk_widget_show(entry);
if (cap.info->cap_file)
file = cap.info->cap_file;
else
file = default_output_file;
gtk_entry_set_text(GTK_ENTRY(entry), file);
cap.file_entry = entry;
button = gtk_button_new_with_label("Browse");
gtk_table_attach_defaults(GTK_TABLE(table2), button, 2, 3, 2, 3);
gtk_widget_show(button);
g_signal_connect (button, "clicked",
G_CALLBACK (file_clicked),
(gpointer)&cap);
/*------------------ Command Output ------------------ */
vbox = gtk_vbox_new(FALSE, 0);
gtk_table_attach_defaults(GTK_TABLE(table), vbox, 1, 2, 0, 4);
gtk_widget_show(vbox);
gtk_widget_set_size_request(GTK_WIDGET(vbox), 500, 0);
label = gtk_label_new("Output Display:");
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
gtk_widget_show(label);
scrollwin = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(GTK_BOX(vbox), scrollwin, TRUE, TRUE, 0);
gtk_widget_show(scrollwin);
viewport = gtk_viewport_new(NULL, NULL);
gtk_widget_show(viewport);
gtk_container_add(GTK_CONTAINER(scrollwin), viewport);
textview = gtk_text_view_new();
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
gtk_container_add(GTK_CONTAINER(viewport), textview);
gtk_widget_show(textview);
cap.output_text = textview;
cap.output_buffer = buffer;
/* set the buffer from its previous setting */
if (info->cap_buffer_output)
gtk_text_buffer_set_text(buffer, info->cap_buffer_output,
strlen(info->cap_buffer_output));
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
label = gtk_label_new("Max # of characters in output display: ");
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
gtk_widget_show(label);
entry = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(hbox), entry, FALSE, FALSE, 0);
gtk_widget_show(entry);
cap.max_num_entry = entry;
if (!info->cap_max_buf_size)
info->cap_max_buf_size = DEFAULT_MAX_BUF_SIZE;
str = g_string_new("");
g_string_append_printf(str, "%d", info->cap_max_buf_size);
gtk_entry_set_text(GTK_ENTRY(entry), str->str);
g_string_free(str, TRUE);
g_signal_connect (entry, "insert-text",
G_CALLBACK (insert_text),
(gpointer)&cap);
gtk_widget_set_size_request(GTK_WIDGET(dialog),
DIALOG_WIDTH, DIALOG_HEIGHT);
gtk_widget_show(dialog);
cont:
result = gtk_dialog_run(GTK_DIALOG(dialog));
if (result == GTK_RESPONSE_ACCEPT) {
execute_button_clicked(&cap);
goto cont;
}
/* Make sure no capture is running */
end_capture(&cap);
/* Get the max buffer size */
val = gtk_entry_get_text(GTK_ENTRY(entry));
info->cap_max_buf_size = atoi(val);
gtk_text_buffer_get_start_iter(cap.output_buffer, &start_iter);
gtk_text_buffer_get_end_iter(cap.output_buffer, &end_iter);
g_free(info->cap_buffer_output);
info->cap_buffer_output = gtk_text_buffer_get_text(cap.output_buffer,
&start_iter,
&end_iter,
FALSE);
/* save the plugin and file to reuse if we come back */
update_plugin(&cap);
free(info->cap_file);
cap.info->cap_file = strdup(gtk_entry_get_text(GTK_ENTRY(cap.file_entry)));
free(info->cap_command);
command = gtk_entry_get_text(GTK_ENTRY(cap.command_entry));
if (command && strlen(command) && !is_just_ws(command))
cap.info->cap_command = strdup(command);
else
cap.info->cap_command = NULL;
update_events(&cap);
gtk_widget_destroy(dialog);
if (pevent)
pevent_free(pevent);
if (plugins)
tracecmd_free_list(plugins);
}
void CSoundRender_Core::update ( const Fvector& P, const Fvector& D, const Fvector& N )
{
u32 it;
if (0==bReady) return;
bLocked = TRUE;
u32 new_tm = Timer.GetElapsed_ms();
Timer_Delta = new_tm-Timer_Value;
float dt = float(Timer_Delta)/1000.f;
Timer_Value = new_tm;
s_emitters_u ++ ;
// Firstly update emitters, which are now being rendered
//Msg ("! update: r-emitters");
for (it=0; it<s_targets.size(); it++)
{
CSoundRender_Target* T = s_targets [it];
CSoundRender_Emitter* E = T->get_emitter();
if (E) {
E->update (dt);
E->marker = s_emitters_u;
E = T->get_emitter(); // update can stop itself
if (E) T->priority = E->priority();
else T->priority = -1;
} else {
T->priority = -1;
}
}
// Update emmitters
//Msg ("! update: emitters");
for (it=0; it<s_emitters.size(); it++)
{
CSoundRender_Emitter* pEmitter = s_emitters[it];
if (pEmitter->marker!=s_emitters_u)
{
pEmitter->update (dt);
pEmitter->marker = s_emitters_u;
}
if (!pEmitter->isPlaying())
{
// Stopped
xr_delete (pEmitter);
s_emitters.erase(s_emitters.begin()+it);
it--;
}
}
// Get currently rendering emitters
//Msg ("! update: targets");
s_targets_defer.clear ();
s_targets_pu ++;
// u32 PU = s_targets_pu%s_targets.size();
for (it=0; it<s_targets.size(); it++)
{
CSoundRender_Target* T = s_targets [it];
if (T->get_emitter())
{
// Has emmitter, maybe just not started rendering
if (T->get_Rendering())
{
/*if (PU == it)*/ T->fill_parameters ();
T->update ();
}
else
s_targets_defer.push_back (T);
}
}
// Commit parameters from pending targets
if (!s_targets_defer.empty())
{
//Msg ("! update: start render - commit");
s_targets_defer.erase (std::unique(s_targets_defer.begin(),s_targets_defer.end()),s_targets_defer.end());
for (it=0; it<s_targets_defer.size(); it++)
s_targets_defer[it]->fill_parameters();
}
// update EAX
if (psSoundFlags.test(ss_EAX) && bEAX){
if (bListenerMoved){
bListenerMoved = FALSE;
e_target = *get_environment (P);
}
e_current.lerp (e_current,e_target,dt);
i_eax_listener_set (&e_current);
i_eax_commit_setting ();
}
// update listener
update_listener (P,D,N,dt);
// Start rendering of pending targets
if (!s_targets_defer.empty())
{
//Msg ("! update: start render");
for (it=0; it<s_targets_defer.size(); it++)
s_targets_defer[it]->render ();
}
// Events
update_events ();
bLocked = FALSE;
}
int main(int argc, char **argv)
{
struct time_type time;
ZOOM_connection *z;
ZOOM_resultset *r;
int *elc;
struct event_line_t *els;
ZOOM_options o;
int i;
int k;
init_statics();
read_params(argc, argv, ¶meters);
z = (ZOOM_connection *) xmalloc(sizeof(*z) * parameters.concurrent);
r = (ZOOM_resultset *) xmalloc(sizeof(*r) * parameters.concurrent);
elc = (int *) xmalloc(sizeof(*elc) * parameters.concurrent * parameters.repeat);
els = (struct event_line_t *) xmalloc(
sizeof(*els) * parameters.concurrent * parameters.repeat * 10);
o = ZOOM_options_create();
/* async mode */
ZOOM_options_set (o, "async", "1");
/* get first record of result set (using piggypack) */
if (parameters.piggypack)
ZOOM_options_set (o, "count", "1");
/* set proxy */
if (strlen(parameters.proxy))
ZOOM_options_set (o, "proxy", parameters.proxy);
/* preferred record syntax */
if (0){
ZOOM_options_set (o, "preferredRecordSyntax", "usmarc");
ZOOM_options_set (o, "elementSetName", "F");
}
time_init(&time);
/* repeat loop */
for (k = 0; k < parameters.repeat; k++){
/* progress zeroing */
for (i = 0; i < 4096; i++){
parameters.progress[i] = k * 5 -1;
}
/* connect to all concurrent connections*/
for ( i = 0; i < parameters.concurrent; i++){
/* set event count to zero */
elc[k * parameters.concurrent + i] = 0;
/* create connection - pass options (they are the same for all) */
z[i] = ZOOM_connection_create(o);
/* connect and init */
ZOOM_connection_connect(z[i], parameters.host, 0);
}
/* search all */
for (i = 0; i < parameters.concurrent; i++)
r[i] = ZOOM_connection_search_pqf (z[i], parameters.query);
/* network I/O. pass number of connections and array of connections */
while ((i = ZOOM_event (parameters.concurrent, z))){
int event = ZOOM_connection_last_event(z[i-1]);
const char *errmsg;
const char *addinfo;
int error = 0;
//int progress = zoom_progress[event];
if (event == ZOOM_EVENT_SEND_DATA || event == ZOOM_EVENT_RECV_DATA)
continue;
time_stamp(&time);
/* updating events and event list */
error = ZOOM_connection_error(z[i-1] , &errmsg, &addinfo);
if (error)
parameters.progress[i] = zoom_progress[ZOOM_EVENT_UNKNOWN];
//parameters.progress[i] = zoom_progress[ZOOM_EVENT_NONE];
else if (event == ZOOM_EVENT_CONNECT)
parameters.progress[i] = zoom_progress[event];
else
//parameters.progress[i] = zoom_progress[event];
parameters.progress[i] += 1;
update_events(elc, els,
k, i-1,
time_sec(&time), time_usec(&time),
parameters.progress[i],
event, zoom_events[event],
error, errmsg);
}
/* destroy connections */
for (i = 0; i<parameters.concurrent; i++)
{
ZOOM_resultset_destroy (r[i]);
ZOOM_connection_destroy (z[i]);
}
} /* for (k = 0; k < parameters.repeat; k++) repeat loop */
/* output */
if (parameters.gnuplot){
printf("# gnuplot data and instruction file \n");
printf("# gnuplot thisfile \n");
printf("\n");
printf("set title \"Z39.50 connection plot\"\n");
printf("set xlabel \"Connection\"\n");
printf("set ylabel \"Time Seconds\"\n");
printf("set zlabel \"Progress\"\n");
printf("set ticslevel 0\n");
printf("set grid\n");
printf("set pm3d\n");
printf("splot '-' using ($1):($2):($3) t '' with points\n");
printf("\n");
printf("\n");
}
print_table_header();
print_events(elc, els, parameters.concurrent);
if (parameters.gnuplot){
printf("end\n");
printf("pause -1 \"Hit ENTER to return\"\n");
}
/* destroy data structures and exit */
xfree(z);
xfree(r);
xfree(elc);
xfree(els);
ZOOM_options_destroy(o);
exit (0);
}
