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

equal deleted inserted replaced

-:333724f2f7cf
+:e1101c5d54a1
 fprintf(stderr, "usage: %s -l < local endpoint > -f < matching filename > "
 "[opts]\n", progname);
 fprintf(stderr, "options:\n");
 fprintf(stderr, " -n  < count > exit after count bundles received\n");
 fprintf(stderr, " -r  < eid > reply to endpoint\n");
-fprintf(stderr, " -e  < seconds > bundle expiry time\n");
 fprintf(stderr, " -i  < regid > existing registration id\n");
 fprintf(stderr, " -E  < seconds > registration expiry time\n");
 fprintf(stderr, " -A  < defer | drop | exec > failure action\n");
 fprintf(stderr, " -S  < script > failure script for exec action\n");
 fprintf(stderr, " -P  < bulk | normal | expedited | reserved > priority\n");
 parse_options(int argc, char** argv,
 char * local_eid_name,              // l
 char * reply_eid_name,              // r
 char * matching_filename,           // f
 int * count,                        // n
-dtn_timeval_t * bundle_expiry,      // e
 dtn_reg_id_t * regid,               // i
 dtn_timeval_t * reg_expiry,         // E
 int * reg_fail_action,              // A
 char * reg_fail_script,             // S
 dtn_bundle_priority_t * priority,   // P
 memset(matching_filename, 0, sizeof(char) * PATH_MAX);
 memset(reg_fail_script,   0, sizeof(char) * PATH_MAX);
 while( !done )
 {
-c = getopt(argc, argv, "l:f:n:r:e:i:E:A:S:P:DXFRcC1NWvhH");
+c = getopt(argc, argv, "l:f:n:r:i:E:A:S:P:DXFRcC1NWvhH");
 switch(c)
 {
 case 'l':
 strncpy(local_eid_name, optarg, PATH_MAX);
 break;
 case 'f':
 strncpy(matching_filename, optarg, PATH_MAX);
 break;
 case 'n':
 *count = atoi(optarg);
-break;
-case 'e':
-*bundle_expiry = atoi(optarg);
 break;
 case 'i':
 *regid = atoi(optarg);
 break;
 case 'E':
 exit(1);
 }
 }
 // if no reply-to eid set, use the local eid
-if (*reply_eid_name == NULL)
+if (reply_eid_name == NULL)
 strncpy(reply_eid_name, local_eid_name, PATH_MAX);
 return DTN_SUCCESS;
 }
 memset(out, 0, out_len);
 // move past any leading whitespace
 // by testing if the current char is in the whitespace string
