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

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