int threads_process(intrace_t * intrace)
{
int err;
pthread_attr_t attr;
pthread_t t;
if (pthread_mutex_init(&intrace->mutex, NULL) != 0) {
debug_printf(dlFatal, "threads: Mutex initialization failed\n");
return errMutex;
}
debug_printf(dlDebug, "Resolving '%s'\n", intrace->hostname);
if (!threads_resolveIP(intrace, intrace->hostname)) {
debug_printf(dlFatal, "Resolving '%s' failed\n", intrace->hostname);
return errResolve;
}
char haddr[INET6_ADDRSTRLEN];
if (!inet_ntop(_IT_AF(intrace), _IT_RIP(intrace), haddr, sizeof(haddr))) {
debug_printf(dlFatal, "Cannot convert IP addr to a text form\n");
return errResolve;
}
debug_printf(dlDebug, "%s for '%s' resolved='%s'\n", _IT_IPSTR(intrace), intrace->hostname,
haddr);
if ((err = listener_init(intrace)) != errNone) {
debug_printf(dlFatal, "threads: Listener initialization failed, err=%d'\n", err);
return err;
}
if ((err = sender_init(intrace)) != errNone) {
debug_printf(dlFatal, "threads: Packet sender initialization failed, err=%d\n",
err);
return err;
}
if ((err = threads_dropPrivs()) != errNone) {
debug_printf(dlFatal, "threads: Couldn't drop privileges, err=%d\n", err);
return err;
}
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
if (pthread_create(&t, &attr, listener_thr, (void *)intrace) < 0) {
debug_printf(dlFatal, "threads: Cannot create listener thread\n");
return errThread;
}
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
if (pthread_create(&t, &attr, sender_thr, (void *)intrace) < 0) {
debug_printf(dlFatal, "threads: Cannot create sender thread\n");
return errThread;
}
display_process(intrace);
return errNone;
}
/**
* Used to handle keyboard input.
* Implement any additional commands here.
*/
void l5_handle_keyboard(void) {
char buffer[1024];
char *retval;
retval = fgets(buffer, sizeof(buffer), stdin);
if(retval != 0) {
buffer[strlen(buffer)-1] = 0;
/* debug */
fprintf(stderr, "The buffer contains: >>%s<<\n", buffer);
if(strstr(buffer, "CONNECT") != NULL) {
char hostname[1024] = {0};
int port;
int device;
/*
* sscanf tries to find the pattern in the buffer, and extracts
* the parts into the given variables.
*/
int ret = sscanf(buffer, "CONNECT %s %d", hostname, &port);
if(ret == 2) {
/* two matches, we got our hostname and port */
device = l1_connect(hostname, port);
if(device < 0) {
fprintf(stderr, "Error connecting to host:port %s:%d.\n", hostname, port);
return;
}
fprintf(stderr,
"Physical connection to host:port %s:%d has device number %d\n",
hostname, port, device);
}
}else if(strstr(buffer, "SEND") != NULL) {
char filename[100];
int device;
int ret = sscanf(buffer, "SEND %s %d", filename, &device);
if(ret == 2) {
//We got our filename and device to send the file
//read file
sender_init(filename, device);
sender_send();
}
}else if(strstr(buffer, "QUIT") != NULL) {
// Gracefully shut down
l2_shutdown();
delayed_send_shutdown();
exit(EXIT_SUCCESS);
}
}
}
static void test_socket_transport(void)
{
struct async_transport *st
= socket_transport_create(socket_factory(), "127.0.0.1");
struct receiver receiver;
struct sender senders[MESSAGES];
size_t i;
receiver_init(&receiver, st);
for (i = 0; i < MESSAGES; i++)
sender_init(&senders[i], st, receiver_address(&receiver));
application_run();
for (i = 0; i < MESSAGES; i++)
sender_fini(&senders[i]);
receiver_fini(&receiver);
async_transport_destroy(st);
}
int main(void)
{
char cbuf[20], s[20];
ioinit();
stdout = stdin = &uart_str;
sender_init();
sei();
help_text();
for (;;){
printf_P(PSTR("Enter command: "));
if (fgets(cbuf, sizeof cbuf - 1, stdin) == NULL) help_text();
else{
switch (tolower(cbuf[0])){
default:
printf("Unknown command: %s\n", cbuf);
help_text();
break;
case 'f':
if (sscanf(cbuf, "%*s %s", s) == 1){
switch (tolower(s[0])){
default:
printf("Illegal channel: %s\n", cbuf);
help_text();
break;
case 'a':
bat_command(0,0);
break;
case 'b':
bat_command(0,1);
break;
case 'c':
bat_command(0,2);
break;
case 'd':
bat_command(0,3);
break;
case 'm':
bat_command(0,4);
break;
}
}
else{
printf("Syntax error\n");
help_text();
}
break;
case 'n':
if (sscanf(cbuf, "%*s %s", s) == 1){
switch (tolower(s[0])){
default:
printf("Illegal channel: %s\n", cbuf);
help_text();
break;
case 'a':
bat_command(1,0);
break;
case 'b':
bat_command(1,1);
break;
case 'c':
bat_command(1,2);
break;
case 'd':
bat_command(1,3);
break;
case 'm':
bat_command(1,4);
break;
case 'x':
bat_command(1,5);
break;
}
}
else{
printf("Syntax error\n");
help_text();
}
break;
}
}
}
}
void recv_model_init(struct recv_model *m,
const struct recv_params *p,
struct design *r, struct design2 *d)
{
assert(m);
assert(r);
assert(design_count(r));
assert(d);
assert(design2_count2(d) == design_count(r));
size_t nrecv = design_count(r);
size_t dimr0 = design_trait_dim(r);
size_t dimr1 = design_tvar_dim(r);
size_t dimd0 = design2_trait_dim(d);
size_t dimd1 = design2_tvar_dim(d);
size_t base_dim = dimr0 + dimr1 + dimd0;
size_t aug_dim = dimd1;
size_t dim = base_dim + aug_dim;
size_t isend, nsend = design2_count1(d);
size_t ic, nc = design2_cohort_count(d);
m->recv = r;
m->dyad = d;
m->exclude_loops = 0;
mlogit_work_init(&m->work, nrecv, base_dim);
mlogitaug_work_init(&m->augwork, base_dim, aug_dim);
m->params.recv.traits = xcalloc(dim, sizeof(double));
m->params.recv.tvars = m->params.recv.traits + dimr0;
m->params.dyad.traits = m->params.recv.tvars + dimr1;
m->params.dyad.tvars = m->params.dyad.traits + dimd0;
if (p && p->recv.traits) {
memcpy(m->params.recv.traits, p->recv.traits, dimr0 * sizeof(double));
}
if (p && p->recv.tvars) {
memcpy(m->params.recv.tvars, p->recv.tvars, dimr1 * sizeof(double));
}
if (p && p->dyad.traits) {
memcpy(m->params.dyad.traits, p->dyad.traits, dimd0 * sizeof(double));
}
if (p && p->dyad.tvars) {
memcpy(m->params.dyad.tvars, p->dyad.tvars, dimd1 * sizeof(double));
}
struct recv_model_cohort *cms = xcalloc(nc, sizeof(*cms));
for (ic = 0; ic < nc; ic++) {
cohort_init(&cms[ic], ic, r, d, &m->params, &m->work);
}
m->cohort_models = cms;
struct recv_model_sender *sms = xcalloc(nsend, sizeof(*sms));
for (isend = 0; isend < nsend; isend++) {
size_t c = recv_model_cohort(m, isend);
struct recv_model_cohort *cm = &cms[c];
sender_init(&sms[isend], isend, d, &m->params, cm, &m->augwork);
}
m->sender_models = sms;
m->moments = 2;
}