-while ( i<strlen(in) && strchr(whitespace, in[i]) != NULL )
+in_len = strlen(in);
+while ( i<in_len && strchr(whitespace, in[i]) != NULL )
 	++i;
 in_len = strlen(&(in[i]));
 if (in_len > out_len) {
 	fprintf(stderr, "Error trimming whitespace, input string [%d] is longer"
 * first move past any leading whitespace
 * after the first non-whitespace char escape any whitespace
 * @return 0 on success or -1 if input not completely read
 *******************************************************************************/
 int
-escape_spaces(const char * in, char * out, int out_len)
+escape_spaces(const char * in, char * out, size_t out_len)
 {
-int i=0, j=0;
+u_int i=0, j=0;
 char escape = '\\';
 char space = ' ';
 memset(out, 0, out_len);
 match_bpq(const dtn_bpq_extension_block_data_t * bpq,
 const char * matching_filename,
 u_int * response_kind,
 char  * response_path,
 int     response_path_len,
-int   * response_expiry,
+dtn_timeval_t * response_expiry,
 int   * found)
 {
 char line[PATH_MAX];
 char trim_path[PATH_MAX];
 char * matching_rule;
 	}
 	if (strncmp(line, "#", 1) == 0)
 		continue;
-	matching_rule 	= strtok(line, ",");
+	// if a null pointer is returned, loop again to get to the next line
-		query 			= strtok(NULL, ",");
+	if ((matching_rule 	= strtok(line, ",")) == NULL) continue;
-		path 	        = strtok(NULL, ",");
+	if ((query 			= strtok(NULL, ",")) == NULL) continue;
-		kind  			= strtok(NULL, ",");
+	if ((path 	        = strtok(NULL, ",")) == NULL) continue;
-		expiry			= strtok(NULL, ",");
+	if ((kind  			= strtok(NULL, ",")) == NULL) continue;
+	if ((expiry			= strtok(NULL, ",")) == NULL) continue;
 	// match query
 if (atoi(matching_rule) != (int)bpq->matching_rule		||
 			BPQ_MATCHING_RULE_EXACT != bpq->matching_rule		||
 // make sure the file exists
 if (response_path_exists(trim_path)) {
 	*found = 1;
 	*response_kind = (u_int) atoi(kind);
-	*response_expiry = atoi(response_expiry);
+	*response_expiry = (dtn_timeval_t) atoi(expiry);
 	strncpy(response_path, trim_path, response_path_len);
 			break;
 } else {
 	continue;
 * @return The number of bytes or -1 on error
 *******************************************************************************/
 int
 bpq_to_char_array(const dtn_bpq_extension_block_data_t * bpq,
 char* buf,
-size_t buf_len,
+int buf_len,
 int verbose)
 {
-int i=0, j=0, k=0;
+int i=0, j=0;
+	u_int k=0;
 int q_encoding_len, f_encoding_len, encoding_len;
-char encoding[PATH_MAX];
+u_char encoding[PATH_MAX];
 memset(buf, 0, buf_len);
 // BPQ-kind             1-byte
 if (i < buf_len)    buf[i++] = (char) bpq->kind;
 		for (j=0; i<buf_len && j<q_encoding_len; ++j)
 	        buf[i++] = encoding[j];
 	}
 // Source EID n-bytes
-for (j=0; i<buf_len && j<bpq->original_id.source_len; ++j)
+for (j=0; i<buf_len && j<(int)bpq->original_id.source_len; ++j)
 buf[i++] = bpq->original_id.source.uri[j];
 // Query length (SDNV)
 	for (j=0; i<buf_len && j<q_encoding_len; ++j)
 		buf[i++] = encoding[j];
 }
 // Query value n-bytes
-for (j=0; i<buf_len && j<bpq->query.query_len; ++j)
+for (j=0; i<buf_len && j<(int)bpq->query.query_len; ++j)
 buf[i++] = bpq->query.query_val[j];
 // number of fragments  SDNV
 fprintf (stdout, "  creation ts seq: %d\n",
 		 (int) bpq->original_id.creation_ts.seqno);
 fprintf (stdout, "   source eid len: %d\n",
 		 (int) bpq->original_id.source_len);
 fprintf (stdout, "       source eid: %s\n",
-		 (int) bpq->original_id.source.uri);
+		 bpq->original_id.source.uri);
 fprintf (stdout, "        query len: %d\n", bpq->query.query_len);
 fprintf (stdout, "   q_encoding_len: %d\n", q_encoding_len);
 fprintf (stdout, "        query val: %s\n", bpq->query.query_val);
 *   Fragment lengths     		SDNV
 *
 * @return The number of bytes or -1 on error
 *******************************************************************************/
 int
-char_array_to_bpq(const char* buf,
+char_array_to_bpq(const u_char* buf,
-size_t buf_len,
+int buf_len,
 dtn_bpq_extension_block_data_t * bpq,
 int verbose)
 {
 int i=0, j=0;
 int q_decoding_len, f_decoding_len, decoding_len;
 i += q_decoding_len;
 // Source EID length     SDNV
 if ( (q_decoding_len = sdnv_decode (&(buf[i]),
 									buf_len - i,
-									&(bpq->original_id.source_len))) == -1 ) {
+									(u_int64_t*)&(bpq->original_id.source_len))) == -1 ) {
 fprintf (stderr, "Error decoding source EID length\n");
 return -1;
 }
 i += q_decoding_len;
 // Source EID            n-bytes
 if (i<buf_len && bpq->original_id.source_len <= DTN_MAX_ENDPOINT_ID) {
-	strncpy(bpq->original_id.source.uri, &(buf[i]), bpq->original_id.source_len);
+	strncpy(bpq->original_id.source.uri, (char*)&(buf[i]), bpq->original_id.source_len);
 	i += bpq->original_id.source_len;
 } else {
 	fprintf (stderr, "Error copying source EID\n");
 		return -1;
 }
 // BPQ-value-length     SDNV
 if ( (q_decoding_len = sdnv_decode (&(buf[i]),
 									buf_len - i,
-									&(bpq->query.query_len))) == -1 ) {
+									(u_int64_t*)&(bpq->query.query_len))) == -1 ) {
 fprintf (stderr, "Error decoding BPQ-value-length\n");
 return -1;
 }
 i += q_decoding_len;
 // BPQ-value            n-bytes
-if (i<buf_len) bpq->query.query_val = &(buf[i]);
+if (i<buf_len) bpq->query.query_val = (char*)&(buf[i]);
 	i += bpq->query.query_len;
 // number of fragments  SDNV
 if ( (f_decoding_len = sdnv_decode (&(buf[i]),
 									buf_len - i,
-									&(bpq->fragments.num_frag_returned))) == -1 ) {
+									(u_int64_t*)&(bpq->fragments.num_frag_returned))) == -1 ) {
 fprintf (stderr, "Error decoding number of fragments\n");
 return -1;
 }
 i += f_decoding_len;
