DTN2-BPQ: comparison apps/dtnquery/dtnquery.c

equal deleted inserted replaced

-:3d5d756acac0
+:3d1ea31e2a19
 usage()
 {
 fprintf(stderr, "usage: %s -s < src endpoint > -d < dest endpoint > "
 "[opts]\n", progname);
 fprintf(stderr, "options:\n");
+fprintf(stderr, " -r  < eid > reply to endpoint\n");
 fprintf(stderr, " -f  < filename > response filename\n");
 fprintf(stderr, " -q  < query > query or matching file\n");
 fprintf(stderr, " -t  < literal | base64 | file > query type\n");
-fprintf(stderr, " -r  < exact > matching rule\n");
+fprintf(stderr, " -u  < exact > matching rule\n");
 fprintf(stderr, " -m  < send | receive | both > mode\n");
 fprintf(stderr, " -n  < count > number of bundles to recv\n");
 fprintf(stderr, " -o  < seconds > timeout\n");
 fprintf(stderr, " -e  < seconds > bundle expiry time\n");
 fprintf(stderr, " -i  < regid > existing registration id\n");
 *******************************************************************************/
 int
 parse_options(int argc, char** argv,
 char * src_eid_name,                // s
 char * dest_eid_name,               // d
+char * reply_eid_name,              // r
 char * filename,                    // f
 char * query,                       // q
 int * query_type,                   // t
-int * matching_rule,                // r
+int * matching_rule,                // u
 int * mode,                         // m
 int * count,                        // n
 dtn_timeval_t * timeout,            // o
 dtn_timeval_t * bundle_expiry,      // e
 dtn_reg_id_t  * regid,              // i
 progname = argv[0];
 //initialize strings
 memset(src_eid_name,    0, sizeof(char) * PATH_MAX);
 memset(dest_eid_name,   0, sizeof(char) * PATH_MAX);
+memset(reply_eid_name,  0, sizeof(char) * PATH_MAX);
 memset(filename,        0, sizeof(char) * PATH_MAX);
 memset(query,           0, sizeof(char) * PATH_MAX);
 memset(matching_file,   0, sizeof(char) * PATH_MAX);
 memset(reg_fail_script, 0, sizeof(char) * PATH_MAX);
 while( !done )
 {
-c = getopt(argc, argv, "s:d:f:q:t:r:m:n:o:e:i:E:A:S:P:DXFcC1NWvhH");
+c = getopt(argc, argv, "s:d:f:q:t:r:u:m:n:o:e:i:E:A:S:P:DXFcC1NWvhH");
 switch(c)
 {
 case 's':
 strncpy(src_eid_name, optarg, PATH_MAX);
 break;
 case 'd':
 strncpy(dest_eid_name, optarg, PATH_MAX);
+break;
+case 'r':
+strncpy(reply_eid_name, optarg, PATH_MAX);
 break;
 case 'f':
 strncpy(filename, optarg, PATH_MAX);
 break;
 case 'q':
 } else {
 fprintf(stderr, "invalid query type '%s'\n", optarg);
 usage();
 exit(1);
 }
-case 'r':
+case 'u':
 if (!strcasecmp(optarg, "exact")) {
 *matching_rule = DTN_BPQ_EXACT;
 break;
 } else {
 fprintf(stderr, "invalid query type '%s'\n", optarg);
 // getopt already prints error message for unknown option characters
 usage();
 exit(1);
 }
-// now set matching file if required
+}
-if (*query_type == DTN_BPQ_FILE) {
+// now set matching file if required
-strncpy(matching_file, query, PATH_MAX);
+if (*query_type == DTN_BPQ_FILE) {
-memset(query, 0, sizeof(char) * PATH_MAX);
+strncpy(matching_file, query, PATH_MAX);
+memset(query, 0, sizeof(char) * PATH_MAX);
-int ret = parse_matching_file(matching_file, matching_rule,
-query_type, query, bundle_expiry, *verbose);
+int ret = parse_matching_file(matching_file, matching_rule,
-if (ret != DTN_SUCCESS) {
+query_type, query, bundle_expiry, *verbose);
-fprintf(stderr, "error parsing matching file, "
+if (ret != DTN_SUCCESS) {
-"see man page dtnmatch(1)\n");
+fprintf(stderr, "error parsing matching file, "
-usage(1);
+"see man page dtnmatch(1)\n");
-exit(1);
+usage(1);
-}
+exit(1);
 }
 }
+// if no reply-to eid set, use the src eid
+if (reply_eid_name == NULL)
+strncpy(reply_eid_name, src_eid_name, PATH_MAX);
 return 0;
 }
 /*******************************************************************************
 * validate options:
 * returns success or exits on failure
 *******************************************************************************/
 int
 validate_options(const char * src_eid_name,
 const char * dest_eid_name,
+const char * reply_eid_name,
 const char * query,
 int query_type,
 int matching_rule,
 int mode,
 dtn_timeval_t bundle_expiry)
 switch (mode)
 {
 case DTN_BPQ_SEND:  //requires src, dest, query
 REQUIRE(strlen(src_eid_name) > 0, "-s <src eid> required\n");
 REQUIRE(strlen(dest_eid_name) > 0, "-d <dest eid> required\n");
+REQUIRE(strlen(reply_eid_name) > 0, "-r <reply eid> required\n");
 REQUIRE(strlen(query) > 0, "-q <query> required\n");
 break;
 case DTN_BPQ_RECV:  //requires src
 REQUIRE(strlen(src_eid_name) > 0, "-s <src eid> required\n");
+REQUIRE(strlen(reply_eid_name) > 0, "-r <reply eid> required\n");
 break;
 case DTN_BPQ_SEND_RECV: //requires src, dest, query
 REQUIRE(strlen(src_eid_name) > 0, "-s <src eid> required\n");
 REQUIRE(strlen(dest_eid_name) > 0, "-d <dest eid> required\n");
+REQUIRE(strlen(reply_eid_name) > 0, "-r <reply eid> required\n");
 REQUIRE(strlen(query) > 0, "-q <query> required\n");
 break;
 default:
 REQUIRE(mode == DTN_BPQ_SEND ||
 mode == DTN_BPQ_RECV ||
 }
 REQUIRE(query_type == DTN_BPQ_LITERAL ||
 query_type == DTN_BPQ_BASE64  ||
 query_type == DTN_BPQ_FILE, "-t <query type> invalid type\n");
-REQUIRE(matching_rule == DTN_BPQ_EXACT, "-r <matching rule> invalid rule\n");
+REQUIRE(matching_rule == DTN_BPQ_EXACT, "-u <matching rule> invalid rule\n");
 REQUIRE(bundle_expiry > 0, "-e <expiry> must be a positive integer\n");
 #undef REQUIRE
 //todo: check this is ok
 return 0;
 }
 int
 send_bpq(dtn_handle_t handle,
 dtn_reg_id_t regid,
 const dtn_endpoint_id_t * src_eid,
 const dtn_endpoint_id_t * dest_eid,
+const dtn_endpoint_id_t * reply_eid,
 char * query,
 int matching_rule,
 int bundle_expiry,
 dtn_bundle_priority_t  priority,
 int delivery_options,
 dtn_set_payload(&payload, DTN_PAYLOAD_MEM, NULL, 0);
 // set the bundle spec eids
 if (verbose) fprintf(stdout, "Source: %s\n", src_eid->uri);
 if (verbose) fprintf(stdout, "Destination: %s\n", dest_eid->uri);
+if (verbose) fprintf(stdout, "Reply-To: %s\n", reply_eid->uri);
 bundle_spec.source = *src_eid;
 bundle_spec.dest = *dest_eid;
+bundle_spec.replyto = *reply_eid;
-dtn_copy_eid(&bundle_spec.replyto, &bundle_spec.source);// add support for this to be set differently
 // set the bundle spec dtn options
 bundle_spec.expiration = bundle_expiry;
 bundle_spec.dopts = delivery_options;
 bundle_spec.priority = priority;
 main(int argc, char** argv)
 {
 dtn_endpoint_id_t reg_eid;
 dtn_endpoint_id_t src_eid;
 dtn_endpoint_id_t dest_eid;
+dtn_endpoint_id_t reply_eid;
 char reg_eid_name[PATH_MAX];
 char src_eid_name[PATH_MAX];
 char dest_eid_name[PATH_MAX];
+char reply_eid_name[PATH_MAX];
 char filename[PATH_MAX];
 char query[PATH_MAX];
 int query_type = DTN_BPQ_LITERAL;
 int matching_rule = DTN_BPQ_EXACT;
 int mode = DTN_BPQ_SEND_RECV;
 dtn_handle_t handle;
 memset( reg_eid_name,   0, sizeof(char) * PATH_MAX );
 memset( src_eid_name,   0, sizeof(char) * PATH_MAX );
 memset( dest_eid_name,  0, sizeof(char) * PATH_MAX );
+memset( reply_eid_name,  0, sizeof(char) * PATH_MAX );
 memset( filename,       0, sizeof(char) * PATH_MAX );
 memset( query,          0, sizeof(char) * PATH_MAX );
 parse_options(argc, argv,
 src_eid_name,
 dest_eid_name,
+reply_eid_name,
 filename,
 query,
 &query_type,
 &matching_rule,
 &mode,
 snprintf(&(reg_eid_name[0]), PATH_MAX, "%s", src_eid_name);
 }
 validate_options(src_eid_name,
 dest_eid_name,
+reply_eid_name,
 query,
 query_type,
 matching_rule,
 mode,
 bundle_expiry);
 // parse eids
 parse_eid(handle, &reg_eid, reg_eid_name, verbose);
 parse_eid(handle, &src_eid, src_eid_name, verbose);
 parse_eid(handle, &dest_eid, dest_eid_name, verbose);
+parse_eid(handle, &reply_eid, reply_eid_name, verbose);
 if (verbose) fprintf(stdout, "parsed reg_eid: %s\n", reg_eid.uri);
 if (verbose) fprintf(stdout, "parsed src_eid: %s\n", src_eid.uri);
 if (verbose) fprintf(stdout, "parsed dest_eid: %s\n", dest_eid.uri);
+if (verbose) fprintf(stdout, "parsed reply_eid: %s\n", reply_eid.uri);
 if (verbose) fprintf(stdout, "regid: %d\n", regid);
 // get dtn registration
 if (verbose) fprintf(stdout, "registering with dtn...\n");
 register_with_dtn(handle,
 fprintf(stderr, err_msg); \
 dtn_close(handle); \
 exit(1); \
 }
 case DTN_BPQ_SEND:
-TRY( send_bpq(handle, regid, &src_eid, &dest_eid, query,
+TRY( send_bpq(handle, regid, &src_eid, &dest_eid, &reply_eid, query,
 matching_rule, bundle_expiry, priority,
 delivery_options, verbose), "error sending query\n" );
 break;
 case DTN_BPQ_RECV:
 TRY( recv_bpq(handle, timeout, filename, count, verbose),
 "error receiving query\n" );
 break;
 case DTN_BPQ_SEND_RECV:
-TRY( send_bpq(handle, regid, &src_eid, &dest_eid, query,
+TRY( send_bpq(handle, regid, &src_eid, &dest_eid, &reply_eid, query,
 matching_rule, bundle_expiry, priority,
 delivery_options, verbose), "error sending query\n" );
 TRY( recv_bpq(handle, timeout, filename, count, verbose),
 "error receiving query\n" );

changeset 18	3d1ea31e2a19
parent 16	dee8e37f24c2
child 20	7fd5f0de6c59