00001 /* SVN FILE INFO 00002 * $Revision: 181 $ : Last Committed Revision 00003 * $Date: 2008年07月01日 15:32:24 -0700 (2008年7月01日) $ : Last Committed Date */ 00004 /*[ 00005 * Copyright (c) 2007 Integration Engineering Laboratory 00006 University of California, Davis 00007 * 00008 * Permission to use, copy, and distribute this software and its 00009 * documentation for any purpose with or without fee is hereby granted, 00010 * provided that the above copyright notice appear in all copies and 00011 * that both that copyright notice and this permission notice appear 00012 * in supporting documentation. 00013 * 00014 * Permission to modify the software is granted, but not the right to 00015 * distribute the complete modified source code. Modifications are to 00016 * be distributed as patches to the released version. Permission to 00017 * distribute binaries produced by compiling modified sources is granted, 00018 * provided you 00019 * 1. distribute the corresponding source modifications from the 00020 * released version in the form of a patch file along with the binaries, 00021 * 2. add special version identification to distinguish your version 00022 * in addition to the base release version number, 00023 * 3. provide your name and address as the primary contact for the 00024 * support of your modified version, and 00025 * 4. retain our contact information in regard to use of the base 00026 * software. 00027 * Permission to distribute the released version of the source code along 00028 * with corresponding source modifications in the form of a patch file is 00029 * granted with same provisions 2 through 4 for binary distributions. 00030 * 00031 * This software is provided "as is" without express or implied warranty 00032 * to the extent permitted by applicable law. 00033 ]*/ 00034 00035 #include <stdio.h> 00036 #include <mxml.h> 00037 #include <time.h> 00038 #include "include/fipa_acl_envelope.h" 00039 #include "include/mc_error.h" 00040 #include "include/mc_platform.h" 00041 00042 /* fipa_acl_envelope_Received */ 00043 fipa_acl_envelope_Received_t* fipa_acl_envelope_Received_New(void) 00044 { 00045 fipa_acl_envelope_Received_t* received; 00046 received = (fipa_acl_envelope_Received_t*)malloc( 00047 sizeof(fipa_acl_envelope_Received_t) ); 00048 memset(received, 0, sizeof(fipa_acl_envelope_Received_t)); 00049 return received; 00050 } 00051 00052 int fipa_acl_envelope_Received_Destroy(fipa_acl_envelope_Received_t* received) 00053 { 00054 if (received == NULL) return 0; 00055 fipa_url_Destroy(received->received_by); 00056 fipa_url_Destroy(received->received_from); 00057 fipa_DateTime_Destroy(received->received_date); 00058 if (received->received_id != NULL) free(received->received_id); 00059 fipa_url_Destroy(received->received_via); 00060 free(received); 00061 return 0; 00062 } 00063 00064 fipa_acl_envelope_Received_t* fipa_acl_envelope_Received_Copy( 00065 fipa_acl_envelope_Received_t* received) 00066 { 00067 fipa_acl_envelope_Received_t* copy; 00068 if (received == NULL) return NULL; 00069 copy = fipa_acl_envelope_Received_New(); 00070 copy->received_by = fipa_url_Copy(received->received_by); 00071 copy->received_from = fipa_url_Copy(received->received_from); 00072 copy->received_date = fipa_DateTime_Copy(received->received_date); 00073 copy->received_id = strdup(received->received_id); 00074 copy->received_via = fipa_url_Copy(received->received_via); 00075 00076 return copy; 00077 } 00078 00079 /* fipa_acl_Param */ 00080 fipa_acl_Param_t* fipa_acl_Param_New(void) 00081 { 00082 fipa_acl_Param_t* param; 00083 param = (fipa_acl_Param_t*)malloc(sizeof(fipa_acl_Param_t)); 00084 memset(param, 0, sizeof(fipa_acl_Param_t)); 00085 return param; 00086 } 00087 00088 int fipa_acl_Param_Destroy(fipa_acl_Param_t* param) 00089 { 00090 if (param == NULL) return 0; 00091 fipa_agent_identifier_set_Destroy(param->to); 00092 fipa_agent_identifier_Destroy(param->from); 00093 if (param->comments != NULL) free(param->comments); 00094 if (param->acl_representation != NULL) free(param->acl_representation); 00095 if (param->payload_length != NULL) free(param->payload_length); 00096 if (param->payload_encoding != NULL) free (param->payload_encoding); 00097 fipa_DateTime_Destroy(param->date); 00098 fipa_agent_identifier_set_Destroy(param->intended_receiver); 00099 fipa_acl_envelope_Received_Destroy(param->received); 00100 00101 free(param); 00102 return 0; 00103 } 00104 00105 fipa_acl_Param_t* fipa_acl_Param_Copy(fipa_acl_Param_t* param) 00106 { 00107 fipa_acl_Param_t* copy; 00108 if (param == NULL) return NULL; 00109 copy = fipa_acl_Param_New(); 00110 copy->to = fipa_agent_identifier_set_Copy(param->to); 00111 copy->from = fipa_agent_identifier_Copy(param->from); 00112 copy->comments = strdup(param->comments); 00113 copy->acl_representation = strdup(param->acl_representation); 00114 copy->payload_length = strdup(param->payload_length); 00115 copy->payload_encoding = strdup(param->payload_encoding); 00116 copy->date = fipa_DateTime_Copy(param->date); 00117 copy->intended_receiver = fipa_agent_identifier_set_Copy(param->intended_receiver); 00118 copy->received = fipa_acl_envelope_Received_Copy(param->received); 00119 00120 return copy; 00121 } 00122 00123 /* fipa_acl_envelope */ 00124 fipa_acl_envelope_t* fipa_acl_envelope_New(void) 00125 { 00126 fipa_acl_envelope_t* envelope; 00127 envelope = (fipa_acl_envelope_t*)malloc(sizeof(fipa_acl_envelope_t)); 00128 memset(envelope, 0, sizeof(fipa_acl_envelope_t)); 00129 return envelope; 00130 } 00131 00132 int fipa_acl_envelope_Destroy(fipa_acl_envelope_t* envelope) 00133 { 00134 int i; 00135 if (envelope == NULL) return 0; 00136 if (envelope->params == NULL) return 0; 00137 for(i = 0; i < envelope->num_params; i++) { 00138 fipa_acl_Param_Destroy(envelope->params[i]); 00139 } 00140 free(envelope->params); 00141 free(envelope); 00142 return 0; 00143 } 00144 00145 fipa_acl_envelope_t* fipa_acl_envelope_Copy(fipa_acl_envelope_t* envelope) 00146 { 00147 int i; 00148 fipa_acl_envelope_t* copy; 00149 if (envelope == NULL) return NULL; 00150 copy = fipa_acl_envelope_New(); 00151 copy->num_params = envelope->num_params; 00152 copy->params = (fipa_acl_Param_t**)malloc(sizeof(fipa_acl_Param_t*)*copy->num_params); 00153 for (i = 0; i < copy->num_params; i++) { 00154 copy->params[i] = fipa_acl_Param_Copy(envelope->params[i]); 00155 } 00156 return copy; 00157 } 00158 00159 /* Parsing Functions */ 00160 int fipa_envelope_Parse( 00161 struct fipa_acl_envelope_s* envelope, 00162 const char* message) 00163 { 00164 /* Call mxml to parse the message */ 00165 int retval; 00166 mxml_node_t* root_node; 00167 root_node = mxmlLoadString(NULL, message, MXML_NO_CALLBACK); 00168 retval = fipa_envelope_HandleEnvelope(envelope, root_node); 00169 mxmlDelete(root_node); 00170 return retval; 00171 } 00172 00173 int fipa_envelope_HandleEnvelope( 00174 struct fipa_acl_envelope_s* envelope, 00175 mxml_node_t* node) 00176 { 00177 /* Find the 'envelope' element */ 00178 mxml_node_t *envelope_node; 00179 envelope_node = mxmlFindElement( 00180 node, 00181 node, 00182 "envelope", 00183 NULL, 00184 NULL, 00185 MXML_DESCEND_FIRST 00186 ); 00187 if (envelope_node == NULL) { 00188 return MC_ERR_PARSE; 00189 } 00190 return fipa_envelope_HandleParams(envelope, envelope_node); 00191 } 00192 00193 int fipa_envelope_HandleParams( 00194 struct fipa_acl_envelope_s* envelope, 00195 mxml_node_t* node) 00196 { 00197 mxml_node_t* param; 00198 int i; 00199 char buf[10]; 00200 00201 /* Lets figure out how hany params there are */ 00202 for (i = 1; ; i++) { 00203 sprintf(buf, "%d", i); 00204 param = mxmlFindElement( 00205 node, 00206 node, 00207 "params", 00208 "index", 00209 buf, 00210 MXML_DESCEND_FIRST); 00211 if (param == NULL) { break; } 00212 } 00213 i--; 00214 if (i == 0) { 00215 /* There should be at least 1 param */ 00216 return MC_ERR_PARSE; 00217 } 00218 envelope->num_params = i; 00219 envelope->params = (struct fipa_acl_Param_s**)malloc( 00220 sizeof(struct fipa_acl_Param_s*) * i); 00221 memset(envelope->params, 0, i*sizeof(struct fipa_acl_Param_s*) ); 00222 00223 for (i = 1; i <= envelope->num_params; i++) { 00224 sprintf(buf, "%d", i); 00225 param = mxmlFindElement( 00226 node, 00227 node, 00228 "params", 00229 "index", 00230 buf, 00231 MXML_DESCEND_FIRST); 00232 fipa_envelope_HandleTo(envelope, param, i-1); 00233 fipa_envelope_HandleFrom(envelope, param, i-1); 00234 fipa_envelope_HandleComments(envelope, param, i-1); 00235 fipa_envelope_HandleAclRepresentation(envelope, param, i-1); 00236 fipa_envelope_HandlePayloadLength(envelope, param, i-1); 00237 fipa_envelope_HandlePayloadEncoding(envelope, param, i-1); 00238 fipa_envelope_HandleDate(envelope, param, i-1); 00239 fipa_envelope_HandleIntendedReceiver(envelope, param, i-1); 00240 fipa_envelope_HandleReceived(envelope, param, i-1); 00241 } 00242 return 0; 00243 } 00244 00245 int fipa_envelope_HandleTo( 00246 struct fipa_acl_envelope_s* envelope, 00247 mxml_node_t* param_node, 00248 int cur_param) 00249 { 00250 int i; 00251 mxml_node_t* to_node; 00252 mxml_node_t* aid_node; 00253 00254 to_node = mxmlFindElement( 00255 param_node, 00256 param_node, 00257 "to", 00258 NULL, NULL, 00259 MXML_DESCEND_FIRST ); 00260 if (to_node == NULL) return MC_ERR_PARSE; 00261 00262 /* There are a bunch of agent identifiers that must be parsed inside the 00263 * 'to' node. Let us first count the number */ 00264 aid_node = mxmlFindElement( 00265 to_node, 00266 to_node, 00267 "agent-identifier", 00268 NULL, NULL, 00269 MXML_DESCEND_FIRST ); 00270 if (aid_node == NULL) return MC_ERR_PARSE; 00271 00272 for( 00273 i = 1; 00274 (aid_node = mxmlFindElement( 00275 aid_node, 00276 to_node, 00277 "agent-identifier", 00278 NULL,NULL, 00279 MXML_NO_DESCEND )) != NULL; 00280 i++ 00281 ); 00282 00283 envelope->params[cur_param] = fipa_acl_Param_New(); 00284 envelope->params[cur_param]->to = fipa_agent_identifier_set_New(); 00285 envelope->params[cur_param]->to->num = i; 00286 envelope->params[cur_param]->to->retain_order = 0; 00287 envelope->params[cur_param]->to->fipa_agent_identifiers = 00288 (struct fipa_agent_identifier_s**) malloc( 00289 sizeof(struct fipa_agent_identifier_s*) * 00290 envelope->params[cur_param]->to->num ); 00291 00292 /* Now we parse each one */ 00293 aid_node = mxmlFindElement( 00294 to_node, 00295 to_node, 00296 "agent-identifier", 00297 NULL, NULL, 00298 MXML_DESCEND_FIRST ); 00299 if (aid_node == NULL) return MC_ERR_PARSE; 00300 00301 fipa_envelope_ParseAgentIdentifier( 00302 &(envelope->params[cur_param]->to->fipa_agent_identifiers[0]), 00303 aid_node ); 00304 00305 for( 00306 i = 1; 00307 aid_node = mxmlFindElement( 00308 aid_node, 00309 to_node, 00310 "agent-identifier", 00311 NULL,NULL, 00312 MXML_NO_DESCEND ); 00313 i++ 00314 ) 00315 { 00316 fipa_envelope_ParseAgentIdentifier( 00317 &(envelope->params[cur_param]->to->fipa_agent_identifiers[i]), 00318 aid_node ); 00319 } 00320 return 0; 00321 } 00322 00323 int fipa_envelope_HandleFrom( 00324 struct fipa_acl_envelope_s* envelope, 00325 mxml_node_t* param_node, 00326 int cur_param) 00327 { 00328 mxml_node_t* from_node; 00329 mxml_node_t* aid_node; 00330 00331 from_node = mxmlFindElement( 00332 param_node, 00333 param_node, 00334 "from", 00335 NULL, NULL, 00336 MXML_DESCEND_FIRST); 00337 if (from_node == NULL) return 0; 00338 00339 aid_node = mxmlFindElement( 00340 from_node, 00341 from_node, 00342 "agent-identifier", 00343 NULL, NULL, 00344 MXML_DESCEND_FIRST); 00345 if (aid_node == NULL) return MC_ERR_PARSE; 00346 00347 return fipa_envelope_ParseAgentIdentifier( 00348 &envelope->params[cur_param]->from, 00349 aid_node); 00350 } 00351 00352 int fipa_envelope_HandleComments( 00353 struct fipa_acl_envelope_s* envelope, 00354 mxml_node_t* param_node, 00355 int cur_param) 00356 { 00357 mxml_node_t* comments_node; 00358 /* find the comments node, if there is one */ 00359 comments_node = mxmlFindElement( 00360 param_node, 00361 param_node, 00362 "comments", 00363 NULL, NULL, 00364 MXML_DESCEND_FIRST); 00365 if (comments_node == NULL) return 0; 00366 00367 /* The comments node exists. Lets get it's contents */ 00368 if (comments_node->child->type != MXML_TEXT) return MC_ERR_PARSE; 00369 envelope->params[cur_param]->comments = (char*)malloc( 00370 sizeof(char) * (strlen(comments_node->child->value.text.string)+1)); 00371 strcpy(envelope->params[cur_param]->comments, 00372 comments_node->child->value.text.string); 00373 return 0; 00374 } 00375 00376 int fipa_envelope_HandleAclRepresentation( 00377 struct fipa_acl_envelope_s* envelope, 00378 mxml_node_t* param_node, 00379 int cur_param) 00380 { 00381 mxml_node_t* acl_representation_node; 00382 /* find the comments node, if there is one */ 00383 acl_representation_node = mxmlFindElement( 00384 param_node, 00385 param_node, 00386 "acl-representation", 00387 NULL, NULL, 00388 MXML_DESCEND_FIRST); 00389 if (acl_representation_node == NULL) return 0; 00390 00391 /* The comments node exists. Lets get it's contents */ 00392 if (acl_representation_node->child->type != MXML_TEXT) return MC_ERR_PARSE; 00393 envelope->params[cur_param]->acl_representation = (char*)malloc( 00394 sizeof(char) * (strlen(acl_representation_node->child->value.text.string)+1)); 00395 strcpy(envelope->params[cur_param]->acl_representation, 00396 acl_representation_node->child->value.text.string); 00397 return 0; 00398 } 00399 00400 int fipa_envelope_HandlePayloadLength( 00401 struct fipa_acl_envelope_s* envelope, 00402 mxml_node_t* param_node, 00403 int cur_param) 00404 { 00405 mxml_node_t* payload_length_node; 00406 00407 payload_length_node = mxmlFindElement( 00408 param_node, 00409 param_node, 00410 "payload-length", 00411 NULL, NULL, 00412 MXML_DESCEND_FIRST); 00413 if (payload_length_node == NULL) return 0; 00414 00415 if (payload_length_node->child->type != MXML_TEXT) return MC_ERR_PARSE; 00416 envelope->params[cur_param]->payload_length = (char*)malloc( 00417 sizeof(char) * (strlen(payload_length_node->child->value.text.string)+1) ); 00418 strcpy( envelope->params[cur_param]->payload_length, 00419 payload_length_node->child->value.text.string ); 00420 return 0; 00421 } 00422 00423 int fipa_envelope_HandlePayloadEncoding( 00424 struct fipa_acl_envelope_s* envelope, 00425 mxml_node_t* param_node, 00426 int cur_param) 00427 { 00428 mxml_node_t* payload_encoding_node; 00429 00430 payload_encoding_node = mxmlFindElement( 00431 param_node, 00432 param_node, 00433 "payload-encoding", 00434 NULL, NULL, 00435 MXML_DESCEND_FIRST); 00436 if (payload_encoding_node == NULL) return 0; 00437 00438 if (payload_encoding_node->child->type != MXML_TEXT) return MC_ERR_PARSE; 00439 00440 envelope->params[cur_param]->payload_encoding = (char*)malloc( 00441 sizeof(char) * (strlen(payload_encoding_node->child->value.text.string)+1) ); 00442 strcpy( envelope->params[cur_param]->payload_encoding, 00443 payload_encoding_node->child->value.text.string ); 00444 return 0; 00445 } 00446 00447 int fipa_envelope_HandleDate( 00448 struct fipa_acl_envelope_s* envelope, 00449 mxml_node_t* param_node, 00450 int cur_param) 00451 { 00452 char date_string[25]; 00453 mxml_node_t* date_node; 00454 fipa_message_string_t message_string; 00455 00456 date_node = mxmlFindElement( 00457 param_node, 00458 param_node, 00459 "date", 00460 NULL, NULL, 00461 MXML_DESCEND_FIRST); 00462 if (date_node == NULL) return 0; 00463 00464 if (date_node->child->type != MXML_TEXT) return MC_ERR_PARSE; 00465 if ( strlen(date_node->child->value.text.string) > 22) return MC_ERR_PARSE; 00466 00467 strcpy(date_string, date_node->child->value.text.string); 00468 00469 message_string.message = date_string; 00470 message_string.parse = date_string; 00471 00472 return fipa_datetime_Parse( 00473 &(envelope->params[cur_param]->date), 00474 &message_string); 00475 } 00476 00477 int fipa_envelope_HandleIntendedReceiver( 00478 struct fipa_acl_envelope_s* envelope, 00479 mxml_node_t* param_node, 00480 int cur_param) 00481 { 00482 int i; 00483 mxml_node_t* intended_receiver_node; 00484 mxml_node_t* aid_node; 00485 00486 intended_receiver_node = mxmlFindElement( 00487 param_node, 00488 param_node, 00489 "intended_receiver", 00490 NULL, NULL, 00491 MXML_DESCEND_FIRST); 00492 if (intended_receiver_node == NULL) { 00493 envelope->params[cur_param]->intended_receiver = NULL; 00494 return 0; 00495 } 00496 envelope->params[cur_param]->intended_receiver = fipa_agent_identifier_set_New(); 00497 00498 /* Count the number of agent id's in the node */ 00499 aid_node = mxmlFindElement( 00500 intended_receiver_node, 00501 intended_receiver_node, 00502 "agent-identifier", 00503 NULL, NULL, 00504 MXML_DESCEND_FIRST); 00505 if (aid_node == NULL) return MC_ERR_PARSE; 00506 for( 00507 i = 1; 00508 aid_node = mxmlFindElement( 00509 aid_node, 00510 intended_receiver_node, 00511 "agent-identifier", 00512 NULL,NULL, 00513 MXML_NO_DESCEND) ; 00514 i++ 00515 ); 00516 /* Allocate space in envelope */ 00517 envelope->params[cur_param]->intended_receiver->num = i; 00518 envelope->params[cur_param]->intended_receiver->fipa_agent_identifiers = 00519 (struct fipa_agent_identifier_s**)malloc( 00520 sizeof(struct fipa_agent_identifier_s*) * i); 00521 envelope->params[cur_param]->intended_receiver->retain_order = 0; 00522 00523 /* Parse each one */ 00524 aid_node = mxmlFindElement( 00525 intended_receiver_node, 00526 intended_receiver_node, 00527 "agent-identifier", 00528 NULL, NULL, 00529 MXML_DESCEND_FIRST); 00530 if (aid_node == NULL) return MC_ERR_PARSE; 00531 fipa_envelope_ParseAgentIdentifier( 00532 &(envelope->params[cur_param]->intended_receiver-> 00533 fipa_agent_identifiers[0]), 00534 aid_node ); 00535 00536 for( 00537 i = 1; 00538 aid_node = mxmlFindElement( 00539 aid_node, 00540 intended_receiver_node, 00541 "agent-identifier", 00542 NULL,NULL, 00543 MXML_NO_DESCEND) ; 00544 i++ 00545 ) 00546 { 00547 fipa_envelope_ParseAgentIdentifier( 00548 &(envelope->params[cur_param]->intended_receiver-> 00549 fipa_agent_identifiers[i]), 00550 aid_node ); 00551 } 00552 return 0; 00553 } 00554 00555 int fipa_envelope_HandleReceived( 00556 struct fipa_acl_envelope_s* envelope, 00557 mxml_node_t* param_node, 00558 int cur_param) 00559 { 00560 int err; 00561 mxml_node_t* received_node; 00562 00563 mxml_node_t* node; 00564 const char* attr; 00565 00566 fipa_message_string_t message_string; 00567 00568 char date_string[25]; 00569 00570 received_node = mxmlFindElement( 00571 param_node, 00572 param_node, 00573 "received", 00574 NULL, NULL, 00575 MXML_DESCEND_FIRST); 00576 00577 if (received_node == NULL) return 0; 00578 envelope->params[cur_param]->received = fipa_acl_envelope_Received_New(); 00579 /* Need to parse the following nodes: 00580 * received-by 00581 * received-date 00582 * o received-from 00583 * o received-id 00584 * o received-via */ 00585 00586 /* received-by */ 00587 node = mxmlFindElement( 00588 received_node, 00589 received_node, 00590 "received-by", 00591 NULL, NULL, 00592 MXML_DESCEND_FIRST); 00593 if (node == NULL) return MC_ERR_PARSE; 00594 attr = mxmlElementGetAttr(node, "value"); 00595 envelope->params[cur_param]->received->received_by = fipa_url_New(); 00596 envelope->params[cur_param]->received->received_by->str = 00597 (char*)malloc(sizeof(char) * (strlen(attr)+1)); 00598 strcpy(envelope->params[cur_param]->received->received_by->str, 00599 attr); 00600 00601 /* received-date */ 00602 node = mxmlFindElement( 00603 received_node, 00604 received_node, 00605 "received-date", 00606 NULL, NULL, 00607 MXML_DESCEND_FIRST); 00608 if (node == NULL) return MC_ERR_PARSE; 00609 attr = mxmlElementGetAttr(node, "value"); 00610 if (attr == NULL) return MC_ERR_PARSE; 00611 if ( strlen(attr) > 22 ) return MC_ERR_PARSE; 00612 strcpy(date_string, attr); 00613 message_string.message = date_string; 00614 message_string.parse = date_string; 00615 00616 err = fipa_datetime_Parse( 00617 &(envelope->params[cur_param]->received->received_date), 00618 &message_string); 00619 if (err) return err; 00620 00621 /* received-from */ 00622 node = mxmlFindElement( 00623 received_node, 00624 received_node, 00625 "received-from", 00626 NULL, NULL, 00627 MXML_DESCEND_FIRST); 00628 if(node == NULL) { 00629 envelope->params[cur_param]->received->received_from = NULL; 00630 } else { 00631 attr = mxmlElementGetAttr(node, "value"); 00632 if (attr == NULL) return MC_ERR_PARSE; 00633 envelope->params[cur_param]->received->received_from = 00634 (struct fipa_url_s*)malloc(sizeof(struct fipa_url_s)); 00635 envelope->params[cur_param]->received->received_from->str = 00636 (char*)malloc(sizeof(char)*(strlen(attr)+1)); 00637 strcpy( 00638 envelope->params[cur_param]->received->received_from->str, 00639 attr ); 00640 } 00641 00642 /* received-id */ 00643 node = mxmlFindElement( 00644 received_node, 00645 received_node, 00646 "received-id", 00647 NULL, NULL, 00648 MXML_DESCEND_FIRST); 00649 if(node == NULL) { 00650 envelope->params[cur_param]->received->received_id = NULL; 00651 } else { 00652 attr = mxmlElementGetAttr(node, "value"); 00653 if (attr == NULL) return MC_ERR_PARSE; 00654 envelope->params[cur_param]->received->received_id = 00655 (char*)malloc(sizeof(char) * (strlen(attr)+1)); 00656 strcpy(envelope->params[cur_param]->received->received_id, 00657 attr); 00658 } 00659 00660 /* received-via */ 00661 node = mxmlFindElement( 00662 received_node, 00663 received_node, 00664 "received-via", 00665 NULL, NULL, 00666 MXML_DESCEND_FIRST); 00667 if(node == NULL) { 00668 envelope->params[cur_param]->received->received_via = NULL; 00669 } else { 00670 attr = mxmlElementGetAttr(node, "value"); 00671 if (attr == NULL) return MC_ERR_PARSE; 00672 envelope->params[cur_param]->received->received_via = 00673 (struct fipa_url_s*)malloc(sizeof(struct fipa_url_s)); 00674 envelope->params[cur_param]->received->received_via->str = 00675 (char*)malloc(sizeof(char) * (strlen(attr)+1)); 00676 strcpy(envelope->params[cur_param]->received->received_via->str, 00677 attr); 00678 } 00679 return 0; 00680 } 00681 00682 int fipa_envelope_ParseAgentIdentifier( 00683 struct fipa_agent_identifier_s** aid, 00684 mxml_node_t* agent_identifier_node 00685 ) 00686 { 00687 int err; 00688 mxml_node_t* name_node; 00689 mxml_node_t* addresses_node; 00690 mxml_node_t* resolvers_node; 00691 00692 name_node = mxmlFindElement( 00693 agent_identifier_node, 00694 agent_identifier_node, 00695 "name", 00696 NULL, NULL, 00697 MXML_DESCEND_FIRST); 00698 /* The child of 'name' better be some text! */ 00699 if(name_node->child->type != MXML_TEXT) { 00700 return MC_ERR_PARSE; 00701 } else { 00702 *aid = fipa_agent_identifier_New(); 00703 (*aid)->name = (char*)malloc(sizeof(char) * 00704 (strlen(name_node->child->value.text.string)+1) ); 00705 strcpy((*aid)->name, 00706 name_node->child->value.text.string ); 00707 } 00708 00709 addresses_node = mxmlFindElement( 00710 agent_identifier_node, 00711 agent_identifier_node, 00712 "addresses", 00713 NULL, NULL, 00714 MXML_DESCEND_FIRST); 00715 if (addresses_node != NULL) { 00716 err = fipa_envelope_ParseAddresses(*aid, addresses_node); 00717 } 00718 if (err) return err; 00719 resolvers_node = mxmlFindElement( 00720 agent_identifier_node, 00721 agent_identifier_node, 00722 "resolvers", 00723 NULL, NULL, 00724 MXML_DESCEND_FIRST); 00725 if (resolvers_node != NULL) { 00726 err = fipa_envelope_ParseResolvers(*aid, resolvers_node); 00727 } 00728 if (err) return err; 00729 return 0; 00730 } 00731 00732 int fipa_envelope_ParseAddresses( 00733 struct fipa_agent_identifier_s* aid, 00734 mxml_node_t* addresses_node) 00735 { 00736 int i; 00737 mxml_node_t* url_node; 00738 /* Here we expect any number of 'url' elements. 00739 * Let us count the number */ 00740 url_node = mxmlFindElement( 00741 addresses_node, 00742 addresses_node, 00743 "url", 00744 NULL, NULL, 00745 MXML_DESCEND_FIRST); 00746 if (url_node == NULL) { 00747 return MC_ERR_PARSE; 00748 } 00749 for ( 00750 i = 1; 00751 url_node = mxmlFindElement( 00752 url_node, 00753 addresses_node, 00754 "url", 00755 NULL, NULL, 00756 MXML_NO_DESCEND) ; 00757 i++ 00758 ); 00759 aid->addresses = (fipa_url_sequence_t*)malloc(sizeof(fipa_url_sequence_t)); 00760 aid->addresses->num = i; 00761 aid->addresses->urls = (struct fipa_url_s**)malloc( 00762 sizeof(struct fipa_url_s*) * aid->addresses->num ); 00763 /* Now we must copy each one */ 00764 url_node = mxmlFindElement( 00765 addresses_node, 00766 addresses_node, 00767 "url", 00768 NULL, NULL, 00769 MXML_DESCEND_FIRST); 00770 if (url_node->child->type != MXML_TEXT) { 00771 return MC_ERR_PARSE; 00772 } 00773 aid->addresses->urls[0] = fipa_url_New(); 00774 aid->addresses->urls[0]->str = (char*)malloc( 00775 sizeof(char) * (strlen(url_node->child->value.text.string)+1)); 00776 strcpy(aid->addresses->urls[0]->str, url_node->child->value.text.string); 00777 for ( 00778 i = 1; 00779 url_node = mxmlFindElement( 00780 url_node, 00781 addresses_node, 00782 "url", 00783 NULL, NULL, 00784 MXML_NO_DESCEND) ; 00785 i++ 00786 ) 00787 { 00788 if (url_node->child->type != MXML_TEXT) { 00789 return MC_ERR_PARSE; 00790 } 00791 aid->addresses->urls[i] = fipa_url_New(); 00792 aid->addresses->urls[i]->str = (char*)malloc( 00793 sizeof(char) * (strlen(url_node->child->value.text.string)+1)); 00794 strcpy(aid->addresses->urls[i]->str, url_node->child->value.text.string); 00795 } 00796 return 0; 00797 } 00798 00799 int fipa_envelope_ParseResolvers( 00800 struct fipa_agent_identifier_s* aid, 00801 mxml_node_t* resolvers_node) 00802 { 00803 int i; 00804 mxml_node_t* agent_id_node; 00805 /* Here we must parse a set of agent identifiers. */ 00806 00807 /* First, find out how many resolvers there are */ 00808 agent_id_node = mxmlFindElement( 00809 resolvers_node, 00810 resolvers_node, 00811 "agent-identifier", 00812 NULL, NULL, 00813 MXML_DESCEND_FIRST); 00814 if (agent_id_node == NULL) { 00815 return MC_ERR_PARSE; 00816 } 00817 for( 00818 i = 1; 00819 agent_id_node = mxmlFindElement( 00820 agent_id_node, 00821 resolvers_node, 00822 "agent-identifier", 00823 NULL, NULL, 00824 MXML_NO_DESCEND); 00825 i++); 00826 00827 /* Now we allocate space and parse */ 00828 aid->resolvers = (fipa_agent_identifier_set_t*)malloc(sizeof(fipa_agent_identifier_set_t)); 00829 aid->resolvers->num = i; 00830 aid->resolvers->retain_order = 0; 00831 aid->resolvers->fipa_agent_identifiers = (struct fipa_agent_identifier_s**)malloc( 00832 sizeof(struct fipa_agent_identifier_s*) * aid->resolvers->num); 00833 agent_id_node = mxmlFindElement( 00834 resolvers_node, 00835 resolvers_node, 00836 "agent-identifier", 00837 NULL, NULL, 00838 MXML_DESCEND_FIRST); 00839 if (agent_id_node == NULL) { 00840 return MC_ERR_PARSE; 00841 } 00842 fipa_envelope_ParseAgentIdentifier( 00843 &(aid->resolvers->fipa_agent_identifiers[0]), agent_id_node); 00844 for( 00845 i = 1; 00846 agent_id_node = mxmlFindElement( 00847 agent_id_node, 00848 resolvers_node, 00849 "agent-identifier", 00850 NULL, NULL, 00851 MXML_NO_DESCEND); 00852 i++ 00853 ) 00854 { 00855 fipa_envelope_ParseAgentIdentifier( 00856 &(aid->resolvers->fipa_agent_identifiers[i]), agent_id_node); 00857 } 00858 return 0; 00859 } 00860 00861 /* 00862 * Composing Functions 00863 * */ 00864 char* fipa_envelope_Compose(fipa_acl_message_t* fipa_acl) 00865 { 00866 char* retval; 00867 mxml_node_t* node; 00868 node = mxmlLoadString 00869 ( 00870 NULL, 00871 "<?xml version=\"1.0\"?>", 00872 MXML_NO_CALLBACK 00873 ); 00874 mxmlAdd 00875 ( 00876 node, 00877 MXML_ADD_AFTER, 00878 MXML_ADD_TO_PARENT, 00879 fipa_envelope_Compose__envelope(fipa_acl) 00880 ); 00881 retval = mxmlSaveAllocString( 00882 node, 00883 MXML_NO_CALLBACK); 00884 mxmlDelete(node); 00885 return retval; 00886 } 00887 00888 mxml_node_t* 00889 fipa_envelope_Compose__envelope(fipa_acl_message_t* fipa_acl) 00890 { 00891 mxml_node_t* node; 00892 00893 node = mxmlNewElement( 00894 NULL, 00895 "envelope" 00896 ); 00897 /* FIXME: Only create 1 param for now. What's with multiple params? */ 00898 mxmlAdd 00899 ( 00900 node, 00901 MXML_ADD_AFTER, 00902 MXML_ADD_TO_PARENT, 00903 fipa_envelope_Compose__params(fipa_acl) 00904 ); 00905 return node; 00906 } 00907 00908 mxml_node_t* 00909 fipa_envelope_Compose__params(fipa_acl_message_t* fipa_acl) 00910 { 00911 mxml_node_t* node; 00912 node = mxmlNewElement( 00913 NULL, 00914 "params" 00915 ); 00916 mxmlElementSetAttr(node, "index", "1"); 00917 mxmlAdd 00918 ( 00919 node, 00920 MXML_ADD_AFTER, 00921 MXML_ADD_TO_PARENT, 00922 fipa_envelope_Compose__to(fipa_acl) 00923 ); 00924 mxmlAdd 00925 ( 00926 node, 00927 MXML_ADD_AFTER, 00928 MXML_ADD_TO_PARENT, 00929 fipa_envelope_Compose__from(fipa_acl) 00930 ); 00931 mxmlAdd 00932 ( 00933 node, 00934 MXML_ADD_AFTER, 00935 MXML_ADD_TO_PARENT, 00936 fipa_envelope_Compose__acl_representation(fipa_acl) 00937 ); 00938 mxmlAdd 00939 ( 00940 node, 00941 MXML_ADD_AFTER, 00942 MXML_ADD_TO_PARENT, 00943 fipa_envelope_Compose__payload_encoding(fipa_acl) 00944 ); 00945 mxmlAdd 00946 ( 00947 node, 00948 MXML_ADD_AFTER, 00949 MXML_ADD_TO_PARENT, 00950 fipa_envelope_Compose__date(fipa_acl) 00951 ); 00952 mxmlAdd 00953 ( 00954 node, 00955 MXML_ADD_AFTER, 00956 MXML_ADD_TO_PARENT, 00957 fipa_envelope_Compose__intended_receiver(fipa_acl) 00958 ); 00959 /* mxmlAdd 00960 ( 00961 node, 00962 MXML_ADD_AFTER, 00963 MXML_ADD_TO_PARENT, 00964 fipa_envelope_Compose__received(fipa_acl) 00965 ); */ 00966 return node; 00967 } 00968 00969 mxml_node_t* 00970 fipa_envelope_Compose__to(fipa_acl_message_t* fipa_acl) 00971 { 00972 int i; 00973 int j; 00974 mxml_node_t* node; 00975 mxml_node_t* agent_identifier_node; 00976 mxml_node_t* name_node; 00977 mxml_node_t* addresses_node; 00978 mxml_node_t* url_node; 00979 node = mxmlNewElement( 00980 NULL, 00981 "to"); 00982 for(i = 0; i < fipa_acl->receiver->num; i++) { 00983 agent_identifier_node = mxmlNewElement( 00984 node, 00985 "agent-identifier"); 00986 name_node = mxmlNewElement( 00987 agent_identifier_node, 00988 "name"); 00989 mxmlNewText( 00990 name_node, 00991 0, 00992 fipa_acl->receiver->fipa_agent_identifiers[i]->name); 00993 00994 addresses_node = mxmlNewElement( 00995 agent_identifier_node, 00996 "addresses"); 00997 for( 00998 j = 0; 00999 j < fipa_acl->receiver->fipa_agent_identifiers[i]->addresses->num; 01000 j++ 01001 ) 01002 { 01003 url_node = mxmlNewElement( 01004 addresses_node, 01005 "url" ); 01006 mxmlNewText( 01007 url_node, 01008 0, 01009 fipa_acl->receiver->fipa_agent_identifiers[i]->addresses->urls[j]->str ); 01010 } 01011 } 01012 return node; 01013 } 01014 01015 mxml_node_t* 01016 fipa_envelope_Compose__from(fipa_acl_message_t* fipa_acl) 01017 { 01018 int i; 01019 extern mc_platform_p g_mc_platform; 01020 mxml_node_t* from_node; 01021 mxml_node_t* agent_identifier_node; 01022 mxml_node_t* name_node; 01023 mxml_node_t* addresses_node; 01024 mxml_node_t* url_node; 01025 dynstring_t* hostname; 01026 char buf[20]; 01027 01028 from_node = mxmlNewElement( 01029 NULL, 01030 "from" ); 01031 agent_identifier_node = mxmlNewElement( 01032 from_node, 01033 "agent-identifier" ); 01034 name_node = mxmlNewElement( 01035 agent_identifier_node, 01036 "name" ); 01037 mxmlNewText( 01038 name_node, 01039 0, 01040 fipa_acl->sender->name ); 01041 01042 /* Compose Addresses */ 01043 addresses_node = mxmlNewElement( 01044 agent_identifier_node, 01045 "addresses"); 01046 if (fipa_acl->sender->addresses != NULL) { 01047 if (fipa_acl->sender->addresses->num != 0) { 01048 for(i = 0; i < fipa_acl->sender->addresses->num; i++) { 01049 url_node = mxmlNewElement( 01050 addresses_node, 01051 "url" ); 01052 /*mxmlNewText( 01053 url_node, 01054 0, 01055 fipa_acl->sender->addresses->urls[i]->str );*/ 01056 mxmlNewText( 01057 url_node, 01058 0, 01059 "http://localhost:5555/acc"); 01060 } 01061 } 01062 } else { 01063 hostname = dynstring_New(); 01064 url_node = mxmlNewElement( 01065 addresses_node, 01066 "url" ); 01067 dynstring_Append(hostname, "http://"); 01068 dynstring_Append(hostname, g_mc_platform->hostname); 01069 sprintf(buf, ":%d", g_mc_platform->port); 01070 dynstring_Append(hostname, buf); 01071 mxmlNewText( 01072 url_node, 01073 0, 01074 hostname->message ); 01075 dynstring_Destroy(hostname); 01076 } 01077 return from_node; 01078 } 01079 01080 mxml_node_t* 01081 fipa_envelope_Compose__acl_representation(fipa_acl_message_t* fipa_acl) 01082 { 01083 mxml_node_t* node; 01084 node = mxmlNewElement( 01085 NULL, 01086 "acl-representation"); 01087 mxmlNewText( 01088 node, 01089 0, 01090 "fipa.acl.rep.string.std"); 01091 return node; 01092 } 01093 01094 mxml_node_t* 01095 fipa_envelope_Compose__payload_encoding(fipa_acl_message_t* fipa_acl) 01096 { 01097 mxml_node_t* node; 01098 node = mxmlNewElement( 01099 NULL, 01100 "payload-encoding"); 01101 mxmlNewText( 01102 node, 01103 0, 01104 "US-ASCII" ); 01105 return node; 01106 } 01107 01108 mxml_node_t* 01109 fipa_envelope_Compose__date(fipa_acl_message_t* fipa_acl) 01110 { 01111 time_t t; 01112 struct tm* mytm; 01113 char buf[30]; 01114 mxml_node_t* node; 01115 t = time(NULL); 01116 mytm = localtime(&t); 01117 if (mytm == NULL) { 01118 fprintf(stderr, "time failure. %s:%d\n", __FILE__, __LINE__); 01119 return NULL; 01120 } 01121 if (strftime(buf, sizeof(buf), "%Y%m%dT%H%M%S000", mytm) == 0) { 01122 fprintf(stderr, "strftime failure. %s:%d\n", __FILE__, __LINE__); 01123 return NULL; 01124 } 01125 01126 node = mxmlNewElement( 01127 NULL, 01128 "date" ); 01129 mxmlNewText( 01130 node, 01131 0, 01132 buf ); 01133 01134 return node; 01135 } 01136 01137 mxml_node_t* 01138 fipa_envelope_Compose__intended_receiver(fipa_acl_message_t* fipa_acl) 01139 { 01140 int i; 01141 int j; 01142 mxml_node_t* node; 01143 mxml_node_t* agent_identifier_node; 01144 mxml_node_t* name_node; 01145 mxml_node_t* addresses_node; 01146 mxml_node_t* url_node; 01147 node = mxmlNewElement( 01148 NULL, 01149 "intended-receiver"); 01150 i = 0; 01151 agent_identifier_node = mxmlNewElement( 01152 node, 01153 "agent-identifier"); 01154 name_node = mxmlNewElement( 01155 agent_identifier_node, 01156 "name"); 01157 mxmlNewText( 01158 name_node, 01159 0, 01160 fipa_acl->receiver->fipa_agent_identifiers[i]->name); 01161 01162 addresses_node = mxmlNewElement( 01163 agent_identifier_node, 01164 "addresses"); 01165 for( 01166 j = 0; 01167 j < fipa_acl->receiver->fipa_agent_identifiers[i]->addresses->num; 01168 j++ 01169 ) 01170 { 01171 url_node = mxmlNewElement( 01172 addresses_node, 01173 "url" ); 01174 mxmlNewText( 01175 url_node, 01176 0, 01177 fipa_acl->receiver->fipa_agent_identifiers[i]->addresses->urls[j]->str ); 01178 } 01179 return node; 01180 }