-for (j=0; i<buf_len && j<bpq->fragments.num_frag_returned; ++j) {
+for (j=0; i<buf_len && j<(int)bpq->fragments.num_frag_returned; ++j) {
 // fragment offsets     SDNV
 if ( (decoding_len = sdnv_decode (&(buf[i]),
 								  buf_len - i,
-								  &(bpq->fragments.frag_offsets[j]))) == -1 ) {
+								  (u_int64_t*)&(bpq->fragments.frag_offsets[j]))) == -1 ) {
 fprintf (stderr, "Error decoding fragment[%d] offset\n", j);
 return -1;
 }
 i += decoding_len;
 // fragment lengths     SDNV
 if ( (decoding_len = sdnv_decode (&(buf[i]),
 								  buf_len - i,
-								  &(bpq->fragments.frag_lenghts[j]))) == -1 ) {
+								  (u_int64_t*)&(bpq->fragments.frag_lenghts[j]))) == -1 ) {
 fprintf (stderr, "Error decoding fragment[%d] length\n", j);
 return -1;
 }
 i += decoding_len;
 }
 fprintf (stdout, "  creation ts seq: %d\n",
 		 (int) bpq->original_id.creation_ts.seqno);
 fprintf (stdout, "   source eid len: %d\n",
 		 (int) bpq->original_id.source_len);
 fprintf (stdout, "       source eid: %s\n",
-		 (int) bpq->original_id.source.uri);
+		 bpq->original_id.source.uri);
 fprintf (stdout, "        query len: %d\n", bpq->query.query_len);
 fprintf (stdout, "   q_decoding_len: %d\n", q_decoding_len);
 fprintf (stdout, "        query val: %s\n", bpq->query.query_val);
 int
 send_response_bpq(dtn_handle_t * handle,
 dtn_reg_id_t regid,
 u_int response_kind,
 dtn_bundle_spec_t * query_bundle_spec,
-const dtn_endpoint_id_t * reply_eid,
+dtn_endpoint_id_t * reply_eid,
 dtn_bpq_extension_block_data_t * query_bpq_block_data,
-const char * pathname,
+char * pathname,
-int bundle_expiry,
+dtn_timeval_t bundle_expiry,
 dtn_bundle_priority_t  priority,
 int delivery_options,
 int verbose)
 {
 int  ret = 0;
 char buf [PATH_MAX];
-size_t buf_len = 0;
+int buf_len = 0;
 dtn_bundle_id_t                 response_bundle_id;
 dtn_bundle_spec_t               response_bundle_spec;
 dtn_extension_block_t           response_bpq_block;
 dtn_bpq_extension_block_data_t  response_bpq_block_data;
 dtn_bundle_payload_t            response_payload;
 // send the bundle, bpq extension and empty payload
 ret = dtn_send(*handle, regid, &response_bundle_spec, &response_payload, &response_bundle_id);
 if (ret != DTN_SUCCESS) {
 fprintf(stderr, "error sending response bundle: %d (%s)\n",
-ret, dtn_strerror(dtn_errno(handle)));
+ret, dtn_strerror(dtn_errno(*handle)));
 } else if (verbose) {
 fprintf(stdout, "bundle sent successfully: id %s,%llu.%llu\n",
 response_bundle_id.source.uri,
 response_bundle_id.creation_ts.secs,
 response_bundle_id.creation_ts.seqno);
 * source of the query.
 *******************************************************************************/
 int
 receive_bpq(dtn_handle_t * handle,
 dtn_reg_id_t regid,
-const dtn_endpoint_id_t * reply_eid,
+dtn_endpoint_id_t * reply_eid,
 const char * matching_filename,
 int  count,
-int bundle_expiry,
 dtn_bundle_priority_t  priority,
 int delivery_options,
 int verbose)
 {
 int i, j, num_blocks, found, ret = 0;
+dtn_timeval_t bundle_expiry = 3600; // default one hour
 u_int response_kind;
 char pathname[PATH_MAX];
 dtn_bundle_spec_t              bundle_spec;
 dtn_extension_block_t          * bpq_blocks;
 dtn_bpq_extension_block_data_t bpq_block_data;
 if (bpq_blocks[j].type == DTN_BPQ_BLOCK_TYPE) {
 if (verbose) fprintf(stdout, "bundle %d contains a "
 "BPQ extension block\n", i);
-ret = char_array_to_bpq(bpq_blocks[j].data.data_val,
+ret = char_array_to_bpq((u_char*)bpq_blocks[j].data.data_val,
 bpq_blocks[j].data.data_len,
 &bpq_block_data,
-					verbose);
+verbose);
 if (ret != DTN_SUCCESS) {
 fprintf(stderr, "error decoding query bundle: %d\n", ret);
 return ret;
 }
 dtn_endpoint_id_t reply_eid;
 char local_eid_name[PATH_MAX];
 char reply_eid_name[PATH_MAX];
 char matching_filename[PATH_MAX];
 int count = 0;                                      //forever
-dtn_timeval_t bundle_expiry = 3600;                 //one hour
 dtn_reg_id_t regid = DTN_REGID_NONE;
 dtn_timeval_t reg_expiry = 30;
 int reg_fail_action = DTN_REG_DEFER;
 char reg_fail_script[PATH_MAX];
 dtn_bundle_priority_t priority = COS_NORMAL;
 parse_options(argc, argv,
 local_eid_name,
 reply_eid_name,
 matching_filename,
 &count,
-&bundle_expiry,
 &regid,
 &reg_expiry,
 &reg_fail_action,
 reg_fail_script,
 &priority,
 receive_bpq(&handle,
 regid,
 &reply_eid,
 matching_filename,
 count,
-bundle_expiry,
 priority,
 delivery_options,
 verbose);
 // UNREACHABLE CODE if count = 0 //////////////////////////////////////////////

changeset 66	e1101c5d54a1
parent 65	333724f2f7cf
child 67	cfe2328ba1c6