LS_API void*
ls_data_realloc(void* ptr,
size_t size)
{
void* ret = _realloc_func(ptr, size);
if (ret)
{
if (ret != ptr)
{
/* log the steps separately so mem leaks can be easily identified */
/* by running log output through */
/* fgrep mem.c: | sed -r 's/.*mem.c:[^ ]* ([^ ]*).* /\1/' | sort | */
/* uniq -c | sort -n | while read count addr; do */
/* if [[ 1 -eq $((count % 2)) ]]; then echo "$addr $count" */
/* fi; done */
if (ptr)
{
ls_log(LS_LOG_MEMTRACE, "mem.c:realloc(free) %p", ptr);
}
ls_log(LS_LOG_MEMTRACE, "mem.c:realloc(malloc) %p %zd", ret, size);
}
}
else
{
ls_log(LS_LOG_WARN,
"mem.c:realloc unable to realloc %p to block of size %zd",
ptr, size);
}
return ret;
}
void
done_sig(int sig)
{
UNUSED_PARAM(sig);
ls_log(LS_LOG_VERBOSE, "Signal caught: %d", sig);
done(NULL);
}
LS_API void*
ls_data_malloc(size_t size)
{
void* ret = _malloc_func(size);
if (ret)
{
ls_log(LS_LOG_MEMTRACE, "mem.c:malloc %p %zd", ret, size);
}
else
{
ls_log(LS_LOG_WARN,
"mem.c:malloc unable to allocate block of size %zd", size);
}
return ret;
}
static void
running_cb(ls_event_data* evt,
void* arg)
{
UNUSED_PARAM(evt);
UNUSED_PARAM(arg);
ls_log(LS_LOG_INFO, "running!");
sendData(NULL);
}
LS_API void
ls_data_free(void* ptr)
{
if (ptr)
{
ls_log(LS_LOG_MEMTRACE, "mem.c:free %p", ptr);
_free_func(ptr);
}
}
void
done()
{
ls_err err;
if ( !tube_manager_stop(mgr, &err) )
{
LS_LOG_ERR(err, "tube_manager_stop");
}
pthread_cancel(listenThread);
pthread_join(listenThread, NULL);
ls_log(LS_LOG_INFO, "DONE!");
exit(0);
}
LS_API bool tube_print(const tube *t, ls_err *err)
{
struct sockaddr_storage addr;
socklen_t addr_len = sizeof(addr);
char local[NI_MAXHOST+NI_MAXSERV+2] = {0};
char remote[NI_MAXHOST+NI_MAXSERV+2] = {0};
char id_buf[SPUD_ID_STRING_SIZE+1] = {0};
assert(t!=NULL);
if (t->sock == -1) {
printf("No socket yet\n");
return true;
}
if (getsockname(t->sock, (struct sockaddr *)&addr, &addr_len) != 0) {
LS_ERROR(err, -errno);
return false;
}
if (t->pktinfo) {
int port = ls_sockaddr_get_port((struct sockaddr *)&addr);
// ignore errors.
// TODO: set pktinfo when receiving ACK
addr_len = sizeof(addr);
if (ls_pktinfo_get_addr(t->pktinfo, (struct sockaddr *)&addr, &addr_len, NULL)) {
ls_sockaddr_set_port((struct sockaddr*)&addr, port);
}
}
if (!ls_sockaddr_to_string((struct sockaddr*)&addr, local, sizeof(local), true) ||
!ls_sockaddr_to_string((struct sockaddr*)&t->peer, remote, sizeof(remote), true)) {
return false;
}
ls_log(LS_LOG_INFO,
"TUBE %s: %s->%s",
spud_id_to_string(id_buf, sizeof(id_buf), &t->id),
local, remote);
return true;
}
static int
markov()
{
struct timespec timer;
struct timespec remaining;
tube* t;
ls_err err;
int i;
int* iptr;
timer.tv_sec = 0;
while ( tube_manager_running(mgr) )
{
timer.tv_nsec = gauss(50000000, 10000000);
nanosleep(&timer, &remaining);
i = random() % NUM_TUBES;
t = tubes[i];
if (!t)
{
if ( !tube_create(&t, &err) )
{
LS_LOG_ERR(err, "tube_create");
return 1;
}
tubes[i] = t;
iptr = malloc( sizeof(*iptr) );
*iptr = i;
tube_set_data(t, iptr);
}
switch ( tube_get_state(t) )
{
case TS_START:
ls_log(LS_LOG_ERROR, "invalid tube state");
return 1;
case TS_UNKNOWN:
if ( !tube_manager_open_tube(mgr,
(const struct sockaddr*)&remoteAddr,
&t,
&err) )
{
LS_LOG_ERR(err, "tube_manager_open_tube");
return 1;
}
break;
case TS_OPENING:
/* keep waiting by the mailbox, Charlie Brown */
break;
case TS_RUNNING:
/* .1% chance of close */
if ( (random() % 10000) < 10 )
{
if ( !tube_close(t, &err) )
{
LS_LOG_ERR(err, "tube_close");
return 1;
}
}
else
{
/* TODO: put something intersting in the buffer */
if ( !tube_data(t, data, random() % sizeof(data), &err) )
{
LS_LOG_ERR(err, "tube_data");
return 1;
}
}
case TS_RESUMING:
/* can't get here yet */
break;
}
}
return 0;
}
int
spudtest(int argc,
char** argv)
{
ls_err err;
int ch;
struct sockaddr_storage addr;
/* bool has_addr = false;; */
while ( ( ch = getopt(argc, argv, "?hvs:") ) != -1 )
{
switch (ch)
{
case 'v':
ls_log_set_level(LS_LOG_VERBOSE);
break;
case 's':
if ( !ls_sockaddr_parse(optarg, (struct sockaddr*)&addr, sizeof(addr),
&err) )
{
LS_LOG_ERR(err, "Invalid address");
return 1;
}
/* has_addr = true; */
break;
case 'h':
case '?':
default:
usage();
break;
}
}
argc -= optind;
argv += optind;
if (argc < 1)
{
usage();
}
ls_log(LS_LOG_INFO, "entering spudtest");
memset( &config, 0, sizeof(config) );
if ( !ls_sockaddr_get_remote_ip_addr(argv[0],
"1402",
(struct sockaddr*)&config.remoteAddr,
sizeof(config.remoteAddr),
&err) )
{
LS_LOG_ERR(err, "ls_sockaddr_get_remote_ip_addr");
return 1;
}
if ( !tube_manager_create(0, &mgr, &err) )
{
LS_LOG_ERR(err, "tube_manager_create");
return 1;
}
if ( !tube_manager_socket(mgr, 0, &err) )
{
LS_LOG_ERR(err, "tube_manager_socket");
return 1;
}
/* TODO: make source addresses work (again?). */
/* if (has_addr) { */
/* LOGI("source address: %s\n", inet_ntop(AF_INET6, &addr, buf,
* sizeof(buf))); */
/* } */
if ( !tube_manager_bind_event(mgr, EV_LOOPSTART_NAME, loopstart_cb, &err) ||
!tube_manager_bind_event(mgr, EV_RUNNING_NAME, running_cb, &err) ||
!tube_manager_bind_event(mgr, EV_DATA_NAME, data_cb, &err) )
{
LS_LOG_ERR(err, "tube_manager_bind_event");
return 1;
}
if ( !tube_manager_signal(mgr, SIGINT, done_sig, &err) )
{
LS_LOG_ERR(err, "tube_manager_signal");
return 1;
}
if ( !tube_manager_schedule_ms(mgr, 5000, done, NULL, NULL, &err) )
{
LS_LOG_ERR(err, "tube_manager_schedule_ms");
return 1;
}
if ( !tube_manager_loop(mgr, &err) )
{
LS_LOG_ERR(err, "tube_manager_loop");
}
return 0;
}
