Mobile-C: /home/dko/Projects/mobilec/trunk/src/libmc.c Source File

00001 /* SVN FILE INFO
00002  * $Revision: 316 $ : Last Committed Revision
00003  * $Date: 2009-04-29 16:40:54 -0700 (Wed, 29 Apr 2009) $ : 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 #ifndef _WIN32
00035 #include "config.h"
00036 #else
00037 #include "winconfig.h"
00038 #endif
00039 
00040 #ifndef _WIN32
00041 #include <unistd.h>
00042 #include <pthread.h>
00043 #else
00044 #include <windows.h>
00045 #include <memory.h>
00046 #endif
00047 #include <embedch.h>
00048 
00049 #include <sys/types.h>
00050 #include <sys/stat.h>
00051 #ifndef _WIN32
00052 #include <sys/time.h>
00053 #else
00054 #include <time.h>
00055 #endif
00056 
00057 #include "include/libmc.h"
00058 #include "include/macros.h"
00059 #include "include/mc_platform.h"
00060 #include "include/message.h"
00061 #include "include/data_structures.h"
00062 #include "include/fipa_acl_envelope.h"
00063 #include "include/fipa_acl.h"
00064 #include "include/agent.h"
00065 #include "include/agent_task.h"
00066 #ifndef HOST_NAME_MAX
00067 #define HOST_NAME_MAX 255
00068 #endif
00069 
00070 /* The Global platform variable */
00071 mc_platform_p g_mc_platform;
00072 
00073 /* **************************** *
00074  * Libmc Binary Space Functions *
00075  * **************************** */
00076 
00077 int 
00078 MC_AclDestroy(struct fipa_acl_message_s* message)
00079 {
00080   return fipa_acl_message_Destroy(message);
00081 }
00082 
00083 EXPORTMC fipa_acl_message_t* 
00084 MC_AclNew(void) {
00085   return fipa_acl_message_New();
00086 }
00087 
00088 EXPORTMC int 
00089 MC_AclPost(MCAgent_t agent, struct fipa_acl_message_s* message)
00090 {
00091   return agent_mailbox_Post(agent->mailbox, message);
00092 }
00093 
00094 EXPORTMC fipa_acl_message_t*
00095 MC_AclReply(fipa_acl_message_t* acl_message)
00096 {
00097   return fipa_Reply(acl_message);
00098 }
00099 
00100 EXPORTMC fipa_acl_message_t*
00101 MC_AclRetrieve(MCAgent_t agent)
00102 {
00103   return agent_mailbox_Retrieve(agent->mailbox);
00104 }
00105 
00106 EXPORTMC int
00107 MC_AclSend(MCAgency_t attr, fipa_acl_message_t* acl)
00108 {
00109   /* FIXME: We may want to multithread this later for asynchronous
00110    * sending to multiple hosts. But for now, we will use a simple
00111    * loop. */
00112   int i;
00113   int err;
00114   mtp_http_t* msg;
00115   dynstring_t* msg_string;
00116   message_p mc_message;
00117 
00118   char* host;
00119   int port;
00120   char* target;
00121   MCAgent_t agent;
00122   int num_addresses = 0;
00123 
00124   err = fipa_acl_Compose(&msg_string, acl);
00125   if( err ) {
00126     fprintf(stderr, "ACL Message Compose Error. %s:%d\n", __FILE__, __LINE__);
00127     return err;
00128   }
00129   for(i = 0; i < acl->receiver->num; i++) {
00130     /* The receiver may or may not have an address. If it does, send the
00131      * message to that address. If not, assume that the target agent is
00132      * local and try to send to that agent. */
00133     if (acl->receiver->fipa_agent_identifiers[i]->addresses == NULL) {
00134       num_addresses = 0;
00135     } else {
00136       num_addresses = acl->receiver->fipa_agent_identifiers[i]->addresses->num;
00137     }
00138     if (num_addresses == 0) {
00139       agent = MC_FindAgentByName(
00140           attr,
00141           acl->receiver->fipa_agent_identifiers[i]->name );
00142       if (agent == NULL) {
00143         fprintf(stderr, "Could not find local agent:%s. %s:%d\n",
00144             acl->receiver->fipa_agent_identifiers[i]->name,
00145             __FILE__, __LINE__);
00146       }
00147       MC_AclPost(agent, acl);
00148     } else {
00149       msg = mtp_http_New();
00150       /* Send to the first address listed */
00151       err = http_to_hostport(
00152           acl->receiver->fipa_agent_identifiers[i]->addresses->urls[0]->str,
00153           &host,
00154           &port,
00155           &target );
00156       if (err) {
00157         fprintf(stderr, "Invalid address. %s:%d\n", __FILE__, __LINE__);
00158         return err;
00159       }
00160       msg->host = strdup(host);
00161       msg->target = strdup(target);
00162       msg->message_parts = 2;
00163       msg->content = (mtp_http_content_t *)malloc(
00164           sizeof(mtp_http_content_t) * 2);
00165 
00166       /* Set up the message envelope */
00167       msg->content[0].data = (void*)fipa_envelope_Compose(acl);
00168       
00169       msg->content[0].content_type = strdup("application/xml");
00170 
00171       /* Set up the ACL message */
00172       msg->content[1].data = (void*)strdup(msg_string->message);
00173       msg->content[1].content_type = strdup("application/text");
00174 
00175       mc_message = mtp_http_CreateMessage(
00176           msg,
00177           host,
00178           port );
00179       mc_message->message_type = FIPA_ACL;
00180       mc_message->target = strdup("acc");
00181 
00182       message_Send
00183         (
00184                                  attr->mc_platform,
00185          mc_message,
00186                                  attr->mc_platform->private_key
00187         );
00188       message_Destroy(mc_message);
00189       mtp_http_Destroy(msg);
00190       free(host);
00191       free(target);
00192     }
00193   }
00194   dynstring_Destroy(msg_string);
00195   return 0;
00196 }
00197 
00198 EXPORTMC fipa_acl_message_t* 
00199 MC_AclWaitRetrieve(MCAgent_t agent)
00200 {
00201   return agent_mailbox_WaitRetrieve(agent->mailbox);
00202 }
00203 
00204 /* ACL Helper Functions Here */
00205 
00206 int MC_AclSetPerformative(
00207     fipa_acl_message_t* acl,
00208     enum fipa_performative_e performative )
00209 {
00210   acl->performative = performative;
00211   return 0;
00212 }
00213 
00214 int MC_AclSetSender(
00215     fipa_acl_message_t* acl,
00216     const char* name,
00217     const char* address )
00218 {
00219   if(acl->sender != NULL) {
00220     /* There is already a sender. Lets over-write it */
00221     fipa_agent_identifier_Destroy(acl->sender);
00222   }
00223   acl->sender = fipa_agent_identifier_New();
00224   acl->sender->name = strdup(name);
00225   if (address != NULL) {
00226     acl->sender->addresses = fipa_url_sequence_New();
00227     acl->sender->addresses->num = 1;
00228     acl->sender->addresses->urls = (struct fipa_url_s**)malloc(
00229         sizeof(struct fipa_url_s*));
00230     acl->sender->addresses->urls[0] = fipa_url_New();
00231     acl->sender->addresses->urls[0]->str = strdup(address);
00232   }
00233 
00234   return 0;
00235 }
00236   
00237 int MC_AclAddReceiver(
00238     fipa_acl_message_t* acl,
00239     const char* name,
00240     const char* address )
00241 {
00242   int i;
00243   struct fipa_agent_identifier_s** tmp;
00244   if (acl->receiver == NULL) {
00245     acl->receiver = fipa_agent_identifier_set_New();
00246   }
00247   acl->receiver_num++;
00248 
00249   acl->receiver->num++;
00250   tmp = (struct fipa_agent_identifier_s**)malloc(
00251       sizeof(struct fipa_agent_identifier_s*)
00252       * acl->receiver->num);
00253   /* Copy existing addresses to new array */
00254   for(i = 0; i < acl->receiver->num-1; i++) {
00255     tmp[i] = acl->receiver->fipa_agent_identifiers[i];
00256   }
00257   /* Create new receiver */
00258   tmp[i] = fipa_agent_identifier_New();
00259   tmp[i]->name = strdup(name);
00260   if(address != NULL) {
00261     tmp[i]->addresses = fipa_url_sequence_New();
00262     tmp[i]->addresses->num = 1;
00263     tmp[i]->addresses->urls = (struct fipa_url_s**)malloc(
00264         sizeof(struct fipa_url_s*));
00265     tmp[i]->addresses->urls[0] = fipa_url_New();
00266     tmp[i]->addresses->urls[0]->str = strdup(address);
00267   }
00268   free(acl->receiver->fipa_agent_identifiers);
00269   acl->receiver->fipa_agent_identifiers = tmp;
00270   return 0;
00271 }
00272 
00273 int MC_AclAddReplyTo(
00274     fipa_acl_message_t* acl,
00275     const char* name,
00276     const char* address)
00277 {
00278   int i;
00279   struct fipa_agent_identifier_s** tmp;
00280   if (acl->reply_to == NULL) {
00281     acl->reply_to = fipa_agent_identifier_set_New();
00282   }
00283 
00284   acl->reply_to->num++;
00285   tmp = (struct fipa_agent_identifier_s**)malloc(
00286       sizeof(struct fipa_agent_identifier_s*)
00287       * acl->reply_to->num);
00288   /* Copy existing addresses to new array */
00289   for(i = 0; i < acl->reply_to->num-1; i++) {
00290     tmp[i] = acl->reply_to->fipa_agent_identifiers[i];
00291   }
00292   /* Create new reply_to */
00293   tmp[i] = fipa_agent_identifier_New();
00294   tmp[i]->name = strdup(name);
00295   if(address != NULL) {
00296     tmp[i]->addresses = fipa_url_sequence_New();
00297     tmp[i]->addresses->num = 1;
00298     tmp[i]->addresses->urls = (struct fipa_url_s**)malloc(
00299         sizeof(struct fipa_url_s*));
00300     tmp[i]->addresses->urls[0] = fipa_url_New();
00301     tmp[i]->addresses->urls[0]->str = strdup(address);
00302   }
00303   free (acl->reply_to->fipa_agent_identifiers);
00304   acl->reply_to->fipa_agent_identifiers = tmp;
00305   return 0;
00306 }
00307 
00308 int MC_AclSetContent(
00309     fipa_acl_message_t* acl,
00310     const char* content )
00311 {
00312   if (acl->content != NULL) {
00313     /* There is already content. Lets over-write it. */
00314     fipa_string_Destroy(acl->content);
00315   }
00316   acl->content = fipa_string_New();
00317   acl->content->content = strdup(content);
00318 
00319   return 0;
00320 }
00321 
00322 /* End ACL Helper Functions */
00323 
00324 EXPORTMC int 
00325 MC_AddAgent(MCAgency_t attr, MCAgent_t agent) /*{{{*/
00326 {
00327   agent->mc_platform = attr->mc_platform;
00328 
00329   agent_queue_Add(attr->mc_platform->agent_queue, agent);
00330 
00331   MUTEX_LOCK(attr->mc_platform->ams->runflag_lock);
00332   attr->mc_platform->ams->run = 1;
00333   COND_SIGNAL(attr->mc_platform->ams->runflag_cond);
00334   MUTEX_UNLOCK(attr->mc_platform->ams->runflag_lock);
00335   return 0;
00336 } /*}}}*/
00337 
00338 const void* MC_AgentVariableRetrieve(MCAgent_t agent, const char* var_name, int task_num)
00339 {
00340   interpreter_variable_data_t* interp_var;
00341 
00342   if (task_num >= agent->datastate->task_progress) {
00343     return NULL;
00344   }
00345 
00346   interp_var = agent_variable_list_Search(
00347       agent->datastate->tasks[task_num]->agent_variable_list,
00348       var_name );
00349   if (interp_var == NULL) {
00350     return NULL;
00351   }
00352 
00353   return interp_var->data;
00354 }
00355 
00356 int MC_AgentVariableRetrieveInfo(MCAgent_t agent, const char* var_name, int task_num, const void** data, int* dim, const int** extent)
00357 {
00358   interpreter_variable_data_t* interp_var;
00359 
00360   if (task_num >= agent->datastate->task_progress) {
00361     return MC_ERR_NOT_FOUND;
00362   }
00363 
00364   interp_var = agent_variable_list_Search(
00365       agent->datastate->tasks[task_num]->agent_variable_list,
00366       var_name );
00367   if (interp_var == NULL) {
00368     return MC_ERR_NOT_FOUND;
00369   }
00370   *data = interp_var->data;
00371   *dim = interp_var->array_dim;
00372   *extent = interp_var->array_extent;
00373 
00374   return MC_SUCCESS;
00375 }
00376 
00377 int MC_AgentVariableSave(MCAgent_t agent, const char* var_name)
00378 {
00379   int current_task = agent->datastate->task_progress;
00380   const int default_num_vars = 50;
00381   agent_task_p task = agent->datastate->tasks[current_task];
00382 
00383   if(task->num_saved_variables == 0) {
00384     task->saved_variables = (char**)malloc(sizeof(char*)*default_num_vars);
00385     memset(task->saved_variables, 0, sizeof(char*)*default_num_vars);
00386   }
00387   task->saved_variables[task->num_saved_variables] = strdup(var_name);
00388   if(task->saved_variables[task->num_saved_variables] == NULL) {
00389     fprintf(stderr, "Memory error. %s:%d\n", __FILE__, __LINE__);
00390     return MC_ERR_MEMORY;
00391   }
00392   task->num_saved_variables++;
00393 
00394   return 0;
00395 }
00396 
00397 int 
00398 MC_Barrier(MCAgency_t attr, int id) /*{{{*/
00399 {
00400     barrier_queue_p list = attr->mc_platform->barrier_queue;
00401     barrier_node_p node;
00402     node = barrier_queue_Get(list, id);
00403     if(node == NULL) {
00404         return MC_ERR_NOT_FOUND;
00405     }
00406 
00407     MUTEX_LOCK(node->lock);
00408     node->num_waiting++;
00409     if (node->num_waiting >= node->num_registered) {
00410         /* Wake all agents/threads waiting on this barrier */
00411         COND_BROADCAST(node->cond);
00412         MUTEX_UNLOCK(node->lock);
00413         return MC_SUCCESS;
00414     } else {
00415         while (node->num_waiting < node->num_registered) {
00416             COND_WAIT(node->cond, node->lock);
00417         }
00418         MUTEX_UNLOCK(node->lock);
00419     }
00420     return MC_SUCCESS;
00421 } /*}}}*/
00422 
00423 EXPORTMC int
00424 MC_BarrierInit(MCAgency_t attr, int id, int num_procs) /*{{{*/
00425 {
00426     barrier_node_p node;
00427     /* First see if there already exists a barrier of the same ID. */
00428     node = barrier_queue_Get(attr->mc_platform->barrier_queue, id);
00429     if (node != NULL) {
00430       return MC_ERR;
00431     }
00432     node = barrier_node_Initialize(id, num_procs);
00433     barrier_queue_Add(attr->mc_platform->barrier_queue, node);
00434     return MC_SUCCESS;
00435 } /*}}}*/
00436 
00437 EXPORTMC int 
00438 MC_BarrierDelete(MCAgency_t attr, int id) /*{{{*/
00439 {
00440   return barrier_queue_Delete(id, attr->mc_platform->barrier_queue);
00441 } /*}}}*/
00442 
00443 EXPORTMC int
00444 MC_CallAgentFunc(
00445     MCAgent_t agent,
00446     const char* funcName,
00447     void* returnVal,
00448     int numArgs,
00449     ...)
00450 {
00451   int return_code;
00452   va_list vl;
00453   va_start(vl, numArgs);
00454   MUTEX_LOCK(agent->run_lock);
00455   return_code = Ch_CallFuncByNamev(
00456       agent->agent_interp,
00457       funcName,
00458       returnVal,
00459       vl );
00460   MUTEX_UNLOCK(agent->run_lock);
00461   return return_code;
00462 }
00463 
00464 EXPORTMC int 
00465 MC_CallAgentFuncArg( /*{{{*/
00466         MCAgent_t agent,
00467         const char* funcName,
00468         void* returnVal, /* FIXME: Should this be a double pointer? */
00469         void* arg)
00470 {
00471     int return_code;
00472 
00473     MUTEX_LOCK(agent->run_lock); 
00474     return_code = Ch_CallFuncByName(
00475             agent->agent_interp,
00476             funcName,
00477             returnVal,
00478             arg);
00479     MUTEX_UNLOCK(agent->run_lock); 
00480     return return_code;
00481 } /*}}}*/ 
00482 
00483 EXPORTMC int
00484 MC_CallAgentFuncV(
00485     MCAgent_t agent,
00486     const char* funcName,
00487     void* returnVal,
00488     va_list ap)
00489 {
00490   int return_code;
00491   MUTEX_LOCK(agent->run_lock);
00492   return_code = Ch_CallFuncByNamev
00493     (
00494      agent->agent_interp,
00495      funcName,
00496      returnVal,
00497      ap
00498     );
00499   MUTEX_UNLOCK(agent->run_lock);
00500   return return_code;
00501 }
00502 
00503 EXPORTMC int
00504 MC_CallAgentFuncVar(
00505                     MCAgent_t agent,
00506                     const char* funcName,
00507                     void* returnVal,
00508                     ChVaList_t varg)
00509 {
00510   int return_code;
00511   MUTEX_LOCK(agent->run_lock);
00512   return_code = Ch_CallFuncByNameVar
00513     (
00514      agent->agent_interp,
00515      funcName,
00516      returnVal,
00517      varg
00518      );
00519   MUTEX_UNLOCK(agent->run_lock);
00520   return return_code;
00521 }
00522 
00523 EXPORTMC int 
00524 MC_ChInitializeOptions(MCAgency_t attr, ChOptions_t *options) { /*{{{*/
00525     if(attr->mc_platform == NULL) {
00526         fprintf(stderr, "MC_ChInitializeOptions must be called after MC_Start()\n");
00527         fprintf(stderr, "Using default interpretor options...\n");
00528         return 1;
00529     }
00530     else {
00531         if (attr->mc_platform->interp_options == NULL) {
00532           attr->mc_platform->interp_options = (ChOptions_t*)malloc(
00533               sizeof(ChOptions_t) );
00534         }
00535         *attr->mc_platform->interp_options = *options;
00536         attr->mc_platform->interp_options->chhome = strdup(options->chhome);
00537         return 0;
00538     }
00539 } /*}}}*/
00540 
00541 MCAgent_t
00542 MC_ComposeAgent(
00543     const char* name,
00544     const char* home,
00545     const char* owner, 
00546     const char* code,
00547     const char* return_var_name,
00548     const char* server,
00549     int persistent
00550     )
00551 {
00552   agent_p agent;
00553   agent = agent_New();
00554   if (agent == NULL) return NULL;
00555   agent->name = strdup(name);
00556   agent->home = strdup(home);
00557   agent->owner = strdup(owner);
00558 
00559   agent->orphan = 1;
00560 
00561   agent->agent_type = MC_LOCAL_AGENT;
00562   agent->agent_status = MC_WAIT_MESSGSEND;
00563 
00564   agent->datastate = agent_datastate_New();
00565   agent->datastate->number_of_tasks = 1;
00566   agent->datastate->persistent = persistent;
00567   agent->datastate->agent_code_ids = (char**)malloc(
00568       sizeof(char*)*2);
00569   if(agent->datastate->agent_code_ids == NULL) {
00570     fprintf(stderr, "Memory Error %s:%d\n", __FILE__, __LINE__);
00571   }
00572   agent->datastate->agent_code_ids[0] = strdup("");
00573   if(agent->datastate->agent_code_ids[0] == NULL) {
00574     fprintf(stderr, "Memory Error %s:%d\n", __FILE__, __LINE__);
00575   }
00576   agent->datastate->agent_code_ids[1] = NULL;
00577 
00578   agent->datastate->agent_codes = (char**)malloc(
00579       sizeof(char*)*2);
00580   if(agent->datastate->agent_codes == NULL) {
00581     fprintf(stderr, "Memory Error %s:%d\n", __FILE__, __LINE__);
00582   }
00583   agent->datastate->agent_codes[0] = strdup(code);
00584   if(agent->datastate->agent_codes[0] == NULL) {
00585     fprintf(stderr, "Memory Error %s:%d\n", __FILE__, __LINE__);
00586   }
00587   agent->datastate->agent_codes[1] = NULL;
00588 
00589   agent->datastate->agent_code = agent->datastate->agent_codes[0];
00590 
00591   agent->datastate->tasks = (agent_task_t**)malloc(
00592       sizeof(agent_task_t*));
00593   agent->datastate->tasks[0] = agent_task_New();
00594   if(return_var_name == NULL) {
00595     agent->datastate->tasks[0]->var_name = strdup("no-return");
00596   } else {
00597     agent->datastate->tasks[0]->var_name = strdup(return_var_name);
00598   }
00599   if(agent->datastate->tasks[0]->var_name == NULL) {
00600     fprintf(stderr, "Memory Error %s:%d\n", __FILE__, __LINE__);
00601   }
00602 
00603   agent->datastate->tasks[0]->server_name = strdup(server);
00604   if(agent->datastate->tasks[0]->server_name == NULL) {
00605     fprintf(stderr, "Memory Error %s:%d\n", __FILE__, __LINE__);
00606   }
00607   
00608   return agent;
00609 }
00610 
00611 EXPORTMC int 
00612 MC_CondBroadcast(MCAgency_t attr, int id) /*{{{*/
00613 {
00614     syncListNode_t *condnode;
00615     condnode = syncListFind(id, attr->mc_platform->syncList);
00616     if (condnode == NULL) {
00617         return MC_ERR_NOT_FOUND;
00618     }
00619     MUTEX_LOCK(condnode->lock);
00620     condnode->signalled=1;
00621     COND_BROADCAST(condnode->cond);
00622     MUTEX_UNLOCK(condnode->lock);
00623     return 0;
00624 } /*}}}*/
00625 
00626 EXPORTMC int 
00627 MC_CondSignal(MCAgency_t attr, int id) /*{{{*/
00628 {
00629     syncListNode_t *condnode;
00630     condnode = syncListFind(id, attr->mc_platform->syncList);
00631     if (condnode == NULL) {
00632         return MC_ERR_NOT_FOUND;
00633     }
00634     MUTEX_LOCK(condnode->lock);
00635     condnode->signalled=1;
00636     COND_SIGNAL(condnode->cond);
00637     MUTEX_UNLOCK(condnode->lock);
00638     return 0;
00639 } /*}}}*/
00640 
00641 EXPORTMC int 
00642 MC_CondWait(MCAgency_t attr, int id)  /*{{{*/
00643 {
00644     syncListNode_t *condnode;
00645     condnode = syncListFind(id, attr->mc_platform->syncList);
00646     if (condnode == NULL) {
00647         return MC_ERR_NOT_FOUND;
00648     }
00649     MUTEX_LOCK(condnode->lock);
00650     if (condnode->signalled) {
00651         MUTEX_UNLOCK(condnode->lock);
00652         return 1;
00653     }
00654 
00655     while (condnode->signalled == 0) {
00656       COND_WAIT(condnode->cond, condnode->lock);
00657     }
00658     MUTEX_UNLOCK(condnode->lock);
00659 
00660     return 0;
00661 } /*}}}*/
00662 
00663 EXPORTMC int 
00664 MC_CondReset(MCAgency_t attr, int id) /*{{{*/
00665 {
00666     syncListNode_t *condnode;
00667     condnode = syncListFind(id, attr->mc_platform->syncList);
00668     if (condnode == NULL) {
00669         return MC_ERR_NOT_FOUND;
00670     }
00671     MUTEX_LOCK(condnode->lock);
00672     if (condnode->signalled) {
00673         condnode->signalled = 0;
00674         MUTEX_UNLOCK(condnode->lock);
00675         return 0;
00676     }
00677     MUTEX_UNLOCK(condnode->lock);
00678     return 1;
00679 } /*}}}*/
00680 
00681 int 
00682 MC_CopyAgent(MCAgent_t* agent_out, const MCAgent_t agent_in) /*{{{*/
00683 {
00684   *agent_out = agent_Copy(agent_in);
00685   return MC_SUCCESS;
00686 } /*}}}*/
00687 
00688 EXPORTMC int 
00689 MC_DeleteAgent(MCAgent_t agent) /*{{{*/
00690 {
00691     /* Error Checking */
00692     CHECK_NULL(agent, return MC_ERR_INVALID;);
00693 
00694     /* First, make sure the agent is no longer running */
00695     MC_TerminateAgent(agent);
00696 
00697     /* Now, we just set it's status to MC_WAIT_FINISHED so that the AMS will
00698      * flush it next chance it gets. */
00699     MC_SetAgentStatus(agent, MC_WAIT_FINISHED);
00700     return MC_SUCCESS;
00701 } /*}}}*/
00702 
00703 int MC_DestroyServiceSearchResult(
00704     char** agentName,
00705     char** serviceName,
00706     int* agentID,
00707     int numResult)
00708 {
00709   int i;
00710   for(i = 0;i < numResult; i++)
00711   {
00712     free(agentName[i]);
00713     free(serviceName[i]);
00714   }
00715   free(agentName);
00716   free(serviceName);
00717   free(agentID);
00718 
00719   return 0;
00720 }
00721 
00722 int 
00723 MC_DeregisterService( /*{{{*/
00724         MCAgency_t agency,
00725         int agentID,
00726         const char *serviceName)
00727 {
00728     int err_code;
00729 
00730     df_request_list_node_t *req_node;
00731     df_deregister_p deregister_data;
00732 
00733     req_node = df_request_list_node_New();
00734     req_node->command = (char*)malloc(sizeof(char)*11);
00735 
00736     strcpy((char*)req_node->command, "deregister");
00737 
00738     deregister_data = (df_deregister_p)malloc(sizeof(df_deregister_t));
00739     deregister_data->agent_id = agentID;
00740     deregister_data->service_name = (char*)serviceName;
00741 
00742     req_node->data = deregister_data;
00743 
00744     err_code = df_AddRequest(
00745             agency->mc_platform->df,
00746             req_node
00747             );
00748     return err_code;
00749 } /*}}}*/
00750 
00751 EXPORTMC int
00752 MC_End(MCAgency_t agency) /*{{{*/
00753 {
00754   /* Now, we must stop all the running pthreads somehow... */
00755   /* We will set the quit flag and signal some important threads to make
00756    * sure they exit cleanly. We want the df, ams, and especially the acc
00757    * to be done with whatever they are doing before exiting. */
00758   MUTEX_LOCK(agency->mc_platform->quit_lock);
00759   agency->mc_platform->quit = 1;
00760   COND_BROADCAST( agency->mc_platform->quit_cond );
00761   MUTEX_UNLOCK(agency->mc_platform->quit_lock);
00762 
00763   /* Stop the listen thread */
00764   if( GET_THREAD_MODE( agency->threads, MC_THREAD_ACC)) {
00765     THREAD_CANCEL( agency->mc_platform->acc->listen_thread );
00766   } 
00767 
00768   /* Stop the connection queue */
00769   MUTEX_LOCK(agency->mc_platform->connection_queue->lock);
00770   COND_SIGNAL(agency->mc_platform->connection_queue->cond);
00771   MUTEX_UNLOCK(agency->mc_platform->connection_queue->lock);
00772   if( GET_THREAD_MODE( agency->threads, MC_THREAD_ACC)) {
00773     THREAD_JOIN(agency->mc_platform->acc->thread);
00774   }
00775 
00776   /* Stop the AMS */
00777   MUTEX_LOCK(agency->mc_platform->ams->runflag_lock);
00778   COND_SIGNAL(agency->mc_platform->ams->runflag_cond);
00779   MUTEX_UNLOCK(agency->mc_platform->ams->runflag_lock);
00780   if( GET_THREAD_MODE( agency->threads, MC_THREAD_AMS)) {
00781     THREAD_JOIN(agency->mc_platform->ams->thread);
00782   }
00783 
00784   /* Stop the message queue */
00785   MUTEX_LOCK(agency->mc_platform->message_queue->lock);
00786   COND_SIGNAL(agency->mc_platform->message_queue->cond);
00787   MUTEX_UNLOCK(agency->mc_platform->message_queue->lock);
00788   if( GET_THREAD_MODE( agency->threads, MC_THREAD_ACC)) {
00789     THREAD_JOIN(agency->mc_platform->acc->message_handler_thread);
00790   }
00791 
00792   /* Stop the DF */
00793   MUTEX_LOCK(agency->mc_platform->df->request_list->lock);
00794   COND_SIGNAL(agency->mc_platform->df->request_list->cond);
00795   MUTEX_UNLOCK(agency->mc_platform->df->request_list->lock);
00796   if( GET_THREAD_MODE( agency->threads, MC_THREAD_DF)) {
00797     THREAD_JOIN(agency->mc_platform->df->thread);
00798   }
00799 
00800   /* Stop the command prompt */
00801   if( GET_THREAD_MODE( agency->threads, MC_THREAD_CP)) {
00802     THREAD_CANCEL( agency->mc_platform->cmd_prompt->thread );
00803   }
00804 
00805   mc_platform_Destroy(agency->mc_platform);
00806 
00807   if (agency->hostName)
00808     free(agency->hostName); 
00809   free(agency);
00810 
00811   return 0;
00812 } /*}}}*/
00813 
00814 EXPORTMC MCAgent_t 
00815 MC_FindAgentByName( MCAgency_t attr, /*{{{*/
00816     const char *name) 
00817 {
00818   extern mc_platform_p g_mc_platform;
00819   if (attr == NULL) {
00820     return agent_queue_SearchName(g_mc_platform->agent_queue, name);
00821   } else {
00822     return agent_queue_SearchName(attr->mc_platform->agent_queue,
00823         name);
00824   }
00825 } /*}}}*/
00826 
00827 EXPORTMC MCAgent_t
00828 MC_FindAgentByID( MCAgency_t attr, /*{{{*/
00829     int ID)
00830 {
00831   extern mc_platform_p g_mc_platform;
00832   if (attr == NULL) {
00833     return agent_queue_Search(g_mc_platform->agent_queue, ID);
00834   } else {
00835     return agent_queue_Search(attr->mc_platform->agent_queue,
00836         ID);
00837   }
00838 } /*}}}*/
00839 
00840 #ifndef _WIN32
00841   time_t 
00842 #else
00843   SYSTEMTIME
00844 #endif
00845 MC_GetAgentArrivalTime(MCAgent_t agent) /*{{{*/
00846 {
00847   if (agent != NULL) {
00848     return agent->arrival_time;
00849   } else {
00850 #ifndef _WIN32
00851     return (time_t)-1;
00852 #else
00853     SYSTEMTIME oy;
00854     return oy;
00855 #endif
00856   }
00857 } /*}}}*/
00858 
00859 EXPORTMC int 
00860 MC_GetAgentStatus(MCAgent_t agent) /*{{{*/
00861 {
00862   int status;
00863   MUTEX_LOCK(agent->lock);
00864   status = agent->agent_status;
00865   MUTEX_UNLOCK(agent->lock);
00866   return status;
00867 } /*}}}*/
00868 
00869 EXPORTMC char*
00870 MC_GetAgentXMLString(MCAgent_t agent) /*{{{*/
00871 {
00872   char *ret;
00873   ret = mxmlSaveAllocString(
00874       agent->datastate->xml_agent_root,
00875       NULL
00876       );
00877   return ret;
00878 } /*}}}*/
00879 
00880 /*ChInterp_t */
00881 EXPORTMC void*
00882 MC_GetAgentExecEngine(MCAgent_t agent) /*{{{*/
00883 {
00884   return agent->agent_interp;
00885 } /*}}}*/
00886 
00887 EXPORTMC int 
00888 MC_GetAgentID( /*{{{*/
00889     MCAgent_t agent
00890     )
00891 {
00892   return agent->id;
00893 } /*}}}*/
00894 
00895 EXPORTMC char* 
00896 MC_GetAgentName( /*{{{*/
00897     MCAgent_t agent
00898     )
00899 {
00900   char *name;
00901   MUTEX_LOCK(agent->lock);
00902   name = (char*)malloc(sizeof(char) * 
00903       (strlen (agent->name) + 1)
00904       );
00905   strcpy(
00906       name,
00907       agent->name
00908       );
00909   MUTEX_UNLOCK(agent->lock);
00910   return name;
00911 } /*}}}*/
00912 
00913 EXPORTMC int
00914 MC_GetAgentReturnData( /*{{{*/
00915     MCAgent_t agent,
00916     int task_num,
00917     void **data,
00918     int *dim,
00919     int **extent) 
00920 {
00921   int num_elements;
00922   int size;
00923   int i;
00924   if (task_num >= agent->datastate->number_of_tasks) {
00925     *data = NULL;
00926     *dim = 0;
00927     *extent = NULL;
00928     return 1;
00929   }
00930   if (
00931       agent->datastate->tasks[task_num]->
00932       agent_return_data->data_type == -1
00933      )
00934   {
00935     return 1;
00936   }
00937   CH_DATATYPE_SIZE(
00938       agent->datastate->tasks[task_num]->agent_return_data->data_type,
00939       size);
00940   num_elements = 1;
00941   for (
00942       i = 0; 
00943       i < agent->datastate->tasks[task_num]->agent_return_data->array_dim;
00944       i++
00945       )
00946   {
00947     num_elements *= agent->datastate->
00948       tasks[task_num]->agent_return_data->array_extent[i];
00949   }
00950 
00951 
00952   *data = malloc(num_elements * size);
00953   memcpy(
00954       *data,
00955       agent->datastate->tasks[task_num]->
00956       agent_return_data->data,
00957       size * num_elements
00958       );
00959   *dim = agent->datastate->tasks[task_num]->agent_return_data->array_dim;
00960   *extent = (int*)malloc(
00961       sizeof(int) * 
00962       agent->datastate->tasks[task_num]->agent_return_data->array_dim
00963       );
00964   for (i = 0; i < *dim; i++) {
00965     (*extent)[i] = 
00966       agent->datastate->tasks[task_num]->agent_return_data->array_extent[i];
00967   }
00968   /*    memcpy(
00969    *extent,
00970    agent->datastate->tasks[0]->agent_return_data->array_extent,
00971    *dim
00972    ); */
00973   return 0;
00974 } /*}}}*/
00975 
00976 EXPORTMC int 
00977 MC_GetAgentNumTasks(MCAgent_t agent) /*{{{*/
00978 {
00979   return agent->datastate->number_of_tasks;
00980 } /*}}}*/
00981 
00982 EXPORTMC enum MC_AgentType_e
00983 MC_GetAgentType(MCAgent_t agent) /*{{{*/
00984 {
00985   if (agent != NULL) {
00986     return agent->agent_type;
00987   } else {
00988     return 0;
00989   }
00990 } /*}}}*/
00991 
00992 int 
00993 MC_GetAllAgents(MCAgency_t attr, MCAgent_t **agents, int* num_agents) /*{{{*/
00994 {
00995   int halt;
00996   int index = 0;
00997   MUTEX_LOCK(attr->mc_platform->giant_lock);
00998   halt = (attr->mc_platform->giant == 1) ? 1 : 0;
00999   MUTEX_UNLOCK(attr->mc_platform->giant_lock);
01000   if (halt)
01001     MC_HaltAgency(attr);
01002   /* Count the number of agents */
01003   while (agent_queue_SearchIndex(attr->mc_platform->agent_queue, index) != NULL) {
01004     index++;
01005   }
01006   *agents = (MCAgent_t *)malloc(sizeof(MCAgent_t*) * index);
01007   *num_agents = index;
01008   /* Assign the agents */
01009   index = 0;
01010   while
01011     (
01012      (
01013       (*agents)[index] = agent_queue_SearchIndex
01014       (
01015        attr->mc_platform->agent_queue,
01016        index
01017       )
01018      )
01019     )
01020     {
01021       index++;
01022     }
01023   if(halt)
01024     MC_ResumeAgency(attr);
01025   return 0;
01026 } /*}}}*/
01027 
01028 EXPORTMC int
01029 MC_HaltAgency(MCAgency_t attr) /*{{{*/
01030 {
01031   MUTEX_LOCK(attr->mc_platform->giant_lock);
01032   attr->mc_platform->giant=0;
01033   MUTEX_UNLOCK(attr->mc_platform->giant_lock);
01034   return 0;
01035 } /*}}}*/
01036 
01037 EXPORTMC MCAgency_t 
01038 MC_Initialize( /*{{{*/
01039     int port,
01040     MCAgencyOptions_t *options)
01041 {
01042   MCAgency_t ret;
01043   int i=0;
01044   int options_malloc = 0;
01045   char privkey[1210];   // private key after decryption
01046   FILE *f;
01047   char buf[4], ch;
01048 
01049   memset(privkey, '\0', 1210);
01050   ret = (MCAgency_t)malloc(sizeof(struct agency_s));
01051   if (ret == NULL) {return NULL;}
01052 
01053   ret->hostName = malloc(HOST_NAME_MAX);
01054   if (ret->hostName == NULL) {return NULL;}
01055   gethostname(ret->hostName, HOST_NAME_MAX);
01056   /*Save some memory */
01057   CHECK_NULL(
01058       realloc(ret->hostName, sizeof(char)*(strlen(ret->hostName)+1)),
01059       return NULL;
01060       );
01061   if (ret->hostName == NULL) {return NULL;}
01062   ret->portno = port;
01063   ret->server = 1;
01064   ret->client = 0;
01065   ret->default_agentstatus = -1;
01066 
01067   /* Set up agency options */
01068   if(options==NULL) {
01069     options = (MCAgencyOptions_t*)malloc(sizeof(MCAgencyOptions_t));
01070     MC_InitializeAgencyOptions(options);
01071     options_malloc = 1;
01072   }
01073   ret->threads = options->threads;
01074   ret->default_agentstatus = options->default_agent_status;
01075   for(i = 0; i < MC_THREAD_ALL; i++) {
01076     ret->stack_size[i] = options->stack_size[i];
01077   }
01078   /* End agency options */
01079 
01080   ret->mc_platform = mc_platform_Initialize(ret);
01081 
01082 #ifdef NEW_SECURITY
01083         if (options->priv_key_filename != NULL) {
01084                 ret->priv_key_filename = strdup(options->priv_key_filename);
01085         } else {
01086                 ret->priv_key_filename = strdup("rsa_priv");
01087         }
01088         if (options->known_host_filename != NULL) {
01089                 ret->known_host_filename = strdup(options->known_host_filename);
01090         } else {
01091                 ret->known_host_filename = strdup("known_host");
01092         }
01093   /* check whether private key file is encryt or not */
01094  memset(buf,'\0', 4);
01095 
01096   if( (f = fopen(ret->priv_key_filename, "r") ) == NULL) {
01097     fprintf(stderr, "rsa_priv_en file not found \n");
01098                 fprintf(stderr, "Aborting... at %s:%d\n", __FILE__, __LINE__);
01099                 exit(0);
01100         }
01101 
01102   fread (buf, 1, 4, f);
01103 
01104   if(buf[0]=='N' && buf[1] == ' ' && buf[2]=='=' && buf[3]==' '){
01105     fread(privkey, 1210, 1, f);
01106     fclose(f);
01107   }
01108   else{   
01109     fclose(f);
01110     /* prompt for passphrase if its NULL */ 
01111     if(options->passphrase[0] == '\0'){
01112       printf("Please enter the passphrase to decrypt private key  ");
01113       scanf("%s", options->passphrase); 
01114     }  
01115     /* decrypting Private key */  
01116     if( read_encrypted_file(ret->priv_key_filename, privkey, options->passphrase) == -1){
01117       printf("Unable to read private key: passphase is wrong or file not exist\n");
01118       printf("Press any key to exit \n");
01119       getchar();
01120       exit(0); 
01121     }
01122   }
01123 
01124   if (privkey == NULL){
01125      printf("Note: private key is Null \n");    
01126          printf("please verify the private key file or generate it again. \n");
01127          printf("Exiting Mobile-C Agency ... \n");
01128          getchar();
01129          exit(0);
01130   }
01131   memset(ret -> mc_platform -> private_key, '\0', 1210);
01132   strcpy(ret -> mc_platform -> private_key, privkey);
01133 //  printf("My private key length =%d \n%s.\n",strlen(privkey), privkey);
01134 #endif /* NEW_SECURITY */
01135 
01136   /* Set up the global platform */
01137   g_mc_platform = ret->mc_platform;
01138 
01139   if (options_malloc)
01140     free(options);
01141 
01142   ret->mc_platform->agency = ret;
01143   return ret;
01144 } /*}}}*/
01145 
01146 EXPORTMC int 
01147 MC_InitializeAgencyOptions(struct MCAgencyOptions_s* options) /*{{{*/
01148 {
01149   int i;
01150   /* Set the default options */
01151   options->threads = 0xFFFF;
01152   options->default_agent_status = MC_WAIT_CH;
01153   options->modified = 0;
01154   for(i = 0; i < MC_THREAD_ALL; i++) {
01155     options->stack_size[i] = -1;
01156   }
01157   memset(options->passphrase, '\0', 32);
01158 
01159         options->known_host_filename = NULL;
01160         options->priv_key_filename = NULL;
01161   return 0;
01162 } /*}}}*/
01163 
01164 EXPORTMC int
01165 MC_LoadAgentFromFile(MCAgency_t attr, const char* filename)
01166 {
01167   struct stat filestat;
01168   char *buf;
01169   FILE *fp;
01170   message_p message;
01171   extern mc_platform_p g_mc_platform;
01172   buf = NULL;
01173   filestat.st_size = 0;
01174   stat(filename, &filestat);
01175   if (filestat.st_size != 0 ) {
01176     buf = malloc( sizeof(char) * (filestat.st_size+1) );
01177     memset(buf, 0, filestat.st_size+1);
01178   } else {
01179     fprintf(stderr, "Error: File %s not found.\n", filename);
01180     return 1;
01181   }
01182 
01183   fp = fopen(filename, "r");
01184   fread((void*)buf, filestat.st_size, 1, fp);
01185   fclose(fp);
01186 
01187   message = message_New();
01188   if ( 
01189       message_InitializeFromString (
01190       attr->mc_platform,
01191       message,
01192       buf,
01193       "",
01194       5050,
01195       "ams"
01196       )
01197      )
01198   {
01199     message_Destroy(message);
01200   }
01201   free(message->to_address);
01202   message->to_address = NULL;
01203   message->xml_root = mxmlLoadString(
01204       NULL,
01205       buf,
01206       NULL );
01207   if (message->xml_root == NULL) {
01208     fprintf(stderr, "Error loading agent. %s:%d\n", __FILE__, __LINE__);
01209     message_Destroy(message);
01210     return 1;
01211   }
01212   message->xml_payload = mxmlFindElement(
01213       message->xml_root,
01214       message->xml_root,
01215       "MOBILE_AGENT",
01216       NULL,
01217       NULL,
01218       MXML_DESCEND );
01219   if(message->xml_payload == NULL) {
01220     fprintf(stderr, "Error loading agent: <MOBILE_AGENT> tag not found. %s:%d\n",
01221         __FILE__, __LINE__ );
01222     message_Destroy(message);
01223     return 1;
01224   }
01225 
01226   message_queue_Add
01227     (
01228      attr->mc_platform->message_queue,
01229      message
01230     );
01231   return 0;
01232 }
01233 
01234 EXPORTMC int
01235 MC_MigrateAgent(MCAgent_t agent, const char* hostname, int port)
01236 {
01237   /* Rewrite the current task to be on "hostname" and "port" and
01238    * resend the agent to its new destination */
01239   int progress;
01240   progress = agent->datastate->task_progress;
01241   
01242   /* Rewind the task progress */
01243   agent->datastate->task_progress--;
01244 
01245   /* Set the new servername */
01246   free(agent->datastate->tasks[progress]->server_name);
01247   agent->datastate->tasks[progress]->server_name = (char*)malloc(
01248       sizeof(char)*(strlen(hostname) + 10) );
01249   sprintf(agent->datastate->tasks[progress]->server_name, "%s:%d", 
01250       hostname, port);
01251 
01252   /* That is all. */
01253   return 0;
01254 }
01255 
01256 EXPORTMC int 
01257 MC_MutexLock(MCAgency_t attr, int id) /*{{{*/
01258 {
01259   syncListNode_t *syncnode;
01260   syncnode = syncListFind(id, attr->mc_platform->syncList);
01261   if (syncnode == NULL) {
01262     return 1;
01263   }
01264   MUTEX_LOCK(syncnode->lock);
01265   return 0;
01266 } /*}}}*/
01267 
01268 EXPORTMC int 
01269 MC_MutexUnlock(MCAgency_t attr, int id) /*{{{*/
01270 {
01271   syncListNode_t *syncnode;
01272   syncnode = syncListFind(id, attr->mc_platform->syncList);
01273   if (syncnode == NULL) {
01274     return 1;
01275   }
01276   MUTEX_UNLOCK(syncnode->lock);
01277   return 0;
01278 } /*}}}*/
01279 
01280 EXPORTMC int
01281 MC_PrintAgentCode(MCAgent_t agent) /*{{{*/
01282 {
01283   int progress;
01284   MUTEX_LOCK(agent->lock);
01285   progress = agent->datastate->task_progress;
01286   /* If progress is past the last task, print the last task's code. */
01287   if (progress >= agent->datastate->number_of_tasks) {
01288     progress = agent->datastate->number_of_tasks - 1;
01289   }
01290   printf("%s\n",
01291       agent->datastate->agent_code);
01292   MUTEX_UNLOCK(agent->lock);
01293   return 0;
01294 } /*}}}*/
01295 
01296 EXPORTMC int 
01297 MC_RegisterService( /*{{{*/
01298     MCAgency_t agency,
01299     MCAgent_t agent,
01300     int agentID,
01301     const char *agentName,
01302     char **serviceNames,
01303     int numServices)
01304 {
01305   df_request_list_node_t *req_node;
01306   df_node_t *new_node;
01307   int i;
01308   /* Error checking: Either an agent, or agent Name must be
01309    * provided. */
01310   if (agent == NULL && agentName == NULL) {
01311     return MC_ERR_INVALID_ARGS;
01312   }
01313   /* init the request node */
01314   req_node = df_request_list_node_New();
01315   req_node->command = (char*)malloc(sizeof(char)*9);
01316   strcpy((char*)req_node->command, "register");
01317 
01318   new_node = (df_node_t*)malloc(sizeof(df_node_t));
01319   CHECK_NULL(new_node, return MC_ERR_MEMORY);
01320 
01321   /* Init the lock */
01322   new_node->lock = (MUTEX_T*)malloc(sizeof(MUTEX_T));
01323   CHECK_NULL(new_node->lock, return MC_ERR_MEMORY);
01324   MUTEX_INIT(new_node->lock);
01325 
01326   /* Init the agentID */
01327   if (agent==NULL) {
01328     new_node->agent_id = agentID;
01329   } else {
01330     new_node->agent_id = agent->id;
01331   }
01332 
01333   /* Init the agent name */
01334   if (agent==NULL) {
01335     new_node->agent_name = 
01336       (char*)malloc(sizeof(char)*(strlen(agentName)+1));
01337     CHECK_NULL(new_node->agent_name, return MC_ERR_MEMORY;);
01338     strcpy(new_node->agent_name, agentName);
01339   } else {
01340     new_node->agent_name = 
01341       (char*)malloc(
01342           sizeof(char) * 
01343           (strlen(agent->name)+1)
01344           );
01345     CHECK_NULL(new_node->agent_name, return MC_ERR_MEMORY;);
01346     strcpy(new_node->agent_name, agent->name);
01347   }
01348 
01349   /* Init the services */
01350   new_node->service_names = (char**)malloc(
01351       sizeof(char*) * numServices
01352       );
01353   CHECK_NULL(new_node->service_names, return MC_ERR_MEMORY;);
01354   for (i = 0; i < numServices; i++) {
01355     new_node->service_names[i] = (char*) malloc(
01356         sizeof(char) * (strlen(serviceNames[i]) + 1)
01357         );
01358     CHECK_NULL(new_node->service_names[i], return MC_ERR_MEMORY;);
01359     strcpy(
01360         new_node->service_names[i],
01361         serviceNames[i]
01362         );
01363   }
01364   new_node->num_services = numServices;
01365 
01366   req_node->data = (void*)new_node;
01367   req_node->data_size = (sizeof(new_node));
01368 
01369   return df_AddRequest(
01370       agency->mc_platform->df,
01371       req_node
01372       );
01373 } /*}}}*/
01374 
01375 EXPORTMC int 
01376 MC_ResumeAgency(MCAgency_t attr) /*{{{*/
01377 {
01378   MUTEX_LOCK(attr->mc_platform->giant_lock);
01379   attr->mc_platform->giant = 1;
01380   MUTEX_UNLOCK(attr->mc_platform->giant_lock);
01381   return 0;
01382 } /*}}}*/
01383 
01384 EXPORTMC MCAgent_t
01385 MC_RetrieveAgent(MCAgency_t attr) /*{{{*/
01386   /* This function retrieves the first agent with agent_status
01387      MC_AGENT_NEUTRAL it finds. If there are no agents with
01388      the specified attributes, return value is NULL. */
01389 {
01390   int i;
01391   MCAgent_t agent=NULL;
01392   MUTEX_LOCK(attr->mc_platform->agent_queue->lock);
01393   for (i = 0; i < attr->mc_platform->agent_queue->size; i++) {
01394     agent = ListSearch(
01395         attr->mc_platform->agent_queue->list, i);
01396     if (agent->agent_status == MC_AGENT_NEUTRAL) {
01397       break;
01398     }
01399   }
01400   if (agent == NULL) {
01401     MUTEX_UNLOCK(attr->mc_platform->agent_queue->lock);
01402     return NULL;
01403   }
01404   if (agent->agent_status != MC_AGENT_NEUTRAL) {
01405     MUTEX_UNLOCK(attr->mc_platform->agent_queue->lock);
01406     return NULL;
01407   }
01408   MUTEX_UNLOCK(attr->mc_platform->agent_queue->lock);
01409   return agent;
01410 }/*}}}*/
01411 
01412 EXPORTMC char * 
01413 MC_RetrieveAgentCode(MCAgent_t agent) /*{{{*/
01414 {
01415   char *buf;
01416   int len, progress;
01417   MUTEX_LOCK(agent->lock);
01418   progress = agent->datastate->task_progress;
01419   len = strlen(
01420       agent->datastate->agent_code);
01421   buf = (char*)malloc( (len+1)*sizeof(char));
01422   strcpy(buf,
01423       agent->datastate->agent_code);
01424   MUTEX_UNLOCK(agent->lock);
01425   return buf;
01426 } /*}}}*/
01427 
01428 EXPORTMC int 
01429 MC_ResetSignal(MCAgency_t attr) /*{{{*/
01430 {
01431   MUTEX_LOCK(attr->mc_platform->giant_lock);
01432   attr->mc_platform->giant = 1;
01433   attr->mc_platform->MC_signal = MC_NO_SIGNAL;
01434   COND_SIGNAL(attr->mc_platform->giant_cond);
01435   MUTEX_UNLOCK(attr->mc_platform->giant_lock);
01436   return 0;
01437 } /*}}}*/
01438 
01439 EXPORTMC int 
01440 MC_SearchForService( /*{{{*/
01441     /* Input args */
01442     MCAgency_t attr, 
01443     const char *searchString,
01444     /* Return Args */
01445     char*** agentNames,
01446     char*** serviceNames,
01447     int** agentIDs,
01448     int* numResults)
01449 {
01450   df_request_search_p search;
01451   df_search_results_p results;
01452   df_request_list_node_p request;
01453   search = df_request_search_New();
01454   CHECK_NULL(search, return MC_ERR_MEMORY;);
01455   results = (df_search_results_p)malloc(sizeof(df_search_results_t));
01456   CHECK_NULL(results, return MC_ERR_MEMORY;);
01457   request = df_request_list_node_New();
01458   CHECK_NULL(request, return MC_ERR_MEMORY;);
01459 
01460 
01461   search->search_results = results;
01462   search->search_string = (char*)searchString;
01463 
01464   request->data = (void*)search;
01465   request->command = malloc(sizeof(char) * 7);
01466   strcpy((char*)request->command, "search");
01467   request->data_size = sizeof(df_request_search_t);
01468 
01469   COND_SLEEP_ACTION(
01470       search->cond,
01471       search->lock,
01472 
01473       df_AddRequest(attr->mc_platform->df, request);
01474       );
01475   /* When we get here, search->results should be filled. */
01476   *agentNames = search->search_results->agent_names;
01477   *serviceNames = search->search_results->service_names;
01478   *agentIDs = search->search_results->agent_ids;
01479   *numResults = search->search_results->num_results;
01480 
01481   /* Free unused data structures */
01482   free((void*)request->command);
01483   df_request_list_node_Destroy(request);
01484   df_request_search_Destroy(search);
01485 
01486   return MC_SUCCESS;
01487 } /*}}}*/
01488 
01489 EXPORTMC int 
01490 MC_SemaphorePost(MCAgency_t attr, int id) /*{{{*/
01491 {
01492   syncListNode_t *syncnode;
01493   syncnode = syncListFind(id, attr->mc_platform->syncList);
01494   if (syncnode == NULL) {
01495     return 1;
01496   }
01497   SEMAPHORE_POST(syncnode->sem);
01498   return 0;
01499 } /*}}}*/
01500 
01501 EXPORTMC int 
01502 MC_SemaphoreWait(MCAgency_t attr, int id) /*{{{*/
01503 {
01504   syncListNode_t *syncnode;
01505   syncnode = syncListFind(id, attr->mc_platform->syncList);
01506   if (syncnode == NULL) {
01507     return 1;
01508   }
01509   SEMAPHORE_WAIT(syncnode->sem);
01510   return 0;
01511 } /*}}}*/
01512 
01513 int
01514 MC_SendCh(MCAgency_t attr, /*{{{*/
01515     const char *filename,
01516     const char *remotehost,
01517     int port)
01518 {
01519   printf("Sorry, not implemented yet.\n");
01520   return -1;
01521 } /*}}}*/
01522 
01523 EXPORTMC int 
01524 MC_SendAgentMigrationMessage(MCAgency_t attr, /*{{{*/
01525     const char *string,
01526     const char *hostname,
01527     int port)
01528 {
01529   message_p message;
01530   message = message_New();
01531   if(
01532       message_InitializeFromString
01533       (
01534        attr->mc_platform,
01535        message,
01536        string,
01537        hostname,
01538        port,
01539        "ams"
01540       )
01541     )
01542   {
01543     message_Destroy(message);
01544     return MC_ERR;
01545   } else {
01546     return message_queue_Add
01547       (
01548        attr->mc_platform->message_queue,
01549        message
01550       );
01551   }
01552 } /*}}}*/
01553 
01554 EXPORTMC int
01555 MC_SendAgentMigrationMessageFile(MCAgency_t attr,  /*{{{*/
01556     const char *filename, 
01557     const char *hostname,
01558     int port)
01559 {
01560   struct stat filestat;
01561   char *buf;
01562   FILE *fp;
01563   int ret;
01564   message_p message;
01565   agent_t *agent;
01566   extern mc_platform_p g_mc_platform;
01567   mc_platform_p platform;
01568   buf = NULL;
01569   filestat.st_size = 0;
01570   stat(filename, &filestat);
01571   if (filestat.st_size != 0 ) {
01572     buf = malloc( sizeof(char) * (filestat.st_size+1) );
01573     memset(buf, 0, filestat.st_size+1);
01574   } else {
01575     fprintf(stderr, "Error: File %s not found.\n", filename);
01576     return 1;
01577   }
01578 
01579   if (attr == NULL) {
01580     platform = g_mc_platform;
01581   } else {
01582     platform = attr->mc_platform;
01583   }
01584 
01585   fp = fopen(filename, "r");
01586   fread((void*)buf, filestat.st_size, 1, fp);
01587   fclose(fp);
01588 
01589   message = message_New();
01590   if( 
01591       message_InitializeFromString
01592       (
01593        platform,
01594        message,
01595        buf,
01596        hostname,
01597        port,
01598        "ams"
01599       )
01600     )
01601   {
01602     message_Destroy(message);
01603   } else {
01604     /* Here, we wish to fully parse the message and create a fully qualified
01605      * agent, then let the agency send the agent. */
01606     agent = agent_Initialize( platform, message, rand() );
01607     if (agent == NULL) {
01608       fprintf(stderr, "Error initializing agent. %s:%d", __FILE__, __LINE__);
01609     }
01610     agent->agent_status = MC_WAIT_MESSGSEND;
01611     agent_queue_Add( platform->agent_queue, agent);
01612     /* Set the ams to run */
01613     MUTEX_LOCK(platform->ams->runflag_lock);
01614     platform->ams->run = 1;
01615     COND_BROADCAST(platform->ams->runflag_cond);
01616     MUTEX_UNLOCK(platform->ams->runflag_lock);
01617   }
01618   free(buf);
01619   return ret;
01620 } /*}}}*/
01621 
01622 EXPORTMC int 
01623 MC_SendSteerCommand(MCAgency_t attr, enum MC_SteerCommand_e cmd) /*{{{*/
01624 {
01625   MUTEX_LOCK(attr->mc_platform->MC_steer_lock);
01626   attr->mc_platform->MC_steer_command = cmd;
01627   COND_BROADCAST(attr->mc_platform->MC_steer_cond);
01628   MUTEX_UNLOCK(attr->mc_platform->MC_steer_lock);
01629   return 0;
01630 } /*}}}*/
01631 
01632 int
01633 MC_SetAgentStatus(MCAgent_t agent, int status) /*{{{*/
01634 {
01635   MUTEX_LOCK(agent->lock);
01636   agent->agent_status = status;
01637   if (!agent->orphan) {
01638     MUTEX_LOCK(agent->mc_platform->ams->runflag_lock);
01639     agent->mc_platform->ams->run = 1;
01640     COND_SIGNAL(agent->mc_platform->ams->runflag_cond);
01641     MUTEX_UNLOCK(agent->mc_platform->ams->runflag_lock);
01642   }
01643   MUTEX_UNLOCK(agent->lock);
01644   return 0;
01645 } /*}}}*/
01646 
01647 int 
01648 MC_SetDefaultAgentStatus(/*{{{*/
01649     MCAgency_t agency,
01650     enum MC_AgentStatus_e status
01651     ) 
01652 {
01653   agency->mc_platform->default_agentstatus = status;
01654   return 0;
01655 } /*}}}*/
01656 
01657 EXPORTMC int 
01658 MC_SetThreadOn(MCAgencyOptions_t *options, enum MC_ThreadIndex_e index) /*{{{*/
01659 {
01660   SET_THREAD_ON(options->threads, index);
01661   return 0;
01662 } /*}}}*/
01663 
01664 EXPORTMC int 
01665 MC_SetThreadsAllOn(MCAgencyOptions_t* options)
01666 {
01667   int i;
01668   for(i = 0; i < MC_THREAD_ALL; i++) {
01669     SET_THREAD_ON(options->threads, i);
01670   }
01671   return 0;
01672 }
01673 
01674 EXPORTMC int
01675 MC_SetThreadOff(MCAgencyOptions_t *options, enum MC_ThreadIndex_e index) /*{{{*/
01676 {
01677   SET_THREAD_OFF(options->threads, index);
01678   return 0;
01679 } /*}}}*/
01680 
01681 EXPORTMC int
01682 MC_SetThreadsAllOff(MCAgencyOptions_t* options)
01683 {
01684   int i;
01685   for(i = 0; i < MC_THREAD_ALL; i++) {
01686     SET_THREAD_OFF(options->threads, i);
01687   }
01688   return 0;
01689 }
01690 
01691 EXPORTMC int 
01692 MC_Steer(                        /*{{{*/
01693     MCAgency_t attr,
01694     int (*funcptr)(void* data),
01695     void *arg
01696     )
01697 {
01698   MUTEX_LOCK(attr->mc_platform->MC_steer_lock);
01699   do {
01700     attr->mc_platform->MC_steer_command = MC_RUN;
01701     MUTEX_UNLOCK(attr->mc_platform->MC_steer_lock);
01702     (*funcptr)(arg);
01703   } while 
01704   (
01705    attr->mc_platform->MC_steer_command == MC_RESTART 
01706   );
01707   return 0;
01708 } /*}}}*/
01709 
01710 EXPORTMC enum MC_SteerCommand_e 
01711 MC_SteerControl(void) /*{{{*/
01712 {
01713   extern mc_platform_p g_mc_platform;
01714   /* Check to see what current command is */
01715   MUTEX_LOCK(g_mc_platform->MC_steer_lock);
01716   while (g_mc_platform->MC_steer_command == MC_SUSPEND) {
01717     COND_WAIT(
01718         g_mc_platform->MC_steer_cond,
01719         g_mc_platform->MC_steer_lock
01720         );
01721   }
01722   MUTEX_UNLOCK(g_mc_platform->MC_steer_lock);
01723   return g_mc_platform->MC_steer_command;
01724 } /*}}}*/
01725 
01726 EXPORTMC int 
01727 MC_SyncDelete(MCAgency_t attr, int id) /*{{{*/
01728 {
01729   syncListNode_t *sync_node;
01730   /* First, lock the entire list. */
01731   MUTEX_LOCK(attr->mc_platform->syncList->giant_lock);
01732 
01733   /* Find and lock the node */
01734   sync_node = syncListFind(id, attr->mc_platform->syncList);
01735   if (sync_node == NULL) {
01736     MUTEX_UNLOCK(attr->mc_platform->syncList->giant_lock);
01737     return MC_ERR_NOT_FOUND;
01738   }
01739   MUTEX_LOCK(sync_node->lock);
01740 
01741   /* Remove it from the list so it may no longer be used */
01742   if (syncListRemove(id, attr->mc_platform->syncList) == NULL) {
01743     fprintf(stderr, "Fatal error. %s:%d\n",
01744         __FILE__,
01745         __LINE__ );
01746     exit(0);
01747   }
01748 
01749   /* Now, unlock and destroy */
01750   MUTEX_UNLOCK(sync_node->lock);
01751   MUTEX_UNLOCK(attr->mc_platform->syncList->giant_lock);
01752 
01753   return syncListNodeDestroy(sync_node);
01754 } /*}}}*/
01755 
01756 EXPORTMC int
01757 MC_SyncInit(MCAgency_t attr, int id) /*{{{*/
01758 {
01759   syncListNode_t *node;
01760   node = syncListNodeNew();
01761   MUTEX_LOCK(attr->mc_platform->syncList->giant_lock);
01762   if (id == 0) {
01763     id = rand();
01764   }
01765   while (
01766       syncListFind(id, attr->mc_platform->syncList) != NULL
01767       ) 
01768   {
01769     id = rand();
01770   }
01771 
01772   node->id = id;
01773   syncListAddNode(
01774       node,
01775       attr->mc_platform->syncList
01776       );
01777   MUTEX_UNLOCK(attr->mc_platform->syncList->giant_lock);
01778   return id;
01779 }/*}}}*/
01780 
01781 EXPORTMC int 
01782 MC_TerminateAgent(MCAgent_t agent) /*{{{*/
01783 {
01784   int status=0;
01785   if(agent->agent_interp != NULL) {
01786     status = Ch_Abort (agent->agent_interp);
01787   }
01788   return status;
01789 } /*}}}*/
01790 
01791 
01792 #ifdef _WIN32
01793 EXPORTMC BOOL
01794 MC_MainLoop(MCAgency_t attr) /*{{{*/
01795 {
01796   /*    return CloseHandle(attr->global->gaf_ap->thread_id[attr->global->mr_index]); */
01797   Sleep (INFINITE);
01798   return 0;
01799 }
01800 #else
01801 int 
01802 MC_MainLoop(MCAgency_t attr) 
01803 {
01804   MUTEX_LOCK( attr->mc_platform->quit_lock );
01805   while( attr->mc_platform->quit != 1 ) {
01806     COND_WAIT( attr->mc_platform->quit_cond, attr->mc_platform->quit_lock );
01807   }
01808   MUTEX_UNLOCK( attr->mc_platform->quit_lock );
01809   return 0;
01810 } /*}}}*/
01811 #endif
01812 
01813 EXPORTMC int
01814 MC_WaitAgent(MCAgency_t attr) /*{{{*/
01815 {
01816   int size;
01817   MUTEX_LOCK(attr->mc_platform->agent_queue->lock);
01818   while(1) {
01819     size = attr->mc_platform->agent_queue->size;
01820     COND_WAIT(
01821         attr->mc_platform->agent_queue->cond,
01822         attr->mc_platform->agent_queue->lock
01823         );
01824     if (size < attr->mc_platform->agent_queue->size) {
01825       MUTEX_UNLOCK(attr->mc_platform->agent_queue->lock);
01826       break;
01827     } 
01828   }
01829   MUTEX_UNLOCK(attr->mc_platform->agent_queue->lock);
01830   return 0;
01831 } /*}}}*/
01832 
01833 EXPORTMC MCAgent_t
01834 MC_WaitRetrieveAgent(MCAgency_t attr) /*{{{*/
01835 {
01836   int index;
01837   MCAgent_t agent;
01838   MC_WaitSignal(attr, MC_RECV_AGENT);
01839   MUTEX_LOCK(attr->mc_platform->agent_queue->lock);
01840   index = attr->mc_platform->agent_queue->size-1;
01841   agent = ListSearch(
01842       attr->mc_platform->agent_queue->list, index);
01843   MUTEX_UNLOCK(attr->mc_platform->agent_queue->lock);
01844   return agent;
01845 } /*}}}*/
01846 
01847 /* MC_WaitSignal */
01848 /* This function blocks until one of the signals in argument
01849  * 'signals' is signalled. 'signals' must be a binary | combination
01850  * of enum MC_Signal_e type. */
01851 EXPORTMC int
01852 MC_WaitSignal(MCAgency_t attr, int signals) /*{{{*/
01853 {
01854   MUTEX_LOCK(attr->mc_platform->MC_signal_lock);
01855   while(! (signals & attr->mc_platform->MC_signal)) {
01856     COND_WAIT(
01857         attr->mc_platform->MC_signal_cond,
01858         attr->mc_platform->MC_signal_lock
01859         );
01860   }
01861   MUTEX_UNLOCK(attr->mc_platform->MC_signal_lock);
01862   MUTEX_LOCK(attr->mc_platform->giant_lock);
01863   attr->mc_platform->giant = 0;
01864   MUTEX_UNLOCK(attr->mc_platform->giant_lock);
01865   return 0;
01866 } /*}}}*/
01867 
01868 /* *********************** *
01869  * Ch Space chdl functions *
01870  * *********************** */
01871 
01872 /* MC_AclDestroy */
01873 int MC_AclDestroy_chdl(void* varg)
01874 {
01875   int retval;
01876   fipa_acl_message_t* acl_message;
01877   ChInterp_t interp;
01878   ChVaList_t ap;
01879 
01880   Ch_VaStart(interp, ap, varg);
01881   acl_message = Ch_VaArg(interp, ap, fipa_acl_message_t*);
01882   retval = MC_AclDestroy(acl_message);
01883   Ch_VaEnd(interp, ap);
01884   return retval;
01885 }
01886 
01887 /* MC_AclNew */
01888 void* MC_AclNew_chdl(void* varg)
01889 {
01890   void* retval;
01891   retval = (void*)MC_AclNew();
01892   return retval;
01893 }
01894 
01895 /* MC_AclPost */
01896 int MC_AclPost_chdl(void* varg)
01897 {
01898   int retval;
01899   agent_p agent;
01900   fipa_acl_message_t* acl_message;
01901   ChInterp_t interp;
01902   ChVaList_t ap;
01903 
01904   Ch_VaStart(interp, ap, varg);
01905   agent = Ch_VaArg(interp, ap, agent_p);
01906   acl_message = Ch_VaArg(interp, ap, fipa_acl_message_t*);
01907   retval = MC_AclPost(agent, acl_message);
01908   Ch_VaEnd(interp, ap);
01909   return retval;
01910 }
01911 
01912 /* MC_AclReply */
01913 EXPORTCH void*
01914 MC_AclReply_chdl(void* varg)
01915 {
01916   void* retval;
01917   fipa_acl_message_t* acl_message;
01918   ChInterp_t interp;
01919   ChVaList_t ap;
01920 
01921   Ch_VaStart(interp, ap, varg);
01922   acl_message = Ch_VaArg(interp, ap, fipa_acl_message_t*);
01923   retval = (void*)MC_AclReply(acl_message);
01924   Ch_VaEnd(interp, ap);
01925   return retval;
01926 }
01927 
01928 /* MC_AclRetrieve */
01929 EXPORTCH void*
01930 MC_AclRetrieve_chdl(void* varg)
01931 {
01932   void* retval;
01933   MCAgent_t agent;
01934   ChInterp_t interp;
01935   ChVaList_t ap;
01936 
01937   Ch_VaStart(interp, ap, varg);
01938   agent = Ch_VaArg(interp, ap, MCAgent_t);
01939   retval = MC_AclRetrieve(agent);
01940   Ch_VaEnd(interp, ap);
01941   return retval;
01942 }
01943 
01944 /* MC_AclSend */
01945 EXPORTCH int
01946 MC_AclSend_chdl(void* varg)
01947 {
01948   int retval;
01949   fipa_acl_message_t* acl_message;
01950   MCAgency_t temp_attr;
01951   extern mc_platform_p g_mc_platform;
01952 
01953   ChInterp_t interp;
01954   ChVaList_t ap;
01955 
01956   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
01957   CHECK_NULL(temp_attr, exit(-1));
01958   temp_attr->mc_platform = g_mc_platform;
01959 
01960   Ch_VaStart(interp, ap, varg);
01961   acl_message = (fipa_acl_message_t*) Ch_VaArg(interp, ap, void*);
01962   retval = MC_AclSend(temp_attr, acl_message);
01963   Ch_VaEnd(interp, ap);
01964   free(temp_attr);
01965   return retval;
01966 }
01967 
01968 /* MC_AclWaitRetrieve */
01969 EXPORTCH void*
01970 MC_AclWaitRetrieve_chdl(void *varg)
01971 {
01972   void* retval;
01973   MCAgent_t agent;
01974   ChInterp_t interp;
01975   ChVaList_t ap;
01976 
01977   Ch_VaStart(interp, ap, varg);
01978   agent = Ch_VaArg(interp, ap, MCAgent_t);
01979   retval = MC_AclWaitRetrieve(agent);
01980   Ch_VaEnd(interp, ap);
01981   return retval;
01982 }
01983 
01984 /* BEGIN Acl helper functions */
01985 
01986 /* MC_AclSetPerformative */
01987 EXPORTCH int
01988 MC_AclSetPerformative_chdl(void* varg)
01989 {
01990   ChInterp_t interp;
01991   ChVaList_t ap;
01992   struct fipa_acl_message_s* acl;
01993   enum fipa_performative_e performative;
01994   int retval;
01995 
01996   Ch_VaStart(interp, ap, varg);
01997   acl = Ch_VaArg(interp, ap, struct fipa_acl_message_s*);
01998   performative = Ch_VaArg(interp, ap, enum fipa_performative_e);
01999   retval = MC_AclSetPerformative(acl, performative);
02000   Ch_VaEnd(interp, ap);
02001   return retval;
02002 }
02003 
02004 /* MC_AclSetSender */
02005 EXPORTCH int
02006 MC_AclSetSender_chdl(void* varg)
02007 {
02008   ChInterp_t interp;
02009   ChVaList_t ap;
02010   struct fipa_acl_message_s* acl;
02011   char* name;
02012   char* address;
02013   int retval;
02014 
02015   Ch_VaStart(interp, ap, varg);
02016   acl = Ch_VaArg(interp, ap, struct fipa_acl_message_s*);
02017   name = Ch_VaArg(interp, ap, char*);
02018   address = Ch_VaArg(interp, ap, char*);
02019   retval = MC_AclSetSender(acl, name, address);
02020   Ch_VaEnd(interp, ap);
02021   return retval;
02022 }
02023 
02024 /* MC_AclAddReceiver */
02025 EXPORTCH int
02026 MC_AclAddReceiver_chdl(void* varg)
02027 {
02028   ChInterp_t interp;
02029   ChVaList_t ap;
02030   struct fipa_acl_message_s* acl;
02031   char* name;
02032   char* address;
02033   int retval;
02034 
02035   Ch_VaStart(interp, ap, varg);
02036   acl = Ch_VaArg(interp, ap, struct fipa_acl_message_s*);
02037   name = Ch_VaArg(interp, ap, char*);
02038   address = Ch_VaArg(interp, ap, char*);
02039   retval = MC_AclAddReceiver(acl, name, address);
02040   Ch_VaEnd(interp, ap);
02041   return retval;
02042 }
02043 
02044 /* MC_AclAddReplyTo */
02045 EXPORTCH int
02046 MC_AclAddReplyTo_chdl(void* varg)
02047 {
02048   ChInterp_t interp;
02049   ChVaList_t ap;
02050   struct fipa_acl_message_s* acl;
02051   char* name;
02052   char* address;
02053   int retval;
02054 
02055   Ch_VaStart(interp, ap, varg);
02056   acl = Ch_VaArg(interp, ap, struct fipa_acl_message_s*);
02057   name = Ch_VaArg(interp, ap, char*);
02058   address = Ch_VaArg(interp, ap, char*);
02059   retval = MC_AclAddReplyTo(acl, name, address);
02060   Ch_VaEnd(interp, ap);
02061   return retval;
02062 }
02063 
02064 /* MC_AclSetContent */
02065 EXPORTCH int
02066 MC_AclSetContent_chdl(void* varg)
02067 {
02068   ChInterp_t interp;
02069   ChVaList_t ap;
02070   struct fipa_acl_message_s* acl;
02071   char* content;
02072   int retval;
02073 
02074   Ch_VaStart(interp, ap, varg);
02075   acl = Ch_VaArg(interp, ap, struct fipa_acl_message_s*);
02076   content = Ch_VaArg(interp, ap, char*);
02077   retval = MC_AclSetContent(acl, content);
02078   Ch_VaEnd(interp, ap);
02079   return retval;
02080 }
02081 
02082 /* END Acl Helper Functions */
02083 
02084 /* MC_AddAgent */
02085 EXPORTCH int
02086 MC_AddAgent_chdl(void *varg) /*{{{*/
02087 {
02088   int retval;
02089   MCAgent_t agent;
02090   MCAgency_t temp_attr;
02091   extern mc_platform_p g_mc_platform;
02092 
02093   ChInterp_t interp;
02094   ChVaList_t ap;
02095 
02096   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02097   CHECK_NULL(temp_attr, exit(-1));
02098   temp_attr->mc_platform = g_mc_platform;
02099 
02100   Ch_VaStart(interp, ap, varg);
02101   agent = (MCAgent_t) Ch_VaArg(interp, ap, void*);
02102   retval = MC_AddAgent(temp_attr, agent);
02103   Ch_VaEnd(interp, ap);
02104   free(temp_attr);
02105   return retval;
02106 } /*}}}*/
02107 
02108 /* MC_AgentVariableRetrieve */
02109 EXPORTCH const void*
02110 MC_AgentVariableRetrieve_chdl(void* varg)
02111 {
02112   void* retval;
02113   MCAgent_t agent;
02114   const char* var_name;
02115   int task_num;
02116 
02117   ChInterp_t interp;
02118   ChVaList_t ap;
02119 
02120   Ch_VaStart(interp, ap, varg);
02121 
02122   agent = Ch_VaArg(interp, ap, MCAgent_t);
02123   var_name = Ch_VaArg(interp, ap, const char* );
02124   task_num = Ch_VaArg(interp, ap, int);
02125 
02126   retval = MC_AgentVariableRetrieve(agent, var_name, task_num);
02127 
02128   Ch_VaEnd(interp, ap);
02129   return retval;
02130 }
02131 
02132 /* MC_AgentVariableSave */
02133 EXPORTCH int
02134 MC_AgentVariableSave_chdl(void *varg)
02135 {
02136   int retval;
02137   MCAgent_t agent;
02138   const char* var_name;
02139 
02140   ChInterp_t interp;
02141   ChVaList_t ap;
02142 
02143   Ch_VaStart(interp, ap, varg);
02144 
02145   agent = Ch_VaArg(interp, ap, MCAgent_t);
02146   var_name = Ch_VaArg(interp, ap, const char*);
02147 
02148   retval = MC_AgentVariableSave(agent, var_name);
02149 
02150   Ch_VaEnd(interp, ap);
02151   return retval;
02152 }
02153 
02154 /* MC_CallAgentFunc */
02155 EXPORTCH int
02156 MC_CallAgentFunc_chdl(void *varg) /*{{{*/
02157 {
02158   int retval;
02159   /* Function Args */
02160   MCAgent_t agent;
02161   const char* funcName;
02162   void* returnVal;
02163   ChVaList_t args;
02164 
02165   ChInterp_t interp;
02166   ChVaList_t ap;
02167 
02168   Ch_VaStart(interp, ap, varg);
02169 
02170   agent =     Ch_VaArg(interp, ap, MCAgent_t);
02171   funcName =  Ch_VaArg(interp, ap, const char*);
02172   returnVal = Ch_VaArg(interp, ap, void*);
02173   args =      Ch_VaArg(interp, ap, void*);
02174 
02175   retval = MC_CallAgentFuncVar(
02176       agent,
02177       funcName,
02178       returnVal,
02179       args);
02180   Ch_VaEnd(interp, ap);
02181   return retval;
02182 } /*}}}*/
02183 
02184 /* MC_Barrier_chdl*/
02185 EXPORTCH int
02186 MC_Barrier_chdl(void *varg) /*{{{*/
02187 {
02188   MCAgency_t temp_attr;
02189   extern mc_platform_p g_mc_platform;
02190   int retval;
02191   ChInterp_t interp;
02192   ChVaList_t ap;
02193   int id;
02194 
02195   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02196   CHECK_NULL(temp_attr, exit(-1));
02197   temp_attr->mc_platform = g_mc_platform;
02198 
02199   Ch_VaStart(interp, ap, varg);
02200   id = Ch_VaArg(interp, ap, int);
02201   retval = MC_Barrier(temp_attr, id);
02202   Ch_VaEnd(interp, ap);
02203   free(temp_attr);
02204   return retval;
02205 } /*}}}*/
02206 
02207 /* MC_BarrierDelete_chdl*/
02208 EXPORTCH int
02209 MC_BarrierDelete_chdl(void *varg) /*{{{*/
02210 {
02211   MCAgency_t temp_attr;
02212   extern mc_platform_p g_mc_platform;
02213   int retval;
02214   ChInterp_t interp;
02215   ChVaList_t ap;
02216   int id;
02217 
02218   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02219   CHECK_NULL(temp_attr, exit(-1));
02220   temp_attr->mc_platform = g_mc_platform;
02221 
02222   Ch_VaStart(interp, ap, varg);
02223   id = Ch_VaArg(interp, ap, int);
02224   retval = MC_BarrierDelete(temp_attr, id);
02225   Ch_VaEnd(interp, ap);
02226   free(temp_attr);
02227   return retval;
02228 } /*}}}*/
02229 
02230 /* MC_BarrierInit_chdl*/
02231 EXPORTCH int
02232 MC_BarrierInit_chdl(void *varg) /*{{{*/
02233 {
02234   MCAgency_t temp_attr;
02235   extern mc_platform_p g_mc_platform;
02236   int retval;
02237   ChInterp_t interp;
02238   ChVaList_t ap;
02239   int id;
02240   int num_procs;
02241 
02242   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02243   CHECK_NULL(temp_attr, exit(-1));
02244   temp_attr->mc_platform = g_mc_platform;
02245 
02246   Ch_VaStart(interp, ap, varg);
02247   id = Ch_VaArg(interp, ap, int);
02248   num_procs = Ch_VaArg(interp, ap, int);
02249   retval = MC_BarrierInit(temp_attr, id, num_procs);
02250   Ch_VaEnd(interp, ap);
02251   free(temp_attr);
02252   return retval;
02253 } /*}}}*/
02254 
02255 /* MC_CondBroadcast_chdl*/
02256 EXPORTCH int
02257 MC_CondBroadcast_chdl(void *varg) /*{{{*/
02258 {
02259   MCAgency_t temp_attr;
02260   extern mc_platform_p g_mc_platform;
02261   int retval;
02262   ChInterp_t interp;
02263   ChVaList_t ap;
02264   int id;
02265 
02266   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02267   CHECK_NULL(temp_attr, exit(-1));
02268   temp_attr->mc_platform = g_mc_platform;
02269 
02270   Ch_VaStart(interp, ap, varg);
02271   id = Ch_VaArg(interp, ap, int);
02272   retval = MC_CondBroadcast(temp_attr, id);
02273   Ch_VaEnd(interp, ap);
02274   free(temp_attr);
02275   return retval;
02276 } /*}}}*/
02277 
02278 /* MC_ComposeAgent */
02279 EXPORTCH MCAgent_t 
02280 MC_ComposeAgent_chdl(void *varg) /*{{{*/
02281 {
02282   MCAgent_t retval;
02283 
02284   /* Function Args */
02285   const char* name;
02286   const char* home;
02287   const char* owner;  
02288   const char* code;
02289   const char* return_var_name;
02290   const char* server;
02291   int persistent;
02292 
02293   ChInterp_t interp;
02294   ChVaList_t ap;
02295 
02296   Ch_VaStart(interp, ap, varg);
02297 
02298   name  = Ch_VaArg(interp, ap, const char*);
02299   home  = Ch_VaArg(interp, ap, const char*);
02300   owner = Ch_VaArg(interp, ap, const char*);
02301   code = Ch_VaArg(interp, ap, const char*);
02302   return_var_name = Ch_VaArg(interp, ap, const char*);
02303   server = Ch_VaArg(interp, ap, const char*);
02304   persistent = Ch_VaArg(interp, ap, int);
02305 
02306   retval= MC_ComposeAgent(
02307       name,
02308       home,
02309       owner,
02310       code,
02311       return_var_name,
02312       server,
02313       persistent);
02314   Ch_VaEnd(interp, ap);
02315   return retval;
02316 } /*}}}*/
02317 
02318 /* MC_CondSignal_chdl*/
02319 EXPORTCH int
02320 MC_CondSignal_chdl(void *varg) /*{{{*/
02321 {
02322   MCAgency_t temp_attr;
02323   extern mc_platform_p g_mc_platform;
02324   int retval;
02325   ChInterp_t interp;
02326   ChVaList_t ap;
02327   int id;
02328 
02329   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02330   CHECK_NULL(temp_attr, exit(-1));
02331   temp_attr->mc_platform = g_mc_platform;
02332 
02333   Ch_VaStart(interp, ap, varg);
02334   id = Ch_VaArg(interp, ap, int);
02335   retval = MC_CondSignal(temp_attr, id);
02336   Ch_VaEnd(interp, ap);
02337   free(temp_attr);
02338   return retval;
02339 } /*}}}*/
02340 
02341 /* MC_CondReset_chdl*/
02342 EXPORTCH int
02343 MC_CondReset_chdl(void *varg) /*{{{*/   
02344 {
02345   MCAgency_t temp_attr;
02346   extern mc_platform_p g_mc_platform;
02347   int retval;
02348   ChInterp_t interp;
02349   ChVaList_t ap;
02350   int id;
02351 
02352   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02353   CHECK_NULL(temp_attr, exit(-1));
02354   temp_attr->mc_platform = g_mc_platform;
02355 
02356   Ch_VaStart(interp, ap, varg);
02357   id = Ch_VaArg(interp, ap, int);
02358   retval = MC_CondReset(temp_attr, id);
02359   Ch_VaEnd(interp, ap);
02360   free(temp_attr);
02361   return retval;
02362 } /*}}}*/
02363 
02364 /* MC_CondWait_chdl*/
02365 EXPORTCH int
02366 MC_CondWait_chdl(void *varg) /*{{{*/
02367 {
02368   MCAgency_t temp_attr;
02369   extern mc_platform_p g_mc_platform;
02370   int retval;
02371   ChInterp_t interp;
02372   ChVaList_t ap;
02373   int id;
02374 
02375   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02376   CHECK_NULL(temp_attr, exit(-1));
02377   temp_attr->mc_platform = g_mc_platform;
02378 
02379   Ch_VaStart(interp, ap, varg);
02380   id = Ch_VaArg(interp, ap, int);
02381   retval = MC_CondWait(temp_attr, id);
02382   Ch_VaEnd(interp, ap);
02383   free(temp_attr);
02384   return retval;
02385 } /*}}}*/
02386 
02387 EXPORTCH int
02388 MC_DeleteAgent_chdl(void *varg) /*{{{*/
02389 {
02390   ChInterp_t interp;
02391   ChVaList_t ap;
02392   MCAgent_t agent;
02393   int retval;
02394 
02395   Ch_VaStart(interp, ap, varg);
02396   agent = Ch_VaArg(interp, ap, MCAgent_t);
02397   retval = MC_DeleteAgent(agent);
02398   Ch_VaEnd(interp, ap);
02399   return retval;
02400 } /*}}}*/
02401 
02402 EXPORTCH int
02403 MC_DestroyServiceSearchResult_chdl(void* varg)
02404 {
02405   ChInterp_t interp;
02406   ChVaList_t ap;
02407   char** agentName;
02408   char** serviceName;
02409   int* agentID;
02410   int numResult;
02411   int retval;
02412 
02413   Ch_VaStart(interp, ap, varg);
02414   agentName = Ch_VaArg(interp, ap, char**);
02415   serviceName = Ch_VaArg(interp, ap, char**);
02416   agentID = Ch_VaArg(interp, ap, int*);
02417   numResult = Ch_VaArg(interp, ap, int);
02418 
02419   retval = MC_DestroyServiceSearchResult(
02420       agentName,
02421       serviceName,
02422       agentID,
02423       numResult );
02424   Ch_VaEnd(interp, ap);
02425   return retval;
02426 }
02427 
02428 /* MC_DeregisterService_chdl */
02429 EXPORTCH int
02430 MC_DeregisterService_chdl(void *varg) /*{{{*/
02431 {
02432   ChInterp_t interp;
02433   ChVaList_t ap;
02434   MCAgency_t temp_attr;
02435   extern mc_platform_p g_mc_platform;
02436   int agentID;
02437   char *serviceName;
02438   int retval;
02439 
02440   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02441   CHECK_NULL(temp_attr, exit(-1));
02442   temp_attr->mc_platform = g_mc_platform;
02443 
02444   Ch_VaStart(interp, ap, varg);
02445   agentID = Ch_VaArg(interp, ap, int);
02446   serviceName = (char*)Ch_VaArg(interp, ap, const char*);
02447   retval = MC_DeregisterService(
02448       temp_attr,
02449       agentID,
02450       serviceName );
02451   Ch_VaEnd(interp, ap);
02452   free(temp_attr);
02453   return retval;
02454 } /*}}}*/
02455 
02456 EXPORTCH int
02457 MC_End_chdl(void *varg) /* {{{ */
02458 {
02459   MCAgency_t temp_attr;
02460   extern mc_platform_p g_mc_platform;
02461   int retval;
02462 
02463   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02464   CHECK_NULL(temp_attr, exit(-1));
02465   temp_attr->mc_platform = g_mc_platform;
02466 
02467   retval = MC_End(temp_attr);
02468 
02469   return retval;
02470 } /* }}} */
02471 
02472 /* MC_FindAgentByID_chdl*/
02473 EXPORTCH MCAgent_t
02474 MC_FindAgentByID_chdl(void *varg) /*{{{*/
02475 {
02476   MCAgency_t temp_attr;
02477   extern mc_platform_p g_mc_platform;
02478   MCAgent_t retval;
02479   ChInterp_t interp;
02480   ChVaList_t ap;
02481   int id;
02482 
02483   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02484   CHECK_NULL(temp_attr, exit(-1));
02485   temp_attr->mc_platform = g_mc_platform;
02486 
02487   Ch_VaStart(interp, ap, varg);
02488   id = Ch_VaArg(interp, ap, int);
02489   retval = MC_FindAgentByID(temp_attr, id);
02490   Ch_VaEnd(interp, ap);
02491   free(temp_attr);
02492   return retval;
02493 } /*}}}*/
02494 
02495 /* MC_FindAgentByName_chdl*/
02496 EXPORTCH MCAgent_t
02497 MC_FindAgentByName_chdl(void *varg) /*{{{*/
02498 {
02499   MCAgency_t temp_attr;
02500   extern mc_platform_p g_mc_platform;
02501   MCAgent_t retval;
02502   ChInterp_t interp;
02503   ChVaList_t ap;
02504   const char *name;
02505 
02506   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02507   CHECK_NULL(temp_attr, exit(-1));
02508   temp_attr->mc_platform = g_mc_platform;
02509 
02510   Ch_VaStart(interp, ap, varg);
02511   name = Ch_VaArg(interp, ap, const char *);
02512   retval = MC_FindAgentByName(temp_attr, name);
02513   Ch_VaEnd(interp, ap);
02514   free(temp_attr);
02515   return retval;
02516 } /*}}}*/
02517 
02518 /* MC_GetAgentArrivalTime */
02519 #ifndef _WIN32
02520 EXPORTCH time_t
02521 #else
02522 EXPORTCH SYSTEMTIME
02523 #endif
02524 MC_GetAgentArrivalTime_chdl(void *varg) /*{{{*/
02525 {
02526   MCAgent_t agent;
02527   ChInterp_t interp;
02528   ChVaList_t ap;
02529 #ifndef _WIN32
02530   time_t arrival_time;
02531 #else
02532   SYSTEMTIME arrival_time;
02533 #endif
02534 
02535   Ch_VaStart(interp, ap, varg);
02536   agent = Ch_VaArg(interp, ap, MCAgent_t);
02537   arrival_time = MC_GetAgentArrivalTime(agent);
02538   Ch_VaEnd(interp, ap);
02539   return arrival_time;
02540 } /* }}} */
02541 
02542 /* MC_GetAgentID */
02543 EXPORTCH int
02544 MC_GetAgentID_chdl(void *varg) /*{{{*/
02545 {
02546   MCAgent_t agent;
02547   ChInterp_t interp;
02548   ChVaList_t ap;
02549   int id;
02550 
02551   Ch_VaStart(interp, ap, varg);
02552   agent = Ch_VaArg(interp, ap, MCAgent_t);
02553   id = MC_GetAgentID(agent);
02554   Ch_VaEnd(interp, ap);
02555   return id;
02556 } /*}}}*/
02557 
02558 /* MC_GetAgentName */
02559 EXPORTCH char*
02560 MC_GetAgentName_chdl(void *varg) /*{{{*/
02561 {
02562   MCAgent_t agent;
02563   ChInterp_t interp;
02564   ChVaList_t ap;
02565   char* name;
02566 
02567   Ch_VaStart(interp, ap, varg);
02568   agent = Ch_VaArg(interp, ap, MCAgent_t);
02569   name = MC_GetAgentName(agent);
02570   Ch_VaEnd(interp, ap);
02571   return name;
02572 } /*}}}*/
02573 
02574 /* MC_GetAgentNumTasks_chdl */
02575 EXPORTCH int
02576 MC_GetAgentNumTasks_chdl(void *varg)
02577 {
02578   MCAgent_t agent;
02579   ChInterp_t interp;
02580   ChVaList_t ap;
02581   int num_tasks;
02582 
02583   Ch_VaStart(interp, ap, varg);
02584   agent = Ch_VaArg(interp, ap, MCAgent_t);
02585   num_tasks = MC_GetAgentNumTasks(agent);
02586   Ch_VaEnd(interp, ap);
02587   return num_tasks;
02588 }
02589 
02590 /* MC_GetAgentStatus_chdl */
02591 EXPORTCH int
02592 MC_GetAgentStatus_chdl(void *varg) /*{{{*/
02593 {
02594   MCAgent_t agent;
02595   int status;
02596   ChInterp_t interp;
02597   ChVaList_t ap;
02598 
02599   Ch_VaStart(interp, ap, varg);
02600   agent = Ch_VaArg(interp, ap, MCAgent_t);
02601   status = MC_GetAgentStatus(agent);
02602   Ch_VaEnd(interp, ap);
02603   return status;
02604 } /*}}}*/
02605 
02606 /* MC_GetAgentXMLString_chdl */
02607 EXPORTCH char *
02608 MC_GetAgentXMLString_chdl(void *varg) /*{{{*/
02609 {
02610   ChInterp_t interp;
02611   ChVaList_t ap;
02612   MCAgent_t agent;
02613   char *retval;
02614 
02615   Ch_VaStart(interp, ap, varg);
02616   agent = Ch_VaArg(interp, ap, MCAgent_t);
02617   retval = MC_GetAgentXMLString(agent);
02618   Ch_VaEnd(interp, ap);
02619   return retval;
02620 } /*}}}*/
02621 
02622 #ifndef _WIN32
02623 EXPORTCH int
02624 MC_GetTimeOfDay_chdl(void *varg)
02625 {
02626   ChInterp_t interp;
02627   ChVaList_t ap;
02628   struct timeval *tv;
02629   Ch_VaStart(interp, ap, varg);
02630   tv = Ch_VaArg(interp, ap, struct timeval*);
02631   gettimeofday(tv, NULL);
02632   Ch_VaEnd(interp, ap);
02633   return 0;
02634 }
02635 #endif
02636 
02637 /* MC_HaltAgency_chdl */
02638 EXPORTCH int
02639 MC_HaltAgency_chdl(void *varg)
02640 {
02641   MCAgency_t temp_attr;
02642   int retval;
02643   extern mc_platform_p g_mc_platform;
02644 
02645   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02646   CHECK_NULL(temp_attr, exit(-1));
02647   temp_attr->mc_platform = g_mc_platform;
02648 
02649   retval = MC_HaltAgency(temp_attr);
02650 
02651   free(temp_attr);
02652   return retval;
02653 }
02654 
02655 EXPORTCH int
02656 MC_MigrateAgent_chdl(void *varg)
02657 {
02658   MCAgent_t agent;
02659   const char* hostname;
02660   int port;
02661   int retval;
02662   ChInterp_t interp;
02663   ChVaList_t ap;
02664 
02665   Ch_VaStart(interp, ap, varg);
02666   agent = Ch_VaArg(interp, ap, MCAgent_t);
02667   hostname = Ch_VaArg(interp, ap, const char*);
02668   port = Ch_VaArg(interp, ap, int);
02669   retval = MC_MigrateAgent(agent, hostname, port);
02670   return retval;
02671 }
02672 
02673 /* MC_MutexLock_chdl */
02674 EXPORTCH int
02675 MC_MutexLock_chdl(void *varg) /*{{{*/
02676 {
02677   MCAgency_t temp_attr;
02678   extern mc_platform_p g_mc_platform;
02679 
02680   ChInterp_t interp;
02681   ChVaList_t ap;
02682   int id;
02683   int retval;
02684 
02685   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02686   CHECK_NULL(temp_attr, exit(-1));
02687   temp_attr->mc_platform = g_mc_platform;
02688 
02689   Ch_VaStart(interp, ap, varg);
02690   id = Ch_VaArg(interp, ap, int );
02691   retval = MC_MutexLock(temp_attr, id);
02692   Ch_VaEnd(interp, ap);
02693   free(temp_attr);
02694   return retval;
02695 } /*}}}*/
02696 
02697 /* MC_MutexUnlock_chdl */
02698 EXPORTCH int
02699 MC_MutexUnlock_chdl(void *varg) /*{{{*/
02700 {
02701   MCAgency_t temp_attr;
02702   extern mc_platform_p g_mc_platform;
02703 
02704   ChInterp_t interp;
02705   ChVaList_t ap;
02706   int id;
02707   int retval;
02708 
02709   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02710   CHECK_NULL(temp_attr, exit(-1));
02711   temp_attr->mc_platform = g_mc_platform;
02712 
02713   Ch_VaStart(interp, ap, varg);
02714   id = Ch_VaArg(interp, ap, int );
02715   retval = MC_MutexUnlock(temp_attr, id);
02716   Ch_VaEnd(interp, ap);
02717   free(temp_attr);
02718   return retval;
02719 } /*}}}*/
02720 
02721 /* MC_PrintAgentCode_chdl */
02722 EXPORTCH int
02723 MC_PrintAgentCode_chdl(void *varg) /*{{{*/
02724 {
02725   ChInterp_t interp;
02726   ChVaList_t ap;
02727   MCAgent_t agent;
02728   int retval;
02729 
02730   Ch_VaStart(interp, ap, varg);
02731   agent = Ch_VaArg(interp, ap, MCAgent_t);
02732   retval = MC_PrintAgentCode(agent);
02733   Ch_VaEnd(interp, ap);
02734   return retval;
02735 } /*}}}*/
02736 
02737 /* MC_RegisterService_chdl */
02738 EXPORTCH int
02739 MC_RegisterService_chdl(void *varg) /*{{{*/
02740 {
02741   ChInterp_t interp;
02742   ChVaList_t ap;
02743   int retval;
02744   MCAgency_t temp_attr;
02745   extern mc_platform_p g_mc_platform;
02746 
02747   /* varg arguments */
02748   MCAgent_t agent;
02749   char **serviceNames;
02750   int numServices;
02751 
02752   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02753   CHECK_NULL(temp_attr, exit(-1));
02754   temp_attr->mc_platform = g_mc_platform;
02755 
02756   Ch_VaStart(interp, ap, varg);
02757   agent = Ch_VaArg(interp, ap, MCAgent_t);
02758   serviceNames = Ch_VaArg(interp, ap, char **);
02759   numServices = Ch_VaArg(interp, ap, int);
02760 
02761   retval = MC_RegisterService(
02762       temp_attr,      /* agency */
02763       agent,          /* agent */ 
02764       0,              /* agent id */
02765       NULL,           /* agent name */
02766       serviceNames,   /* services */
02767       numServices
02768       );
02769   Ch_VaEnd(interp, ap);
02770   free(temp_attr);
02771   return retval;
02772 } /*}}}*/
02773 
02774 /* MC_ResumeAgency_chdl */
02775 EXPORTCH int
02776 MC_ResumeAgency_chdl(void *varg)
02777 {
02778   MCAgency_t temp_attr;
02779   int retval;
02780   extern mc_platform_p g_mc_platform;
02781 
02782   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02783   CHECK_NULL(temp_attr, exit(-1));
02784   temp_attr->mc_platform = g_mc_platform;
02785 
02786   retval = MC_ResumeAgency(temp_attr);
02787 
02788   free(temp_attr);
02789   return retval;
02790 }
02791 
02792 /* MC_RetrieveAgent_chdl */
02793 EXPORTCH MCAgent_t
02794 MC_RetrieveAgent_chdl(void *varg) /*{{{*/
02795 {
02796   MCAgency_t temp_attr;
02797   extern mc_platform_p g_mc_platform;
02798   MCAgent_t agent;
02799 
02800   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02801   CHECK_NULL(temp_attr, exit(-1));
02802   temp_attr->mc_platform = g_mc_platform;
02803 
02804   agent = MC_RetrieveAgent(temp_attr);
02805   free(temp_attr);
02806   return agent;
02807 } /*}}}*/
02808 
02809 /* MC_RetrieveAgentCode_chdl */
02810 EXPORTCH char *
02811 MC_RetrieveAgentCode_chdl(void *varg) /*{{{*/
02812 {
02813   ChInterp_t interp;
02814   ChVaList_t ap;
02815   MCAgent_t agent;
02816   char *retval;
02817 
02818   Ch_VaStart(interp, ap, varg);
02819   agent = Ch_VaArg(interp, ap, MCAgent_t);
02820   retval = MC_RetrieveAgentCode(agent);
02821   Ch_VaEnd(interp, ap);
02822   return retval;
02823 } /*}}}*/
02824 
02825 /* MC_SaveData_chdl */
02826 EXPORTCH int
02827 MC_SaveData_chdl(void* varg)
02828 {
02829   ChInterp_t interp;
02830   ChVaList_t ap;
02831   interpreter_variable_data_p interp_var_data;
02832   MCAgent_t agent;
02833   int progress;
02834   const char* name;
02835   int size;
02836   void* data;
02837   
02838   Ch_VaStart(interp, ap, varg);
02839   agent = Ch_VaArg(interp, ap, MCAgent_t);
02840   name = Ch_VaArg(interp, ap, char*);
02841   size = Ch_VaArg(interp, ap, int);
02842   data = Ch_VaArg(interp, ap, void*);
02843 
02844   progress = agent->datastate->task_progress;
02845 
02846   interp_var_data = interpreter_variable_data_New();
02847   interp_var_data->name = strdup(name);
02848   interp_var_data->size = size;
02849   interp_var_data->data_type = CH_VOIDPTRTYPE;
02850   interp_var_data->data = malloc(size);
02851   memcpy(interp_var_data->data, data, size);
02852 
02853   agent_variable_list_Add(
02854       agent->datastate->tasks[progress]->agent_variable_list,
02855       interp_var_data );
02856 
02857   return 0;
02858 }
02859 
02860 /* MC_SearchForService_chdl */
02861 EXPORTCH int
02862 MC_SearchForService_chdl(void *varg) /*{{{*/
02863 {
02864   ChInterp_t interp;
02865   ChVaList_t ap;
02866   int retval;
02867   MCAgency_t temp_attr;
02868   extern mc_platform_p g_mc_platform;
02869 
02870   /* Args */
02871   const char* searchString;
02872   char*** agentNames;
02873   char*** serviceNames;
02874   int** agentIDs;
02875   int* numResults;
02876 
02877   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02878   CHECK_NULL(temp_attr, exit(-1));
02879   temp_attr->mc_platform = g_mc_platform;
02880 
02881   Ch_VaStart(interp, ap, varg);
02882   searchString = Ch_VaArg(interp, ap, const char*);
02883   agentNames = Ch_VaArg(interp, ap, char***);
02884   serviceNames = Ch_VaArg(interp, ap, char***);
02885   agentIDs = Ch_VaArg(interp, ap, int**);
02886   numResults = Ch_VaArg(interp, ap, int*);
02887 
02888   retval = MC_SearchForService(
02889       temp_attr,
02890       searchString,
02891       agentNames,
02892       serviceNames,
02893       agentIDs,
02894       numResults
02895       );
02896   Ch_VaEnd(interp, ap);
02897   free(temp_attr);
02898   return retval;
02899 } /*}}}*/
02900 
02901 /* MC_SemaphorePost_chdl */
02902 EXPORTCH int
02903 MC_SemaphorePost_chdl(void *varg) /*{{{*/
02904 {
02905   MCAgency_t temp_attr;
02906   extern mc_platform_p g_mc_platform;
02907 
02908   ChInterp_t interp;
02909   ChVaList_t ap;
02910   int id;
02911   int retval;
02912 
02913   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02914   CHECK_NULL(temp_attr, exit(-1));
02915   temp_attr->mc_platform = g_mc_platform;
02916 
02917   Ch_VaStart(interp, ap, varg);
02918   id = Ch_VaArg(interp, ap, int );
02919   retval = MC_SemaphorePost(temp_attr, id);
02920   Ch_VaEnd(interp, ap);
02921   free(temp_attr);
02922   return retval;
02923 } /*}}}*/
02924 
02925 /* MC_SemaphoreWait_chdl */
02926 EXPORTCH int 
02927 MC_SemaphoreWait_chdl(void *varg) /*{{{*/
02928 {   
02929   MCAgency_t temp_attr;
02930   extern mc_platform_p g_mc_platform;
02931 
02932   ChInterp_t interp;
02933   ChVaList_t ap;
02934   int id;
02935   int retval;
02936 
02937   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02938   CHECK_NULL(temp_attr, exit(-1));
02939   temp_attr->mc_platform = g_mc_platform;
02940 
02941   Ch_VaStart(interp, ap, varg);
02942   id = Ch_VaArg(interp, ap, int );
02943   retval = MC_SemaphoreWait(temp_attr, id);
02944   Ch_VaEnd(interp, ap);
02945   free(temp_attr);
02946   return retval;
02947 } /*}}}*/
02948 
02949 /* MC_SendAgentMigrationMessage_chdl*/
02950 EXPORTCH int
02951 MC_SendAgentMigrationMessage_chdl(void *varg) /*{{{*/
02952 {
02953   MCAgency_t temp_attr;
02954   extern mc_platform_p g_mc_platform;
02955   const char *message, *hostname;
02956   int port, retval;
02957   ChInterp_t interp;
02958   ChVaList_t ap;
02959 
02960   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02961   CHECK_NULL(temp_attr, exit(-1));
02962   temp_attr->mc_platform = g_mc_platform;
02963 
02964   Ch_VaStart(interp, ap, varg);
02965   message = Ch_VaArg(interp, ap, char *);
02966   hostname = Ch_VaArg(interp, ap, char *);
02967   port = Ch_VaArg(interp, ap, int);
02968   retval = MC_SendAgentMigrationMessage(temp_attr, message, hostname, port);
02969   Ch_VaEnd(interp, ap);
02970   free(temp_attr);
02971   return retval;
02972 } /*}}}*/
02973 
02974 /* MC_SendAgentMigrationMessageFile_chdl*/
02975 EXPORTCH int
02976 MC_SendAgentMigrationMessageFile_chdl(void *varg) /*{{{*/
02977 {
02978   MCAgency_t temp_attr;
02979   char *filename, *hostname;
02980   int port, retval;
02981   ChInterp_t interp;
02982   ChVaList_t ap;
02983 
02984   temp_attr = NULL;
02985 
02986   Ch_VaStart(interp, ap, varg);
02987   filename = Ch_VaArg(interp, ap, char *);
02988   hostname = Ch_VaArg(interp, ap, char *);
02989   port = Ch_VaArg(interp, ap, int);
02990   retval = MC_SendAgentMigrationMessageFile(temp_attr, filename, hostname, port);
02991   Ch_VaEnd(interp, ap);
02992   return retval;
02993 } /*}}}*/
02994 
02995 EXPORTCH int
02996 MC_SendSteerCommand_chdl(void *varg) /*{{{*/
02997 {
02998   MCAgency_t temp_attr;
02999   int retval;
03000   enum MC_SteerCommand_e command;
03001   extern mc_platform_p g_mc_platform;
03002   ChInterp_t interp;
03003   ChVaList_t ap;
03004 
03005   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
03006   CHECK_NULL(temp_attr, exit(-1));
03007   temp_attr->mc_platform = g_mc_platform;
03008 
03009   Ch_VaStart(interp, ap, varg);
03010   command = Ch_VaArg(interp, ap, enum MC_SteerCommand_e );
03011   retval = MC_SendSteerCommand(temp_attr, command);
03012   Ch_VaEnd(interp, ap);
03013   free(temp_attr);
03014   return retval;
03015 } /*}}}*/
03016 
03017 /* MC_SetAgentStatus_chdl */
03018 EXPORTCH int
03019 MC_SetAgentStatus_chdl(void *varg) /*{{{*/
03020 {
03021   MCAgent_t agent;
03022   int status;
03023   int ret;
03024   ChInterp_t interp;
03025   ChVaList_t ap;
03026 
03027   Ch_VaStart(interp, ap, varg);
03028   agent = Ch_VaArg(interp, ap, MCAgent_t);
03029   status = Ch_VaArg(interp, ap, int);
03030   ret = MC_SetAgentStatus(agent, status);
03031   Ch_VaEnd(interp, ap);
03032   return ret;
03033 } /*}}}*/
03034 
03035 /* MC_SetDefaultAgentStatus_chdl */
03036 EXPORTCH int
03037 MC_SetDefaultAgentStatus_chdl(void *varg) /*{{{*/
03038 {
03039   MCAgency_t temp_attr;
03040   extern mc_platform_p g_mc_platform;
03041   int status;
03042   int ret;
03043   ChInterp_t interp;
03044   ChVaList_t ap;
03045 
03046   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
03047   CHECK_NULL(temp_attr, exit(1););
03048   temp_attr->mc_platform = g_mc_platform;
03049 
03050   Ch_VaStart(interp, ap, varg);
03051   status = Ch_VaArg(interp, ap, int);
03052   ret = MC_SetDefaultAgentStatus(temp_attr, status);
03053   Ch_VaEnd(interp, ap);
03054   free(temp_attr);
03055   return ret;
03056 } /*}}}*/
03057 
03058 /* MC_SyncDelete_chdl*/
03059 EXPORTCH int
03060 MC_SyncDelete_chdl(void *varg) /*{{{*/
03061 {
03062   MCAgency_t temp_attr;
03063   extern mc_platform_p g_mc_platform;
03064   int retval;
03065   ChInterp_t interp;
03066   ChVaList_t ap;
03067   int id;
03068 
03069   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
03070   CHECK_NULL(temp_attr, exit(-1));
03071   temp_attr->mc_platform = g_mc_platform;
03072 
03073   Ch_VaStart(interp, ap, varg);
03074   id = Ch_VaArg(interp, ap, int);
03075   retval = MC_SyncDelete(temp_attr, id);
03076   Ch_VaEnd(interp, ap);
03077   free(temp_attr);
03078   return retval;
03079 } /*}}}*/
03080 
03081 /* MC_SyncInit_chdl*/
03082 EXPORTCH int
03083 MC_SyncInit_chdl(void *varg) /*{{{*/
03084 {
03085   MCAgency_t temp_attr;
03086   extern mc_platform_p g_mc_platform;
03087   int retval;
03088   ChInterp_t interp;
03089   ChVaList_t ap;
03090   int id;
03091 
03092   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
03093   CHECK_NULL(temp_attr, exit(-1));
03094   temp_attr->mc_platform = g_mc_platform;
03095 
03096   Ch_VaStart(interp, ap, varg);
03097   id = Ch_VaArg(interp, ap, int);
03098 
03099   retval = MC_SyncInit(temp_attr, id);
03100   Ch_VaEnd(interp, ap);
03101   free(temp_attr);
03102   return retval;
03103 } /*}}}*/
03104 
03105 /* MC_TerminateAgent_chdl */
03106 EXPORTCH int
03107 MC_TerminateAgent_chdl(void *varg) /*{{{*/
03108 {
03109   ChInterp_t interp;
03110   ChVaList_t ap;
03111   MCAgent_t agent;
03112   int retval;
03113 
03114   Ch_VaStart(interp, ap, varg);
03115   agent = Ch_VaArg(interp, ap, MCAgent_t);
03116   retval = MC_TerminateAgent(agent);
03117   Ch_VaEnd(interp, ap);
03118   return retval;
03119 } /*}}}*/
03120