void
make_registration(dtn_reg_info_t* reginfo)
{
int ret;
// try to find an existing registration to use (unless we're
// using session flags, in which case we always create a new
// registration)
if (session_flags == 0) {
ret = dtn_find_registration(handle, ®info->endpoint, ®id);
if (ret == 0) {
// found the registration, bind it to the handle
if (dtn_bind(handle, regid) != DTN_SUCCESS) {
fprintf(stderr, "%s: error in bind (id=0x%x): %d (%s)\n",
progname, regid, ret, dtn_strerror(dtn_errno(handle)));
exit(EXIT_FAILURE);
}
return;
} else if (dtn_errno(handle) == DTN_ENOTFOUND) {
// fall through
} else {
fprintf(stderr, "%s: error in dtn_find_registration: %d (%s)\n",
progname, ret, dtn_strerror(dtn_errno(handle)));
exit(EXIT_FAILURE);
}
}
// create a new dtn registration to receive bundles
if ((ret = dtn_register(handle, reginfo, ®id)) != 0) {
fprintf(stderr, "%s: error creating registration (id=0x%x): %d (%s)\n",
progname, regid, ret, dtn_strerror(dtn_errno(handle)));
exit(EXIT_FAILURE);
}
if (verbose)
fprintf(info, "dtn_register succeeded, regid 0x%x\n", regid);
}
void
from_bundles()
{
int total_bytes = 0, i, ret;
char *buffer;
char s_buffer[BUFSIZ];
dtn_reg_info_t reg;
dtn_endpoint_id_t local_eid;
dtn_bundle_spec_t receive_spec;
parse_eid(handle, &local_eid, arg_receive);
memset(®, 0, sizeof(reg));
dtn_copy_eid(®.endpoint, &local_eid);
// when using the session flags, the registration expires
// immediately, otherwise we give it a default expiration time
if (session_flags) {
reg.flags = DTN_REG_DROP | DTN_SESSION_SUBSCRIBE;
reg.expiration = 0;
} else {
reg.flags = DTN_REG_DEFER;
reg.expiration = REG_EXPIRE;
}
make_registration(®);
if (verbose)
fprintf(info, "waiting to receive %d bundles using reg >%s<\n",
bundle_count, reg.endpoint.uri);
// loop waiting for bundles
for (i = 0; i < bundle_count; ++i) {
size_t bytes = 0;
u_int k;
// read from network
if ((ret = dtn_recv(handle, &receive_spec,
DTN_PAYLOAD_MEM, &primary_payload, -1)) < 0) {
fprintf(stderr, "%s: error getting recv reply: %d (%s)\n",
progname, ret, dtn_strerror(dtn_errno(handle)));
exit(EXIT_FAILURE);
}
bytes = primary_payload.buf.buf_len;
buffer = (char *) primary_payload.buf.buf_val;
total_bytes += bytes;
// write to stdout
if (fwrite(buffer, 1, bytes, stdout) != bytes) {
fprintf(stderr, "%s: error writing to stdout\n",
progname);
exit(EXIT_FAILURE);
}
if (!verbose) {
continue;
}
fprintf(info, "%d bytes from [%s]: transit time=%d ms\n",
primary_payload.buf.buf_len,
receive_spec.source.uri, 0);
for (k=0; k < primary_payload.buf.buf_len; k++) {
if (buffer[k] >= ' ' && buffer[k] <= '~')
s_buffer[k%BUFSIZ] = buffer[k];
else
s_buffer[k%BUFSIZ] = '.';
if (k%BUFSIZ == 0) // new line every 16 bytes
{
fprintf(info,"%07x ", k);
}
else if (k%2 == 0)
{
fprintf(info," "); // space every 2 bytes
}
fprintf(info,"%02x", buffer[k] & 0xff);
// print character summary (a la emacs hexl-mode)
if (k%BUFSIZ == BUFSIZ-1)
{
fprintf(info," | %.*s\n", BUFSIZ, s_buffer);
}
}
// print spaces to fill out the rest of the line
if (k%BUFSIZ != BUFSIZ-1) {
while (k%BUFSIZ != BUFSIZ-1) {
if (k%2 == 0) {
fprintf(info," ");
}
fprintf(info," ");
k++;
}
fprintf(info," | %.*s\n",
(int)primary_payload.buf.buf_len%BUFSIZ,
s_buffer);
}
fprintf(info,"\n");
}
}
void
to_bundles()
{
int bytes, ret;
dtn_reg_info_t reg_report; /* for reports, if reqd */
dtn_reg_info_t reg_session; /* for session reg, if reqd */
// initialize bundle spec
memset(&bundle_spec, 0, sizeof(bundle_spec));
parse_eid(handle, &bundle_spec.dest, arg_dest);
parse_eid(handle, &bundle_spec.source, arg_source);
if (arg_replyto == NULL) {
dtn_copy_eid(&bundle_spec.replyto, &bundle_spec.source);
} else {
parse_eid(handle, &bundle_spec.replyto, arg_replyto);
}
if (verbose) {
print_eid(info, "source_eid", &bundle_spec.source);
print_eid(info, "replyto_eid", &bundle_spec.replyto);
print_eid(info, "dest_eid", &bundle_spec.dest);
}
if (wait_for_report) {
// if we're given a regid, bind to it, otherwise make a
// registration for incoming reports
if (regid != DTN_REGID_NONE) {
if (dtn_bind(handle, regid) != DTN_SUCCESS) {
fprintf(stderr, "%s: error in bind (id=0x%x): %d (%s)\n",
progname, regid, ret, dtn_strerror(dtn_errno(handle)));
exit(EXIT_FAILURE);
}
} else {
memset(®_report, 0, sizeof(reg_report));
dtn_copy_eid(®_report.endpoint, &bundle_spec.replyto);
reg_report.flags = DTN_REG_DEFER;
reg_report.expiration = REG_EXPIRE;
make_registration(®_report);
}
}
if (session_flags) {
// make a publisher registration
memset(®_session, 0, sizeof(reg_session));
dtn_copy_eid(®_session.endpoint, &bundle_spec.dest);
reg_session.flags = DTN_SESSION_PUBLISH;
reg_session.expiration = 0;
make_registration(®_session);
}
// set the dtn options
bundle_spec.expiration = expiration;
if (delivery_receipts) {
// set the delivery receipt option
bundle_spec.dopts |= DOPTS_DELIVERY_RCPT;
}
if (forwarding_receipts) {
// set the forward receipt option
bundle_spec.dopts |= DOPTS_FORWARD_RCPT;
}
if (custody) {
// request custody transfer
bundle_spec.dopts |= DOPTS_CUSTODY;
}
if (custody_receipts) {
// request custody transfer
bundle_spec.dopts |= DOPTS_CUSTODY_RCPT;
}
if (receive_receipts) {
// request receive receipt
bundle_spec.dopts |= DOPTS_RECEIVE_RCPT;
}
if (sequence_id) {
bundle_spec.sequence_id.data.data_val = sequence_id;
bundle_spec.sequence_id.data.data_len = strlen(sequence_id);
}
if (obsoletes_id) {
bundle_spec.obsoletes_id.data.data_val = obsoletes_id;
bundle_spec.obsoletes_id.data.data_len = strlen(obsoletes_id);
}
if ((bytes = fill_payload(&primary_payload)) < 0) {
fprintf(stderr, "%s: error reading bundle data\n",
progname);
exit(EXIT_FAILURE);
}
memset(&bundle_id, 0, sizeof(bundle_id));
if ((ret = dtn_send(handle, regid, &bundle_spec, &primary_payload,
&bundle_id)) != 0) {
fprintf(stderr, "%s: error sending bundle: %d (%s)\n",
progname, ret, dtn_strerror(dtn_errno(handle)));
exit(EXIT_FAILURE);
}
if (verbose)
fprintf(info, "Read %d bytes from stdin and wrote to bundles\n",
bytes);
if (wait_for_report) {
memset(&reply_spec, 0, sizeof(reply_spec));
memset(&reply_payload, 0, sizeof(reply_payload));
// now we block waiting for any replies
if ((ret = dtn_recv(handle, &reply_spec,
DTN_PAYLOAD_MEM, &reply_payload, -1)) < 0) {
fprintf(stderr, "%s: error getting reply: %d (%s)\n",
progname, ret, dtn_strerror(dtn_errno(handle)));
exit(EXIT_FAILURE);
}
if (gettimeofday(&end, NULL) < 0) {
fprintf(stderr, "%s: gettimeofday(end) returned error %s\n",
progname, strerror(errno));
exit(EXIT_FAILURE);
}
if (verbose)
fprintf(info, "got %d byte report from [%s]: time=%.1f ms\n",
reply_payload.buf.buf_len,
reply_spec.source.uri,
((double)(end.tv_sec - start.tv_sec) * 1000.0 +
(double)(end.tv_usec - start.tv_usec)/1000.0));
}
}
int
main(int argc, const char** argv)
{
int i;
int ret;
dtn_handle_t handle;
dtn_endpoint_id_t source_eid;
dtn_reg_info_t reginfo;
dtn_reg_id_t regid;
dtn_bundle_spec_t ping_spec;
dtn_bundle_spec_t reply_spec;
dtn_bundle_payload_t ping_payload;
ping_payload_t payload_contents;
ping_payload_t recv_contents;
dtn_bundle_payload_t reply_payload;
dtn_bundle_status_report_t* sr_data;
dtn_bundle_id_t bundle_id;
int debug = 1;
char demux[64];
int dest_len = 0;
struct timeval send_times[MAX_PINGS_IN_FLIGHT];
dtn_timestamp_t creation_times[MAX_PINGS_IN_FLIGHT];
struct timeval now, recv_start, recv_end;
u_int32_t nonce;
u_int32_t seqno = 0;
int timeout;
// force stdout to always be line buffered, even if output is
// redirected to a pipe or file
setvbuf(stdout, (char *)NULL, _IOLBF, 0);
doOptions(argc, argv);
memset(&ping_spec, 0, sizeof(ping_spec));
gettimeofday(&now, 0);
srand(now.tv_sec);
nonce = rand();
// open the ipc handle
int err = dtn_open(&handle);
if (err != DTN_SUCCESS) {
fprintf(stderr, "fatal error opening dtn handle: %s\n",
dtn_strerror(err));
exit(1);
}
// make sure they supplied a valid destination eid or
// "localhost", in which case we just use the local daemon
if (strcmp(dest_eid_str, "localhost") == 0) {
dtn_build_local_eid(handle, &ping_spec.dest, "ping");
} else {
if (dtn_parse_eid_string(&ping_spec.dest, dest_eid_str)) {
fprintf(stderr, "invalid destination eid string '%s'\n",
dest_eid_str);
exit(1);
}
}
dest_len = strlen(ping_spec.dest.uri);
if ((dest_len < 4) ||
(strcmp(ping_spec.dest.uri + dest_len - 4, "ping") != 0))
{
fprintf(stderr, "\nWARNING: ping destination does not end in \"ping\"\n\n");
}
// if the user specified a source eid, register on it.
// otherwise, build a local eid based on the configuration of
// our dtn router plus the demux string
snprintf(demux, sizeof(demux), "/ping.%d", getpid());
if (source_eid_str[0] != '\0') {
if (dtn_parse_eid_string(&source_eid, source_eid_str)) {
fprintf(stderr, "invalid source eid string '%s'\n",
source_eid_str);
exit(1);
}
} else {
dtn_build_local_eid(handle, &source_eid, demux);
}
// set the source and replyto eids in the bundle spec
if (debug) printf("source_eid [%s]\n", source_eid.uri);
dtn_copy_eid(&ping_spec.source, &source_eid);
dtn_copy_eid(&ping_spec.replyto, &source_eid);
// now create a new registration based on the source
memset(®info, 0, sizeof(reginfo));
dtn_copy_eid(®info.endpoint, &source_eid);
reginfo.flags = DTN_REG_DEFER;
reginfo.regid = DTN_REGID_NONE;
reginfo.expiration = 0;
if ((ret = dtn_register(handle, ®info, ®id)) != 0) {
fprintf(stderr, "error creating registration: %d (%s)\n",
ret, dtn_strerror(dtn_errno(handle)));
exit(1);
}
if (debug) printf("dtn_register succeeded, regid %d\n", regid);
// set the expiration time and request deletion status reports
ping_spec.expiration = expiration;
ping_spec.dopts = DOPTS_DELETE_RCPT;
printf("PING [%s] (expiration %u)...\n", ping_spec.dest.uri, expiration);
if (interval == 0) {
printf("WARNING: zero second interval will result in flooding pings!!\n");
}
// loop, sending pings and polling for activity
for (i = 0; count == 0 || i < count; ++i) {
gettimeofday(&send_times[seqno], NULL);
// fill in a short payload string, a nonce, and a sequence number
// to verify the echo feature and make sure we're not getting
// duplicate responses or ping responses from another app
memcpy(&payload_contents.ping, PING_STR, 8);
payload_contents.seqno = seqno;
payload_contents.nonce = nonce;
payload_contents.time = send_times[seqno].tv_sec;
memset(&ping_payload, 0, sizeof(ping_payload));
dtn_set_payload(&ping_payload, DTN_PAYLOAD_MEM,
(char*)&payload_contents, sizeof(payload_contents));
memset(&bundle_id, 0, sizeof(bundle_id));
if ((ret = dtn_send(handle, regid, &ping_spec, &ping_payload,
&bundle_id)) != 0) {
fprintf(stderr, "error sending bundle: %d (%s)\n",
ret, dtn_strerror(dtn_errno(handle)));
exit(1);
}
creation_times[seqno] = bundle_id.creation_ts;
memset(&reply_spec, 0, sizeof(reply_spec));
memset(&reply_payload, 0, sizeof(reply_payload));
// now loop waiting for replies / status reports until it's
// time to send again, adding twice the expiration time if we
// just sent the last ping
timeout = interval * 1000;
if (i == count - 1)
timeout += expiration * 2000;
do {
gettimeofday(&recv_start, 0);
if ((ret = dtn_recv(handle, &reply_spec,
DTN_PAYLOAD_MEM, &reply_payload, timeout)) < 0)
{
if (dtn_errno(handle) == DTN_ETIMEOUT) {
break; // time to send again
}
fprintf(stderr, "error getting ping reply: %d (%s)\n",
ret, dtn_strerror(dtn_errno(handle)));
exit(1);
}
gettimeofday(&recv_end, 0);
if (reply_payload.status_report != NULL)
{
sr_data = reply_payload.status_report;
if (sr_data->flags != STATUS_DELETED) {
fprintf(stderr, "(bad status report from %s: flags 0x%x)\n",
reply_spec.source.uri, sr_data->flags);
goto next;
}
// find the seqno corresponding to the original
// transmission time in the status report
int j = 0;
for (j = 0; j < MAX_PINGS_IN_FLIGHT; ++j) {
if (creation_times[j].secs ==
sr_data->bundle_id.creation_ts.secs &&
creation_times[j].seqno ==
sr_data->bundle_id.creation_ts.seqno)
{
printf("bundle deleted at [%s] (%s): seqno=%d, time=%ld ms\n",
reply_spec.source.uri,
dtn_status_report_reason_to_str(sr_data->reason),
j, TIMEVAL_DIFF_MSEC(recv_end, send_times[j]));
goto next;
}
}
printf("bundle deleted at [%s] (%s): ERROR: can't find seqno\n",
reply_spec.source.uri,
dtn_status_report_reason_to_str(sr_data->reason));
}
else {
if (reply_payload.buf.buf_len != sizeof(ping_payload_t))
{
printf("%d bytes from [%s]: ERROR: length != %zu\n",
reply_payload.buf.buf_len,
reply_spec.source.uri,
sizeof(ping_payload_t));
goto next;
}
memcpy(&recv_contents, reply_payload.buf.buf_val,
sizeof(recv_contents));
if (recv_contents.seqno > MAX_PINGS_IN_FLIGHT)
{
printf("%d bytes from [%s]: ERROR: invalid seqno %d\n",
reply_payload.buf.buf_len,
reply_spec.source.uri,
recv_contents.seqno);
goto next;
}
if (recv_contents.nonce != nonce)
{
printf("%d bytes from [%s]: ERROR: invalid nonce %u != %u\n",
reply_payload.buf.buf_len,
reply_spec.source.uri,
recv_contents.nonce, nonce);
goto next;
}
if (recv_contents.time != (u_int32_t)send_times[recv_contents.seqno].tv_sec)
{
printf("%d bytes from [%s]: ERROR: time mismatch -- "
"seqno %u reply time %u != send time %lu\n",
reply_payload.buf.buf_len,
reply_spec.source.uri,
recv_contents.seqno,
recv_contents.time,
(long unsigned int)send_times[recv_contents.seqno].tv_sec);
goto next;
}
printf("%d bytes from [%s]: '%.*s' seqno=%d, time=%ld ms\n",
reply_payload.buf.buf_len,
reply_spec.source.uri,
(u_int)strlen(PING_STR),
reply_payload.buf.buf_val,
recv_contents.seqno,
TIMEVAL_DIFF_MSEC(recv_end,
send_times[recv_contents.seqno]));
fflush(stdout);
}
next:
dtn_free_payload(&reply_payload);
timeout -= TIMEVAL_DIFF_MSEC(recv_end, recv_start);
// once we get status from all the pings we're supposed to
// send, we're done
reply_count++;
if (count != 0 && reply_count == count) {
break;
}
} while (timeout > 0);
seqno++;
seqno %= MAX_PINGS_IN_FLIGHT;
}
dtn_close(handle);
return 0;
}
int
main(int argc, char** argv)
{
int i, errs;
int ret;
dtn_handle_t handle;
dtn_endpoint_id_t local_eid;
dtn_reg_info_t reginfo;
dtn_bundle_spec_t spec;
dtn_bundle_payload_t payload;
int call_bind;
time_t now;
// force stdout to always be line buffered, even if output is
// redirected to a pipe or file
setvbuf(stdout, (char *)NULL, _IOLBF, 0);
progname = argv[0];
parse_options(argc, argv);
printf("dtnsink starting up -- waiting for %u bundles\n", count);
// open the ipc handle
if (verbose) printf("opening connection to dtn router...\n");
int err = dtn_open(&handle);
if (err != DTN_SUCCESS) {
fprintf(stderr, "fatal error opening dtn handle: %s\n",
dtn_strerror(err));
exit(1);
}
if (verbose) printf("opened connection to dtn router...\n");
// if we're not given a regid, or we're in change mode, we need to
// build up the reginfo
memset(®info, 0, sizeof(reginfo));
if ((regid == DTN_REGID_NONE) || change)
{
// if the specified eid starts with '/', then build a local
// eid based on the configuration of our dtn router plus the
// demux string. otherwise make sure it's a valid one
if (endpoint[0] == '/') {
if (verbose) printf("calling dtn_build_local_eid.\n");
dtn_build_local_eid(handle, &local_eid, (char *) endpoint);
if (verbose) printf("local_eid [%s]\n", local_eid.uri);
} else {
if (verbose) printf("calling parse_eid_string\n");
if (dtn_parse_eid_string(&local_eid, endpoint)) {
fprintf(stderr, "invalid destination endpoint '%s'\n",
endpoint);
goto err;
}
}
// create a new registration based on this eid
dtn_copy_eid(®info.endpoint, &local_eid);
reginfo.regid = regid;
reginfo.expiration = expiration;
reginfo.flags = failure_action;
reginfo.script.script_val = failure_script;
reginfo.script.script_len = strlen(failure_script) + 1;
}
if (change) {
if ((ret = dtn_change_registration(handle, regid, ®info)) != 0) {
fprintf(stderr, "error changing registration: %d (%s)\n",
ret, dtn_strerror(dtn_errno(handle)));
goto err;
}
printf("change registration succeeded, regid %d\n", regid);
goto done;
}
if (unregister) {
if (dtn_unregister(handle, regid) != 0) {
fprintf(stderr, "error in unregister regid %d: %s\n",
regid, dtn_strerror(dtn_errno(handle)));
goto err;
}
printf("unregister succeeded, regid %d\n", regid);
goto done;
}
// try to see if there is an existing registration that matches
// the given endpoint, in which case we'll use that one.
if (regid == DTN_REGID_NONE && ! no_find_reg) {
if (dtn_find_registration(handle, &local_eid, ®id) != 0) {
if (dtn_errno(handle) != DTN_ENOTFOUND) {
fprintf(stderr, "error in find_registration: %s\n",
dtn_strerror(dtn_errno(handle)));
goto err;
}
}
printf("find registration succeeded, regid %d\n", regid);
call_bind = 1;
}
// if the user didn't give us a registration to use, get a new one
if (regid == DTN_REGID_NONE) {
if ((ret = dtn_register(handle, ®info, ®id)) != 0) {
fprintf(stderr, "error creating registration: %d (%s)\n",
ret, dtn_strerror(dtn_errno(handle)));
goto err;
}
printf("register succeeded, regid %d\n", regid);
call_bind = 0;
} else {
call_bind = 1;
}
if (register_only) {
goto done;
}
if (call_bind) {
// bind the current handle to the found registration
printf("binding to regid %d\n", regid);
if (dtn_bind(handle, regid) != 0) {
fprintf(stderr, "error binding to registration: %s\n",
dtn_strerror(dtn_errno(handle)));
goto err;
}
}
// keep track of what we've seen
char *received = (char *)malloc(count + 1);
memset(received, '\0', count);
// loop waiting for bundles
fprintf(stderr, "waiting %d seconds for first bundle...\n",
(MAX_STARTUP_TRIES)*RECV_TIMEOUT/1000);
for (i = 1; i <= count; ++i) {
int tries;
uint32_t which;
uint32_t size;
memset(&spec, 0, sizeof(spec));
memset(&payload, 0, sizeof(payload));
/*
* this is a little tricky. We want dtn_recv to time out after
* RECV_TIMEOUT ms, so we don't wait a long time for a bundle
* if something is broken and no bundle is coming. But we
* want to be friendly and wait patiently for the first
* bundle, in case dtnsource is slow in getting off the mark.
*
* So we loop at most MAX_STARTUP_TRIES times
*/
tries = 0;
while ((ret = dtn_recv(handle, &spec, bundletype, &payload,
RECV_TIMEOUT)) < 0) {
/* if waiting for the first bundle and we timed out be patient */
if (dtn_errno(handle) == DTN_ETIMEOUT) {
if (i == 1 && ++tries < MAX_STARTUP_TRIES) {
fprintf(stderr, "waiting %d seconds for first bundle...\n",
(MAX_STARTUP_TRIES-tries)*RECV_TIMEOUT/1000);
} else {
/* timed out waiting, something got dropped */
fprintf(stderr, "timeout waiting for bundle %d\n", i);
goto bail;
}
} else {
/* a bad thing has happend in recv, or we've lost patience */
fprintf(stderr, "error in dtn_recv: %d (%d, %s)\n", ret,
dtn_errno(handle), dtn_strerror(dtn_errno(handle)));
goto bail;
}
}
if (i == 1) {
now = time(0);
printf("received first bundle at %s\n", ctime(&now));
}
if (verbose) {
printf("bundle %d received successfully: id %s,%llu.%llu\n",
i,
spec.source.uri,
spec.creation_ts.secs,
spec.creation_ts.seqno);
}
if (!promiscuous) {
/* check to see which bundle this is */
// Files need to be handled differently than memory transfers
if (payload.location == DTN_PAYLOAD_FILE) {
if (handle_file_transfer(payload, &size, &which) < 0) {
dtn_free_payload(&payload);
continue;
}
} else {
which = ntohl(*(uint32_t *)payload.buf.buf_val);
size = payload.buf.buf_len;
}
if (which > (uint32_t) count) {
// note that the above cast is safe as count always >= 0
fprintf(stderr, "-- expecting %d bundles, saw bundle %u\n",
count, which);
}
else if (which <= 0) { /* because I am paranoid -DJE */
fprintf(stderr, "-- didn't expect bundle %u\n", which);
}
else {
++received[which];
}
}
// XXX should verify size here...
/* all done, get next one */
dtn_free_payload(&payload);
}
bail:
for (i = 1; i <= count; ++i) {
if (received[i] == 0) {
int j = i + 1;
while (j <= count && received[j] == 0)
++j;
if (j == i + 1)
printf("bundle %d: dropped\n", i);
else
printf("bundles %d-%d dropped\n", i, j - 1);
errs += (j - i);
i += (j - i - 1);
} else if (received[i] > 1) {
printf("bundle %d: received %d copies\n", i, received[i]);
++errs;
}
}
if (errs == 0) {
printf("all %d bundles received correctly\n", count);
}
free(received);
now = time(0);
printf("terminating at %s\n", ctime(&now));
done:
dtn_close(handle);
return 0;
err:
dtn_close(handle);
return 1;
}
int
main(int argc, char** argv)
{
int ret;
dtn_handle_t handle;
dtn_reg_info_t reginfo;
dtn_reg_id_t regid = DTN_REGID_NONE;
dtn_bundle_spec_t bundle_spec;
dtn_bundle_spec_t reply_spec;
dtn_bundle_payload_t send_payload;
dtn_bundle_payload_t reply_payload;
dtn_bundle_id_t bundle_id;
char demux[4096];
struct timeval start, end;
/* FILE * file; */
/* //struct stat finfo; */
/* char buffer[4096]; // max filesize to send is 4096 (temp) */
/* int bufsize = 0; */
// force stdout to always be line buffered, even if output is
// redirected to a pipe or file
setvbuf(stdout, (char *)NULL, _IOLBF, 0);
parse_options(argc, argv);
// open the ipc handle
if (verbose) fprintf(stdout, "Opening connection to local DTN daemon\n");
int err = 0;
if (api_IP_set) err = dtn_open_with_IP(api_IP,api_port,&handle);
else err = dtn_open(&handle);
if (err != DTN_SUCCESS) {
fprintf(stderr, "fatal error opening dtn handle: %s\n",
dtn_strerror(err));
exit(1);
}
// ----------------------------------------------------
// initialize bundle spec with src/dest/replyto
// ----------------------------------------------------
// initialize bundle spec
memset(&bundle_spec, 0, sizeof(bundle_spec));
// destination host is specified at run time, demux is hardcoded
sprintf(demux, "%s/dtncp/recv?file=%s", arg_dest, arg_target);
parse_eid(handle, &bundle_spec.dest, demux);
// source is local eid with file path as demux string
sprintf(demux, "/dtncp/send?source=%s", data_source);
parse_eid(handle, &bundle_spec.source, demux);
if (verbose)
{
print_eid("source_eid", &bundle_spec.source);
print_eid("dest_eid", &bundle_spec.dest);
}
// set the expiration time (one hour)
bundle_spec.expiration = expiration_time;
if (delivery_receipts)
{
// set the delivery receipt option
bundle_spec.dopts |= DOPTS_DELIVERY_RCPT;
}
// fill in a payload
memset(&send_payload, 0, sizeof(send_payload));
dtn_set_payload(&send_payload, DTN_PAYLOAD_FILE,
data_source, strlen(data_source));
// send file and wait for reply
// create a new dtn registration to receive bundle status reports
memset(®info, 0, sizeof(reginfo));
dtn_copy_eid(®info.endpoint, &bundle_spec.source);
reginfo.flags = DTN_REG_DEFER;
reginfo.regid = regid;
reginfo.expiration = 0;
if ((ret = dtn_register(handle, ®info, ®id)) != 0) {
fprintf(stderr, "error creating registration (id=%d): %d (%s)\n",
regid, ret, dtn_strerror(dtn_errno(handle)));
exit(1);
}
if (verbose) printf("dtn_register succeeded, regid 0x%x\n", regid);
gettimeofday(&start, NULL); // timer
memset(&bundle_id, 0, sizeof(bundle_id));
if ((ret = dtn_send(handle, regid, &bundle_spec, &send_payload,
&bundle_id)) != 0) {
fprintf(stderr, "error sending file bundle: %d (%s)\n",
ret, dtn_strerror(dtn_errno(handle)));
exit(1);
}
if (delivery_receipts)
{
memset(&reply_spec, 0, sizeof(reply_spec));
memset(&reply_payload, 0, sizeof(reply_payload));
// now we block waiting for the echo reply
if ((ret = dtn_recv(handle, &reply_spec,
DTN_PAYLOAD_MEM, &reply_payload, -1)) < 0)
{
fprintf(stderr, "error getting reply: %d (%s)\n",
ret, dtn_strerror(dtn_errno(handle)));
exit(1);
}
gettimeofday(&end, NULL);
printf("file sent successfully to [%s]: time=%.1f ms\n",
reply_spec.source.uri,
((double)(end.tv_sec - start.tv_sec) * 1000.0 +
(double)(end.tv_usec - start.tv_usec)/1000.0));
dtn_free_payload(&reply_payload);
}
else
{
printf("file sent to [%s]\n",
bundle_spec.dest.uri);
}
dtn_close(handle);
return 0;
}
int
main(int argc, const char** argv)
{
int ret;
dtn_handle_t handle;
dtn_endpoint_id_t source_eid;
dtn_endpoint_id_t replyto_eid;
dtn_reg_info_t reginfo;
dtn_reg_id_t regid;
dtn_bundle_spec_t ping_spec;
dtn_bundle_spec_t reply_spec;
dtn_bundle_payload_t ping_payload;
ping_payload_t payload_contents;
ping_payload_t recv_contents;
dtn_bundle_payload_t reply_payload;
dtn_bundle_status_report_t* sr_data;
dtn_bundle_id_t bundle_id;
int debug = 1;
char demux[64];
int dest_len = 0;
struct timeval send_time, now;
u_int32_t nonce;
int done;
time_t clock;
struct tm* tm_buf;
// force stdout to always be line buffered, even if output is
// redirected to a pipe or file
setvbuf(stdout, (char *)NULL, _IOLBF, 0);
doOptions(argc, argv);
memset(&ping_spec, 0, sizeof(ping_spec));
gettimeofday(&now, 0);
srand(now.tv_sec);
nonce = rand();
// open the ipc handle
int err = 0;
if (api_IP_set) err = dtn_open_with_IP(api_IP,api_port,&handle);
else err = dtn_open(&handle);
if (err != DTN_SUCCESS) {
fprintf(stderr, "fatal error opening dtn handle: %s\n",
dtn_strerror(err));
exit(1);
}
// make sure they supplied a valid destination eid or
// "localhost", in which case we just use the local daemon
if (strcmp(dest_eid_str, "localhost") == 0) {
dtn_build_local_eid(handle, &ping_spec.dest, "ping");
} else {
if (dtn_parse_eid_string(&ping_spec.dest, dest_eid_str)) {
fprintf(stderr, "invalid destination eid string '%s'\n",
dest_eid_str);
exit(1);
}
}
dest_len = strlen(ping_spec.dest.uri);
if ((dest_len < 4) ||
(strcmp(ping_spec.dest.uri + dest_len - 4, "ping") != 0))
{
fprintf(stderr, "\nWARNING: ping destination does not end in \"ping\"\n\n");
}
// if the user specified a source eid, register on it.
// otherwise, build a local eid based on the configuration of
// our dtn router plus the demux string
snprintf(demux, sizeof(demux), "/traceroute.%d", getpid());
if (source_eid_str[0] != '\0') {
if (dtn_parse_eid_string(&source_eid, source_eid_str)) {
fprintf(stderr, "invalid source eid string '%s'\n",
source_eid_str);
exit(1);
}
} else {
dtn_build_local_eid(handle, &source_eid, demux);
}
if (debug) printf("source_eid [%s]\n", source_eid.uri);
dtn_copy_eid(&ping_spec.source, &source_eid);
// Make the replyto EID
if ( replyto_eid_str[0]!=0 ) {
if (dtn_parse_eid_string(&replyto_eid, replyto_eid_str)) {
fprintf(stderr, "invalid replyto eid string '%s'\n",
replyto_eid_str);
exit(1);
}
dtn_copy_eid(&ping_spec.replyto, &replyto_eid);
printf("using user-supplied replyto\n");
} else {
dtn_copy_eid(&ping_spec.replyto, &source_eid);
printf("using default replyto\n");
}
// now create a new registration based on the source
// if the replyto EID is unspecified or the same as the
// source EID then we'll get status reports, otherwise
// they'll go somewhere else.
memset(®info, 0, sizeof(reginfo));
dtn_copy_eid(®info.endpoint, &source_eid);
reginfo.flags = DTN_REG_DROP;
reginfo.regid = DTN_REGID_NONE;
reginfo.expiration = 0;
if ((ret = dtn_register(handle, ®info, ®id)) != 0) {
fprintf(stderr, "error creating registration: %d (%s)\n",
ret, dtn_strerror(dtn_errno(handle)));
exit(1);
}
if (debug) printf("dtn_register succeeded, regid %d\n", regid);
// set the expiration time and request a bunch of status reports
ping_spec.expiration = expiration;
ping_spec.dopts = DOPTS_DELETE_RCPT |
DOPTS_RECEIVE_RCPT |
DOPTS_FORWARD_RCPT |
DOPTS_DELIVERY_RCPT;
// loop, sending pings and polling for activity
gettimeofday(&send_time, NULL);
// fill in a short payload string, a nonce, and a sequence number
// to verify the echo feature and make sure we're not getting
// duplicate responses or ping responses from another app
memcpy(&payload_contents.ping, PING_STR, 8);
payload_contents.seqno = 0;
payload_contents.nonce = nonce;
payload_contents.time = send_time.tv_sec;
memset(&ping_payload, 0, sizeof(ping_payload));
dtn_set_payload(&ping_payload, DTN_PAYLOAD_MEM,
(char*)&payload_contents, sizeof(payload_contents));
memset(&bundle_id, 0, sizeof(bundle_id));
if ((ret = dtn_send(handle, regid, &ping_spec, &ping_payload, &bundle_id)) != 0) {
fprintf(stderr, "error sending bundle: %d (%s)\n",
ret, dtn_strerror(dtn_errno(handle)));
exit(1);
}
memset(&reply_spec, 0, sizeof(reply_spec));
memset(&reply_payload, 0, sizeof(reply_payload));
clock = time(&clock);
tm_buf = gmtime(&clock);
printf("%s: sent at %.*s UTC\n",
ping_spec.source.uri, 24, asctime(tm_buf));
// now loop waiting for replies / status reports until we're done
done = 0;
while (1) {
int timeout = done ? wait_after_done * 1000 : -1;
if ((ret = dtn_recv(handle, &reply_spec,
DTN_PAYLOAD_MEM, &reply_payload, timeout)) < 0)
{
if (done && dtn_errno(handle) == DTN_ETIMEOUT) {
break;
}
fprintf(stderr, "error getting ping reply: %d (%s)\n",
ret, dtn_strerror(dtn_errno(handle)));
exit(1);
}
gettimeofday(&now, 0);
if (reply_payload.status_report != NULL)
{
sr_data = reply_payload.status_report;
if (sr_data->flags & STATUS_RECEIVED)
{
clock = sr_data->receipt_ts.secs + DTNTIME_OFFSET;
tm_buf = gmtime(&clock);
printf("%s: received at %.*s UTC (%ld ms rtt)\n",
reply_spec.source.uri, 24, asctime(tm_buf),
TIMEVAL_DIFF_MSEC(now, send_time));
}
if (sr_data->flags & STATUS_FORWARDED)
{
clock = sr_data->forwarding_ts.secs + DTNTIME_OFFSET;
tm_buf = gmtime(&clock);
printf("%s: forwarded at %.*s UTC (%ld ms rtt)\n",
reply_spec.source.uri, 24, asctime(tm_buf),
TIMEVAL_DIFF_MSEC(now, send_time));
}
if (sr_data->flags & STATUS_DELIVERED)
{
clock = sr_data->delivery_ts.secs + DTNTIME_OFFSET;
tm_buf = gmtime(&clock);
printf("%s: delivered at %.*s UTC (%ld ms rtt)\n",
reply_spec.source.uri, 24, asctime(tm_buf),
TIMEVAL_DIFF_MSEC(now, send_time));
}
if (sr_data->flags & STATUS_DELETED)
{
clock = sr_data->deletion_ts.secs + DTNTIME_OFFSET;
tm_buf = gmtime(&clock);
printf("%s: deleted at %.*s UTC (%s) (%ld ms rtt)\n",
reply_spec.source.uri, 24, asctime(tm_buf),
dtn_status_report_reason_to_str(sr_data->reason),
TIMEVAL_DIFF_MSEC(now, send_time));
break;
}
}
else {
if (reply_payload.buf.buf_len != sizeof(ping_payload_t))
{
printf("%d bytes from [%s]: ERROR: length != %zu\n",
reply_payload.buf.buf_len,
reply_spec.source.uri,
sizeof(ping_payload_t));
break;
}
memcpy(&recv_contents, reply_payload.buf.buf_val,
sizeof(recv_contents));
if (recv_contents.seqno != 0)
{
printf("%d bytes from [%s]: ERROR: invalid seqno %d\n",
reply_payload.buf.buf_len,
reply_spec.source.uri,
recv_contents.seqno);
break;
}
if (recv_contents.nonce != nonce)
{
printf("%d bytes from [%s]: ERROR: invalid nonce %u != %u\n",
reply_payload.buf.buf_len,
reply_spec.source.uri,
recv_contents.nonce, nonce);
break;
}
if ((int)recv_contents.time != (int)send_time.tv_sec)
{
printf("%d bytes from [%s]: ERROR: time mismatch %u != %lu\n",
reply_payload.buf.buf_len,
reply_spec.source.uri,
recv_contents.time,
(long unsigned int)send_time.tv_sec);
}
clock = reply_spec.creation_ts.secs + DTNTIME_OFFSET;
tm_buf = gmtime(&clock);
printf("%s: echo reply at %.*s UTC (%ld ms rtt)\n",
reply_spec.source.uri, 24, asctime(tm_buf),
TIMEVAL_DIFF_MSEC(now, send_time));
done = 1;
}
dtn_free_payload(&reply_payload);
}
dtn_close(handle);
return 0;
}
int
reader_thread(void *p)
{
// loop reading from motes, writing to directory
static int tcnt=0;
DATAPACKET *dataPacket;
// dtn api variables
int ret;
dtn_handle_t handle;
dtn_reg_info_t reginfo;
dtn_reg_id_t regid = DTN_REGID_NONE;
dtn_bundle_spec_t bundle_spec;
dtn_bundle_payload_t send_payload;
dtn_bundle_id_t bundle_id;
char demux[4096];
p = NULL;
// open the ipc handle
if (debug > 0) fprintf(stdout, "Opening connection to local DTN daemon\n");
int err = 0;
if (api_IP_set) err = dtn_open_with_IP(api_IP,api_port,&handle);
else err = dtn_open(&handle);
if (err != DTN_SUCCESS) {
fprintf(stderr, "fatal error opening dtn handle: %s\n",
dtn_strerror(err));
exit(1);
}
// ----------------------------------------------------
// initialize bundle spec with src/dest/replyto
// ----------------------------------------------------
// initialize bundle spec
memset(&bundle_spec, 0, sizeof(bundle_spec));
// destination host is specified at run time, demux is hardcoded
sprintf(demux, "%s/dtnmoteproxy/recv", arg_dest);
parse_eid(handle, &bundle_spec.dest, demux);
// source is local eid with file path as demux string
sprintf(demux, "/dtnmoteproxy/send");
parse_eid(handle, &bundle_spec.source, demux);
// reply to is the same as the source
dtn_copy_eid(&bundle_spec.replyto, &bundle_spec.source);
if (debug > 2)
{
print_eid("source_eid", &bundle_spec.source);
print_eid("replyto_eid", &bundle_spec.replyto);
print_eid("dest_eid", &bundle_spec.dest);
}
// set the return receipt option
bundle_spec.dopts |= DOPTS_DELIVERY_RCPT;
// send file and wait for reply
// create a new dtn registration to receive bundle status reports
memset(®info, 0, sizeof(reginfo));
dtn_copy_eid(®info.endpoint, &bundle_spec.replyto);
reginfo.flags = DTN_REG_DEFER;
reginfo.regid = regid;
reginfo.expiration = 0;
if ((ret = dtn_register(handle, ®info, ®id)) != 0) {
fprintf(stderr, "error creating registration (id=%d): %d (%s)\n",
regid, ret, dtn_strerror(dtn_errno(handle)));
exit(1);
}
if (debug > 3) printf("dtn_register succeeded, regid 0x%x\n", regid);
while (1) {
static unsigned char motedata[BUFSIZ];
int length;
int ret;
if (debug > 1) fprintf(dout, "about to read from motes...\n");
while((ret=read_packet((char *) motedata, (int *) &length))) {
if(ret==DEBUG_PKT)
continue;
if (debug > 0) {
fprintf(dout, "\nreader loop... got [%d] bytes from motes\n",
length);
if (debug > 1) hexdump(motedata, length);
}
// the extra cast to void* is needed to circumvent gcc warnings
// about unsafe casting
dataPacket=(DATAPACKET *)((void*)motedata);
// skip packets from base mote
if(dataPacket->origin_mote_id == 0) continue;
// set a default expiration time of one hour
bundle_spec.expiration = 3600;
// fill in a payload
memset(&send_payload, 0, sizeof(send_payload));
dtn_set_payload(&send_payload, DTN_PAYLOAD_MEM,
(char *) motedata, length);
memset(&bundle_id, 0, sizeof(bundle_id));
if ((ret = dtn_send(handle, regid, &bundle_spec, &send_payload,
&bundle_id)) != 0)
{
fprintf(stderr, "error sending bundle: %d (%s)\n",
ret, dtn_strerror(dtn_errno(handle)));
}
else fprintf(stderr, "motedata bundle sent");
printf("Mote ID = %u\n",dataPacket->origin_mote_id);
printf("Source Mote ID = %u\n",dataPacket->source_mote_id);
printf("Hop Count = %u\n",dataPacket->hop_cnt);
printf("Packet Type = %u\n",dataPacket->surge_pkt_type);
printf("Parent Address = %u\n",dataPacket->surge_parent_addr);
printf("Sequence Number = %u\n", (u_int)dataPacket->surge_seq_no);
printf("Light = %u\n",dataPacket->light);
printf("Temperature = %u\n\n",dataPacket->temp);
tcnt=(tcnt+1)%10000;
}
if (debug > 0)
fprintf(dout, "reader loop.... nothing to do? [shouldn't happen]\n");
}
// if this was ever changed to gracefully shutdown, it would be good to call:
dtn_close(handle);
return (1);
// NOTREACHED
}
