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

00001 /* SVN FILE INFO
00002  * $Revision: 235 $ : Last Committed Revision
00003  * $Date: 2008-11-12 16:27:33 -0800 (Wed, 12 Nov 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   extern mc_platform_p g_mc_platform;
01451   buf = NULL;
01452   filestat.st_size = 0;
01453   stat(filename, &filestat);
01454   if (filestat.st_size != 0 ) {
01455     buf = malloc( sizeof(char) * (filestat.st_size+1) );
01456     memset(buf, 0, filestat.st_size+1);
01457   } else {
01458     fprintf(stderr, "Error: File %s not found.\n", filename);
01459     return 1;
01460   }
01461 
01462   fp = fopen(filename, "r");
01463   fread((void*)buf, filestat.st_size, 1, fp);
01464   fclose(fp);
01465 
01466   if (attr!=NULL) {
01467     message = message_New();
01468     if( 
01469         message_InitializeFromString
01470         (
01471          attr->mc_platform,
01472          message,
01473          buf,
01474          hostname,
01475          port,
01476          "ams"
01477         )
01478       )
01479     {
01480       message_Destroy(message);
01481     } else {
01482       ret = message_queue_Add
01483         (
01484          attr->mc_platform->message_queue,
01485          message 
01486         );
01487     }
01488   } else {
01489     message = message_New();
01490     if(
01491         message_InitializeFromString
01492         (
01493          g_mc_platform,
01494          message,
01495          buf,
01496          hostname,
01497          port,
01498          "ams"
01499         )
01500       )
01501     {
01502       message_Destroy(message);
01503     } else {
01504       ret = message_queue_Add
01505         (
01506          g_mc_platform->message_queue,
01507          message
01508         );
01509     }
01510   }
01511   free(buf);
01512   return ret;
01513 } /*}}}*/
01514 
01515 EXPORTMC int 
01516 MC_SendSteerCommand(MCAgency_t attr, enum MC_SteerCommand_e cmd) /*{{{*/
01517 {
01518   MUTEX_LOCK(attr->mc_platform->MC_steer_lock);
01519   attr->mc_platform->MC_steer_command = cmd;
01520   COND_BROADCAST(attr->mc_platform->MC_steer_cond);
01521   MUTEX_UNLOCK(attr->mc_platform->MC_steer_lock);
01522   return 0;
01523 } /*}}}*/
01524 
01525 int
01526 MC_SetAgentStatus(MCAgent_t agent, int status) /*{{{*/
01527 {
01528   MUTEX_LOCK(agent->lock);
01529   agent->agent_status = status;
01530   if (!agent->orphan) {
01531     MUTEX_LOCK(agent->mc_platform->ams->runflag_lock);
01532     agent->mc_platform->ams->run = 1;
01533     COND_SIGNAL(agent->mc_platform->ams->runflag_cond);
01534     MUTEX_UNLOCK(agent->mc_platform->ams->runflag_lock);
01535   }
01536   MUTEX_UNLOCK(agent->lock);
01537   return 0;
01538 } /*}}}*/
01539 
01540 int 
01541 MC_SetDefaultAgentStatus(/*{{{*/
01542     MCAgency_t agency,
01543     enum MC_AgentStatus_e status
01544     ) 
01545 {
01546   agency->mc_platform->default_agentstatus = status;
01547   return 0;
01548 } /*}}}*/
01549 
01550 EXPORTMC int 
01551 MC_SetThreadOn(MCAgencyOptions_t *options, enum MC_ThreadIndex_e index) /*{{{*/
01552 {
01553   SET_THREAD_ON(options->threads, index);
01554   return 0;
01555 } /*}}}*/
01556 
01557 EXPORTMC int 
01558 MC_SetThreadsAllOn(MCAgencyOptions_t* options)
01559 {
01560   int i;
01561   for(i = 0; i < MC_THREAD_ALL; i++) {
01562     SET_THREAD_ON(options->threads, i);
01563   }
01564   return 0;
01565 }
01566 
01567 EXPORTMC int
01568 MC_SetThreadOff(MCAgencyOptions_t *options, enum MC_ThreadIndex_e index) /*{{{*/
01569 {
01570   SET_THREAD_OFF(options->threads, index);
01571   return 0;
01572 } /*}}}*/
01573 
01574 EXPORTMC int
01575 MC_SetThreadsAllOff(MCAgencyOptions_t* options)
01576 {
01577   int i;
01578   for(i = 0; i < MC_THREAD_ALL; i++) {
01579     SET_THREAD_OFF(options->threads, i);
01580   }
01581   return 0;
01582 }
01583 
01584 EXPORTMC int 
01585 MC_Steer(                        /*{{{*/
01586     MCAgency_t attr,
01587     int (*funcptr)(void* data),
01588     void *arg
01589     )
01590 {
01591   MUTEX_LOCK(attr->mc_platform->MC_steer_lock);
01592   do {
01593     attr->mc_platform->MC_steer_command = MC_RUN;
01594     MUTEX_UNLOCK(attr->mc_platform->MC_steer_lock);
01595     (*funcptr)(arg);
01596   } while 
01597   (
01598    attr->mc_platform->MC_steer_command == MC_RESTART 
01599   );
01600   return 0;
01601 } /*}}}*/
01602 
01603 EXPORTMC enum MC_SteerCommand_e 
01604 MC_SteerControl(void) /*{{{*/
01605 {
01606   extern mc_platform_p g_mc_platform;
01607   /* Check to see what current command is */
01608   MUTEX_LOCK(g_mc_platform->MC_steer_lock);
01609   while (g_mc_platform->MC_steer_command == MC_SUSPEND) {
01610     COND_WAIT(
01611         g_mc_platform->MC_steer_cond,
01612         g_mc_platform->MC_steer_lock
01613         );
01614   }
01615   MUTEX_UNLOCK(g_mc_platform->MC_steer_lock);
01616   return g_mc_platform->MC_steer_command;
01617 } /*}}}*/
01618 
01619 EXPORTMC int 
01620 MC_SyncDelete(MCAgency_t attr, int id) /*{{{*/
01621 {
01622   syncListNode_t *sync_node;
01623   /* First, lock the entire list. */
01624   MUTEX_LOCK(attr->mc_platform->syncList->giant_lock);
01625 
01626   /* Find and lock the node */
01627   sync_node = syncListFind(id, attr->mc_platform->syncList);
01628   if (sync_node == NULL) {
01629     MUTEX_UNLOCK(attr->mc_platform->syncList->giant_lock);
01630     return MC_ERR_NOT_FOUND;
01631   }
01632   MUTEX_LOCK(sync_node->lock);
01633 
01634   /* Remove it from the list so it may no longer be used */
01635   if (syncListRemove(id, attr->mc_platform->syncList) == NULL) {
01636     fprintf(stderr, "Fatal error. %s:%d\n",
01637         __FILE__,
01638         __LINE__ );
01639     exit(0);
01640   }
01641 
01642   /* Now, unlock and destroy */
01643   MUTEX_UNLOCK(sync_node->lock);
01644   MUTEX_UNLOCK(attr->mc_platform->syncList->giant_lock);
01645 
01646   return syncListNodeDestroy(sync_node);
01647 } /*}}}*/
01648 
01649 EXPORTMC int
01650 MC_SyncInit(MCAgency_t attr, int id) /*{{{*/
01651 {
01652   syncListNode_t *node;
01653   node = syncListNodeNew();
01654   MUTEX_LOCK(attr->mc_platform->syncList->giant_lock);
01655   if (id == 0) {
01656     id = rand();
01657   }
01658   while (
01659       syncListFind(id, attr->mc_platform->syncList) != NULL
01660       ) 
01661   {
01662     id = rand();
01663   }
01664 
01665   node->id = id;
01666   syncListAddNode(
01667       node,
01668       attr->mc_platform->syncList
01669       );
01670   MUTEX_UNLOCK(attr->mc_platform->syncList->giant_lock);
01671   return id;
01672 }/*}}}*/
01673 
01674 EXPORTMC int 
01675 MC_TerminateAgent(MCAgent_t agent) /*{{{*/
01676 {
01677   int status=0;
01678   if(agent->agent_interp != NULL) {
01679     status = Ch_Abort (agent->agent_interp);
01680   }
01681   return status;
01682 } /*}}}*/
01683 
01684 
01685 #ifdef _WIN32
01686 EXPORTMC BOOL
01687 MC_MainLoop(MCAgency_t attr) /*{{{*/
01688 {
01689   /*    return CloseHandle(attr->global->gaf_ap->thread_id[attr->global->mr_index]); */
01690   Sleep (INFINITE);
01691   return 0;
01692 }
01693 #else
01694 int 
01695 MC_MainLoop(MCAgency_t attr) 
01696 {
01697   return pthread_join(attr->mc_platform->ams->thread, NULL);
01698 } /*}}}*/
01699 #endif
01700 
01701 EXPORTMC int
01702 MC_WaitAgent(MCAgency_t attr) /*{{{*/
01703 {
01704   int size;
01705   MUTEX_LOCK(attr->mc_platform->agent_queue->lock);
01706   while(1) {
01707     size = attr->mc_platform->agent_queue->size;
01708     COND_WAIT(
01709         attr->mc_platform->agent_queue->cond,
01710         attr->mc_platform->agent_queue->lock
01711         );
01712     if (size < attr->mc_platform->agent_queue->size) {
01713       MUTEX_UNLOCK(attr->mc_platform->agent_queue->lock);
01714       break;
01715     } 
01716   }
01717   MUTEX_UNLOCK(attr->mc_platform->agent_queue->lock);
01718   return 0;
01719 } /*}}}*/
01720 
01721 EXPORTMC MCAgent_t
01722 MC_WaitRetrieveAgent(MCAgency_t attr) /*{{{*/
01723 {
01724   int index;
01725   MCAgent_t agent;
01726   MC_WaitSignal(attr, MC_RECV_AGENT);
01727   MUTEX_LOCK(attr->mc_platform->agent_queue->lock);
01728   index = attr->mc_platform->agent_queue->size-1;
01729   agent = ListSearch(
01730       attr->mc_platform->agent_queue->list, index);
01731   MUTEX_UNLOCK(attr->mc_platform->agent_queue->lock);
01732   return agent;
01733 } /*}}}*/
01734 
01735 /* MC_WaitSignal */
01736 /* This function blocks until one of the signals in argument
01737  * 'signals' is signalled. 'signals' must be a binary | combination
01738  * of enum MC_Signal_e type. */
01739 EXPORTMC int
01740 MC_WaitSignal(MCAgency_t attr, int signals) /*{{{*/
01741 {
01742   MUTEX_LOCK(attr->mc_platform->MC_signal_lock);
01743   while(! (signals & attr->mc_platform->MC_signal)) {
01744     COND_WAIT(
01745         attr->mc_platform->MC_signal_cond,
01746         attr->mc_platform->MC_signal_lock
01747         );
01748   }
01749   MUTEX_UNLOCK(attr->mc_platform->MC_signal_lock);
01750   MUTEX_LOCK(attr->mc_platform->giant_lock);
01751   attr->mc_platform->giant = 0;
01752   MUTEX_UNLOCK(attr->mc_platform->giant_lock);
01753   return 0;
01754 } /*}}}*/
01755 
01756 /* *********************** *
01757  * Ch Space chdl functions *
01758  * *********************** */
01759 
01760 /* MC_AclDestroy */
01761 int MC_AclDestroy_chdl(void* varg)
01762 {
01763   int retval;
01764   fipa_acl_message_t* acl_message;
01765   ChInterp_t interp;
01766   ChVaList_t ap;
01767 
01768   Ch_VaStart(interp, ap, varg);
01769   acl_message = Ch_VaArg(interp, ap, fipa_acl_message_t*);
01770   retval = MC_AclDestroy(acl_message);
01771   Ch_VaEnd(interp, ap);
01772   return retval;
01773 }
01774 
01775 /* MC_AclNew */
01776 void* MC_AclNew_chdl(void* varg)
01777 {
01778   void* retval;
01779   retval = (void*)MC_AclNew();
01780   return retval;
01781 }
01782 
01783 /* MC_AclPost */
01784 int MC_AclPost_chdl(void* varg)
01785 {
01786   int retval;
01787   agent_p agent;
01788   fipa_acl_message_t* acl_message;
01789   ChInterp_t interp;
01790   ChVaList_t ap;
01791 
01792   Ch_VaStart(interp, ap, varg);
01793   agent = Ch_VaArg(interp, ap, agent_p);
01794   acl_message = Ch_VaArg(interp, ap, fipa_acl_message_t*);
01795   retval = MC_AclPost(agent, acl_message);
01796   Ch_VaEnd(interp, ap);
01797   return retval;
01798 }
01799 
01800 /* MC_AclReply */
01801 EXPORTCH void*
01802 MC_AclReply_chdl(void* varg)
01803 {
01804   void* retval;
01805   fipa_acl_message_t* acl_message;
01806   ChInterp_t interp;
01807   ChVaList_t ap;
01808 
01809   Ch_VaStart(interp, ap, varg);
01810   acl_message = Ch_VaArg(interp, ap, fipa_acl_message_t*);
01811   retval = (void*)MC_AclReply(acl_message);
01812   Ch_VaEnd(interp, ap);
01813   return retval;
01814 }
01815 
01816 /* MC_AclRetrieve */
01817 EXPORTCH void*
01818 MC_AclRetrieve_chdl(void* varg)
01819 {
01820   void* retval;
01821   MCAgent_t agent;
01822   ChInterp_t interp;
01823   ChVaList_t ap;
01824 
01825   Ch_VaStart(interp, ap, varg);
01826   agent = Ch_VaArg(interp, ap, MCAgent_t);
01827   retval = MC_AclRetrieve(agent);
01828   Ch_VaEnd(interp, ap);
01829   return retval;
01830 }
01831 
01832 /* MC_AclSend */
01833 EXPORTCH int
01834 MC_AclSend_chdl(void* varg)
01835 {
01836   int retval;
01837   fipa_acl_message_t* acl_message;
01838   MCAgency_t temp_attr;
01839   extern mc_platform_p g_mc_platform;
01840 
01841   ChInterp_t interp;
01842   ChVaList_t ap;
01843 
01844   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
01845   CHECK_NULL(temp_attr, exit(-1));
01846   temp_attr->mc_platform = g_mc_platform;
01847 
01848   Ch_VaStart(interp, ap, varg);
01849   acl_message = (fipa_acl_message_t*) Ch_VaArg(interp, ap, void*);
01850   retval = MC_AclSend(temp_attr, acl_message);
01851   Ch_VaEnd(interp, ap);
01852   free(temp_attr);
01853   return retval;
01854 }
01855 
01856 /* MC_AclWaitRetrieve */
01857 EXPORTCH void*
01858 MC_AclWaitRetrieve_chdl(void *varg)
01859 {
01860   void* retval;
01861   MCAgent_t agent;
01862   ChInterp_t interp;
01863   ChVaList_t ap;
01864 
01865   Ch_VaStart(interp, ap, varg);
01866   agent = Ch_VaArg(interp, ap, MCAgent_t);
01867   retval = MC_AclWaitRetrieve(agent);
01868   Ch_VaEnd(interp, ap);
01869   return retval;
01870 }
01871 
01872 /* BEGIN Acl helper functions */
01873 
01874 /* MC_AclSetPerformative */
01875 EXPORTCH int
01876 MC_AclSetPerformative_chdl(void* varg)
01877 {
01878   ChInterp_t interp;
01879   ChVaList_t ap;
01880   struct fipa_acl_message_s* acl;
01881   enum fipa_performative_e performative;
01882   int retval;
01883 
01884   Ch_VaStart(interp, ap, varg);
01885   acl = Ch_VaArg(interp, ap, struct fipa_acl_message_s*);
01886   performative = Ch_VaArg(interp, ap, enum fipa_performative_e);
01887   retval = MC_AclSetPerformative(acl, performative);
01888   Ch_VaEnd(interp, ap);
01889   return retval;
01890 }
01891 
01892 /* MC_AclSetSender */
01893 EXPORTCH int
01894 MC_AclSetSender_chdl(void* varg)
01895 {
01896   ChInterp_t interp;
01897   ChVaList_t ap;
01898   struct fipa_acl_message_s* acl;
01899   char* name;
01900   char* address;
01901   int retval;
01902 
01903   Ch_VaStart(interp, ap, varg);
01904   acl = Ch_VaArg(interp, ap, struct fipa_acl_message_s*);
01905   name = Ch_VaArg(interp, ap, char*);
01906   address = Ch_VaArg(interp, ap, char*);
01907   retval = MC_AclSetSender(acl, name, address);
01908   Ch_VaEnd(interp, ap);
01909   return retval;
01910 }
01911 
01912 /* MC_AclAddReceiver */
01913 EXPORTCH int
01914 MC_AclAddReceiver_chdl(void* varg)
01915 {
01916   ChInterp_t interp;
01917   ChVaList_t ap;
01918   struct fipa_acl_message_s* acl;
01919   char* name;
01920   char* address;
01921   int retval;
01922 
01923   Ch_VaStart(interp, ap, varg);
01924   acl = Ch_VaArg(interp, ap, struct fipa_acl_message_s*);
01925   name = Ch_VaArg(interp, ap, char*);
01926   address = Ch_VaArg(interp, ap, char*);
01927   retval = MC_AclAddReceiver(acl, name, address);
01928   Ch_VaEnd(interp, ap);
01929   return retval;
01930 }
01931 
01932 /* MC_AclAddReplyTo */
01933 EXPORTCH int
01934 MC_AclAddReplyTo_chdl(void* varg)
01935 {
01936   ChInterp_t interp;
01937   ChVaList_t ap;
01938   struct fipa_acl_message_s* acl;
01939   char* name;
01940   char* address;
01941   int retval;
01942 
01943   Ch_VaStart(interp, ap, varg);
01944   acl = Ch_VaArg(interp, ap, struct fipa_acl_message_s*);
01945   name = Ch_VaArg(interp, ap, char*);
01946   address = Ch_VaArg(interp, ap, char*);
01947   retval = MC_AclAddReplyTo(acl, name, address);
01948   Ch_VaEnd(interp, ap);
01949   return retval;
01950 }
01951 
01952 /* MC_AclSetContent */
01953 EXPORTCH int
01954 MC_AclSetContent_chdl(void* varg)
01955 {
01956   ChInterp_t interp;
01957   ChVaList_t ap;
01958   struct fipa_acl_message_s* acl;
01959   char* content;
01960   int retval;
01961 
01962   Ch_VaStart(interp, ap, varg);
01963   acl = Ch_VaArg(interp, ap, struct fipa_acl_message_s*);
01964   content = Ch_VaArg(interp, ap, char*);
01965   retval = MC_AclSetContent(acl, content);
01966   Ch_VaEnd(interp, ap);
01967   return retval;
01968 }
01969 
01970 /* END Acl Helper Functions */
01971 
01972 /* MC_AddAgent */
01973 EXPORTCH int
01974 MC_AddAgent_chdl(void *varg) /*{{{*/
01975 {
01976   int retval;
01977   MCAgent_t agent;
01978   MCAgency_t temp_attr;
01979   extern mc_platform_p g_mc_platform;
01980 
01981   ChInterp_t interp;
01982   ChVaList_t ap;
01983 
01984   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
01985   CHECK_NULL(temp_attr, exit(-1));
01986   temp_attr->mc_platform = g_mc_platform;
01987 
01988   Ch_VaStart(interp, ap, varg);
01989   agent = (MCAgent_t) Ch_VaArg(interp, ap, void*);
01990   retval = MC_AddAgent(temp_attr, agent);
01991   Ch_VaEnd(interp, ap);
01992   free(temp_attr);
01993   return retval;
01994 } /*}}}*/
01995 
01996 /* MC_AgentVariableRetrieve */
01997 EXPORTCH const void*
01998 MC_AgentVariableRetrieve_chdl(void* varg)
01999 {
02000   void* retval;
02001   MCAgent_t agent;
02002   const char* var_name;
02003   int task_num;
02004 
02005   ChInterp_t interp;
02006   ChVaList_t ap;
02007 
02008   Ch_VaStart(interp, ap, varg);
02009 
02010   agent = Ch_VaArg(interp, ap, MCAgent_t);
02011   var_name = Ch_VaArg(interp, ap, const char* );
02012   task_num = Ch_VaArg(interp, ap, int);
02013 
02014   retval = MC_AgentVariableRetrieve(agent, var_name, task_num);
02015 
02016   Ch_VaEnd(interp, ap);
02017   return retval;
02018 }
02019 
02020 /* MC_AgentVariableSave */
02021 EXPORTCH int
02022 MC_AgentVariableSave_chdl(void *varg)
02023 {
02024   int retval;
02025   MCAgent_t agent;
02026   const char* var_name;
02027 
02028   ChInterp_t interp;
02029   ChVaList_t ap;
02030 
02031   Ch_VaStart(interp, ap, varg);
02032 
02033   agent = Ch_VaArg(interp, ap, MCAgent_t);
02034   var_name = Ch_VaArg(interp, ap, const char*);
02035 
02036   retval = MC_AgentVariableSave(agent, var_name);
02037 
02038   Ch_VaEnd(interp, ap);
02039   return retval;
02040 }
02041 
02042 /* MC_CallAgentFunc */
02043 EXPORTCH int
02044 MC_CallAgentFunc_chdl(void *varg) /*{{{*/
02045 {
02046   int retval;
02047   /* Function Args */
02048   MCAgent_t agent;
02049   const char* funcName;
02050   void* returnVal;
02051   ChVaList_t args;
02052 
02053   ChInterp_t interp;
02054   ChVaList_t ap;
02055 
02056   Ch_VaStart(interp, ap, varg);
02057 
02058   agent =     Ch_VaArg(interp, ap, MCAgent_t);
02059   funcName =  Ch_VaArg(interp, ap, const char*);
02060   returnVal = Ch_VaArg(interp, ap, void*);
02061   args =      Ch_VaArg(interp, ap, void*);
02062 
02063   retval = MC_CallAgentFuncVar(
02064       agent,
02065       funcName,
02066       returnVal,
02067       args);
02068   Ch_VaEnd(interp, ap);
02069   return retval;
02070 } /*}}}*/
02071 
02072 /* MC_Barrier_chdl*/
02073 EXPORTCH int
02074 MC_Barrier_chdl(void *varg) /*{{{*/
02075 {
02076   MCAgency_t temp_attr;
02077   extern mc_platform_p g_mc_platform;
02078   int retval;
02079   ChInterp_t interp;
02080   ChVaList_t ap;
02081   int id;
02082 
02083   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02084   CHECK_NULL(temp_attr, exit(-1));
02085   temp_attr->mc_platform = g_mc_platform;
02086 
02087   Ch_VaStart(interp, ap, varg);
02088   id = Ch_VaArg(interp, ap, int);
02089   retval = MC_Barrier(temp_attr, id);
02090   Ch_VaEnd(interp, ap);
02091   free(temp_attr);
02092   return retval;
02093 } /*}}}*/
02094 
02095 /* MC_BarrierDelete_chdl*/
02096 EXPORTCH int
02097 MC_BarrierDelete_chdl(void *varg) /*{{{*/
02098 {
02099   MCAgency_t temp_attr;
02100   extern mc_platform_p g_mc_platform;
02101   int retval;
02102   ChInterp_t interp;
02103   ChVaList_t ap;
02104   int id;
02105 
02106   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02107   CHECK_NULL(temp_attr, exit(-1));
02108   temp_attr->mc_platform = g_mc_platform;
02109 
02110   Ch_VaStart(interp, ap, varg);
02111   id = Ch_VaArg(interp, ap, int);
02112   retval = MC_BarrierDelete(temp_attr, id);
02113   Ch_VaEnd(interp, ap);
02114   free(temp_attr);
02115   return retval;
02116 } /*}}}*/
02117 
02118 /* MC_BarrierInit_chdl*/
02119 EXPORTCH int
02120 MC_BarrierInit_chdl(void *varg) /*{{{*/
02121 {
02122   MCAgency_t temp_attr;
02123   extern mc_platform_p g_mc_platform;
02124   int retval;
02125   ChInterp_t interp;
02126   ChVaList_t ap;
02127   int id;
02128   int num_procs;
02129 
02130   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02131   CHECK_NULL(temp_attr, exit(-1));
02132   temp_attr->mc_platform = g_mc_platform;
02133 
02134   Ch_VaStart(interp, ap, varg);
02135   id = Ch_VaArg(interp, ap, int);
02136   num_procs = Ch_VaArg(interp, ap, int);
02137   retval = MC_BarrierInit(temp_attr, id, num_procs);
02138   Ch_VaEnd(interp, ap);
02139   free(temp_attr);
02140   return retval;
02141 } /*}}}*/
02142 
02143 /* MC_CondBroadcast_chdl*/
02144 EXPORTCH int
02145 MC_CondBroadcast_chdl(void *varg) /*{{{*/
02146 {
02147   MCAgency_t temp_attr;
02148   extern mc_platform_p g_mc_platform;
02149   int retval;
02150   ChInterp_t interp;
02151   ChVaList_t ap;
02152   int id;
02153 
02154   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02155   CHECK_NULL(temp_attr, exit(-1));
02156   temp_attr->mc_platform = g_mc_platform;
02157 
02158   Ch_VaStart(interp, ap, varg);
02159   id = Ch_VaArg(interp, ap, int);
02160   retval = MC_CondBroadcast(temp_attr, id);
02161   Ch_VaEnd(interp, ap);
02162   free(temp_attr);
02163   return retval;
02164 } /*}}}*/
02165 
02166 /* MC_ComposeAgent */
02167 EXPORTCH MCAgent_t 
02168 MC_ComposeAgent_chdl(void *varg) /*{{{*/
02169 {
02170   MCAgent_t retval;
02171 
02172   /* Function Args */
02173   const char* name;
02174   const char* home;
02175   const char* owner;  
02176   const char* code;
02177   const char* return_var_name;
02178   const char* server;
02179   int persistent;
02180 
02181   ChInterp_t interp;
02182   ChVaList_t ap;
02183 
02184   Ch_VaStart(interp, ap, varg);
02185 
02186   name  = Ch_VaArg(interp, ap, const char*);
02187   home  = Ch_VaArg(interp, ap, const char*);
02188   owner = Ch_VaArg(interp, ap, const char*);
02189   code = Ch_VaArg(interp, ap, const char*);
02190   return_var_name = Ch_VaArg(interp, ap, const char*);
02191   server = Ch_VaArg(interp, ap, const char*);
02192   persistent = Ch_VaArg(interp, ap, int);
02193 
02194   retval= MC_ComposeAgent(
02195       name,
02196       home,
02197       owner,
02198       code,
02199       return_var_name,
02200       server,
02201       persistent);
02202   Ch_VaEnd(interp, ap);
02203   return retval;
02204 } /*}}}*/
02205 
02206 /* MC_CondSignal_chdl*/
02207 EXPORTCH int
02208 MC_CondSignal_chdl(void *varg) /*{{{*/
02209 {
02210   MCAgency_t temp_attr;
02211   extern mc_platform_p g_mc_platform;
02212   int retval;
02213   ChInterp_t interp;
02214   ChVaList_t ap;
02215   int id;
02216 
02217   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02218   CHECK_NULL(temp_attr, exit(-1));
02219   temp_attr->mc_platform = g_mc_platform;
02220 
02221   Ch_VaStart(interp, ap, varg);
02222   id = Ch_VaArg(interp, ap, int);
02223   retval = MC_CondSignal(temp_attr, id);
02224   Ch_VaEnd(interp, ap);
02225   free(temp_attr);
02226   return retval;
02227 } /*}}}*/
02228 
02229 /* MC_CondReset_chdl*/
02230 EXPORTCH int
02231 MC_CondReset_chdl(void *varg) /*{{{*/   
02232 {
02233   MCAgency_t temp_attr;
02234   extern mc_platform_p g_mc_platform;
02235   int retval;
02236   ChInterp_t interp;
02237   ChVaList_t ap;
02238   int id;
02239 
02240   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02241   CHECK_NULL(temp_attr, exit(-1));
02242   temp_attr->mc_platform = g_mc_platform;
02243 
02244   Ch_VaStart(interp, ap, varg);
02245   id = Ch_VaArg(interp, ap, int);
02246   retval = MC_CondReset(temp_attr, id);
02247   Ch_VaEnd(interp, ap);
02248   free(temp_attr);
02249   return retval;
02250 } /*}}}*/
02251 
02252 /* MC_CondWait_chdl*/
02253 EXPORTCH int
02254 MC_CondWait_chdl(void *varg) /*{{{*/
02255 {
02256   MCAgency_t temp_attr;
02257   extern mc_platform_p g_mc_platform;
02258   int retval;
02259   ChInterp_t interp;
02260   ChVaList_t ap;
02261   int id;
02262 
02263   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02264   CHECK_NULL(temp_attr, exit(-1));
02265   temp_attr->mc_platform = g_mc_platform;
02266 
02267   Ch_VaStart(interp, ap, varg);
02268   id = Ch_VaArg(interp, ap, int);
02269   retval = MC_CondWait(temp_attr, id);
02270   Ch_VaEnd(interp, ap);
02271   free(temp_attr);
02272   return retval;
02273 } /*}}}*/
02274 
02275 EXPORTCH int
02276 MC_DeleteAgent_chdl(void *varg) /*{{{*/
02277 {
02278   ChInterp_t interp;
02279   ChVaList_t ap;
02280   MCAgent_t agent;
02281   int retval;
02282 
02283   Ch_VaStart(interp, ap, varg);
02284   agent = Ch_VaArg(interp, ap, MCAgent_t);
02285   retval = MC_DeleteAgent(agent);
02286   Ch_VaEnd(interp, ap);
02287   return retval;
02288 } /*}}}*/
02289 
02290 EXPORTCH int
02291 MC_DestroyServiceSearchResult_chdl(void* varg)
02292 {
02293   ChInterp_t interp;
02294   ChVaList_t ap;
02295   char** agentName;
02296   char** serviceName;
02297   int* agentID;
02298   int numResult;
02299   int retval;
02300 
02301   Ch_VaStart(interp, ap, varg);
02302   agentName = Ch_VaArg(interp, ap, char**);
02303   serviceName = Ch_VaArg(interp, ap, char**);
02304   agentID = Ch_VaArg(interp, ap, int*);
02305   numResult = Ch_VaArg(interp, ap, int);
02306 
02307   retval = MC_DestroyServiceSearchResult(
02308       agentName,
02309       serviceName,
02310       agentID,
02311       numResult );
02312   Ch_VaEnd(interp, ap);
02313   return retval;
02314 }
02315 
02316 /* MC_DeregisterService_chdl */
02317 EXPORTCH int
02318 MC_DeregisterService_chdl(void *varg) /*{{{*/
02319 {
02320   ChInterp_t interp;
02321   ChVaList_t ap;
02322   MCAgency_t temp_attr;
02323   extern mc_platform_p g_mc_platform;
02324   int agentID;
02325   char *serviceName;
02326   int retval;
02327 
02328   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02329   CHECK_NULL(temp_attr, exit(-1));
02330   temp_attr->mc_platform = g_mc_platform;
02331 
02332   Ch_VaStart(interp, ap, varg);
02333   agentID = Ch_VaArg(interp, ap, int);
02334   serviceName = (char*)Ch_VaArg(interp, ap, const char*);
02335   retval = MC_DeregisterService(
02336       temp_attr,
02337       agentID,
02338       serviceName );
02339   Ch_VaEnd(interp, ap);
02340   free(temp_attr);
02341   return retval;
02342 } /*}}}*/
02343 
02344 EXPORTCH int
02345 MC_End_chdl(void *varg) /* {{{ */
02346 {
02347   MCAgency_t temp_attr;
02348   extern mc_platform_p g_mc_platform;
02349   int retval;
02350 
02351   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02352   CHECK_NULL(temp_attr, exit(-1));
02353   temp_attr->mc_platform = g_mc_platform;
02354 
02355   retval = MC_End(temp_attr);
02356 
02357   return retval;
02358 } /* }}} */
02359 
02360 /* MC_FindAgentByID_chdl*/
02361 EXPORTCH MCAgent_t
02362 MC_FindAgentByID_chdl(void *varg) /*{{{*/
02363 {
02364   MCAgency_t temp_attr;
02365   extern mc_platform_p g_mc_platform;
02366   MCAgent_t retval;
02367   ChInterp_t interp;
02368   ChVaList_t ap;
02369   int id;
02370 
02371   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02372   CHECK_NULL(temp_attr, exit(-1));
02373   temp_attr->mc_platform = g_mc_platform;
02374 
02375   Ch_VaStart(interp, ap, varg);
02376   id = Ch_VaArg(interp, ap, int);
02377   retval = MC_FindAgentByID(temp_attr, id);
02378   Ch_VaEnd(interp, ap);
02379   free(temp_attr);
02380   return retval;
02381 } /*}}}*/
02382 
02383 /* MC_FindAgentByName_chdl*/
02384 EXPORTCH MCAgent_t
02385 MC_FindAgentByName_chdl(void *varg) /*{{{*/
02386 {
02387   MCAgency_t temp_attr;
02388   extern mc_platform_p g_mc_platform;
02389   MCAgent_t retval;
02390   ChInterp_t interp;
02391   ChVaList_t ap;
02392   const char *name;
02393 
02394   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02395   CHECK_NULL(temp_attr, exit(-1));
02396   temp_attr->mc_platform = g_mc_platform;
02397 
02398   Ch_VaStart(interp, ap, varg);
02399   name = Ch_VaArg(interp, ap, const char *);
02400   retval = MC_FindAgentByName(temp_attr, name);
02401   Ch_VaEnd(interp, ap);
02402   free(temp_attr);
02403   return retval;
02404 } /*}}}*/
02405 
02406 /* MC_GetAgentArrivalTime */
02407 #ifndef _WIN32
02408 EXPORTCH time_t
02409 #else
02410 EXPORTCH SYSTEMTIME
02411 #endif
02412 MC_GetAgentArrivalTime_chdl(void *varg) /*{{{*/
02413 {
02414   MCAgent_t agent;
02415   ChInterp_t interp;
02416   ChVaList_t ap;
02417 #ifndef _WIN32
02418   time_t arrival_time;
02419 #else
02420   SYSTEMTIME arrival_time;
02421 #endif
02422 
02423   Ch_VaStart(interp, ap, varg);
02424   agent = Ch_VaArg(interp, ap, MCAgent_t);
02425   arrival_time = MC_GetAgentArrivalTime(agent);
02426   Ch_VaEnd(interp, ap);
02427   return arrival_time;
02428 } /* }}} */
02429 
02430 /* MC_GetAgentID */
02431 EXPORTCH int
02432 MC_GetAgentID_chdl(void *varg) /*{{{*/
02433 {
02434   MCAgent_t agent;
02435   ChInterp_t interp;
02436   ChVaList_t ap;
02437   int id;
02438 
02439   Ch_VaStart(interp, ap, varg);
02440   agent = Ch_VaArg(interp, ap, MCAgent_t);
02441   id = MC_GetAgentID(agent);
02442   Ch_VaEnd(interp, ap);
02443   return id;
02444 } /*}}}*/
02445 
02446 /* MC_GetAgentName */
02447 EXPORTCH char*
02448 MC_GetAgentName_chdl(void *varg) /*{{{*/
02449 {
02450   MCAgent_t agent;
02451   ChInterp_t interp;
02452   ChVaList_t ap;
02453   char* name;
02454 
02455   Ch_VaStart(interp, ap, varg);
02456   agent = Ch_VaArg(interp, ap, MCAgent_t);
02457   name = MC_GetAgentName(agent);
02458   Ch_VaEnd(interp, ap);
02459   return name;
02460 } /*}}}*/
02461 
02462 /* MC_GetAgentNumTasks_chdl */
02463 EXPORTCH int
02464 MC_GetAgentNumTasks_chdl(void *varg)
02465 {
02466   MCAgent_t agent;
02467   ChInterp_t interp;
02468   ChVaList_t ap;
02469   int num_tasks;
02470 
02471   Ch_VaStart(interp, ap, varg);
02472   agent = Ch_VaArg(interp, ap, MCAgent_t);
02473   num_tasks = MC_GetAgentNumTasks(agent);
02474   Ch_VaEnd(interp, ap);
02475   return num_tasks;
02476 }
02477 
02478 /* MC_GetAgentStatus_chdl */
02479 EXPORTCH int
02480 MC_GetAgentStatus_chdl(void *varg) /*{{{*/
02481 {
02482   MCAgent_t agent;
02483   int status;
02484   ChInterp_t interp;
02485   ChVaList_t ap;
02486 
02487   Ch_VaStart(interp, ap, varg);
02488   agent = Ch_VaArg(interp, ap, MCAgent_t);
02489   status = MC_GetAgentStatus(agent);
02490   Ch_VaEnd(interp, ap);
02491   return status;
02492 } /*}}}*/
02493 
02494 /* MC_GetAgentXMLString_chdl */
02495 EXPORTCH char *
02496 MC_GetAgentXMLString_chdl(void *varg) /*{{{*/
02497 {
02498   ChInterp_t interp;
02499   ChVaList_t ap;
02500   MCAgent_t agent;
02501   char *retval;
02502 
02503   Ch_VaStart(interp, ap, varg);
02504   agent = Ch_VaArg(interp, ap, MCAgent_t);
02505   retval = MC_GetAgentXMLString(agent);
02506   Ch_VaEnd(interp, ap);
02507   return retval;
02508 } /*}}}*/
02509 
02510 #ifndef _WIN32
02511 EXPORTCH int
02512 MC_GetTimeOfDay_chdl(void *varg)
02513 {
02514   ChInterp_t interp;
02515   ChVaList_t ap;
02516   struct timeval *tv;
02517   Ch_VaStart(interp, ap, varg);
02518   tv = Ch_VaArg(interp, ap, struct timeval*);
02519   gettimeofday(tv, NULL);
02520   Ch_VaEnd(interp, ap);
02521   return 0;
02522 }
02523 #endif
02524 
02525 /* MC_HaltAgency_chdl */
02526 EXPORTCH int
02527 MC_HaltAgency_chdl(void *varg)
02528 {
02529   MCAgency_t temp_attr;
02530   int retval;
02531   extern mc_platform_p g_mc_platform;
02532 
02533   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02534   CHECK_NULL(temp_attr, exit(-1));
02535   temp_attr->mc_platform = g_mc_platform;
02536 
02537   retval = MC_HaltAgency(temp_attr);
02538 
02539   free(temp_attr);
02540   return retval;
02541 }
02542 
02543 /* MC_MutexLock_chdl */
02544 EXPORTCH int
02545 MC_MutexLock_chdl(void *varg) /*{{{*/
02546 {
02547   MCAgency_t temp_attr;
02548   extern mc_platform_p g_mc_platform;
02549 
02550   ChInterp_t interp;
02551   ChVaList_t ap;
02552   int id;
02553   int retval;
02554 
02555   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02556   CHECK_NULL(temp_attr, exit(-1));
02557   temp_attr->mc_platform = g_mc_platform;
02558 
02559   Ch_VaStart(interp, ap, varg);
02560   id = Ch_VaArg(interp, ap, int );
02561   retval = MC_MutexLock(temp_attr, id);
02562   Ch_VaEnd(interp, ap);
02563   free(temp_attr);
02564   return retval;
02565 } /*}}}*/
02566 
02567 /* MC_MutexUnlock_chdl */
02568 EXPORTCH int
02569 MC_MutexUnlock_chdl(void *varg) /*{{{*/
02570 {
02571   MCAgency_t temp_attr;
02572   extern mc_platform_p g_mc_platform;
02573 
02574   ChInterp_t interp;
02575   ChVaList_t ap;
02576   int id;
02577   int retval;
02578 
02579   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02580   CHECK_NULL(temp_attr, exit(-1));
02581   temp_attr->mc_platform = g_mc_platform;
02582 
02583   Ch_VaStart(interp, ap, varg);
02584   id = Ch_VaArg(interp, ap, int );
02585   retval = MC_MutexUnlock(temp_attr, id);
02586   Ch_VaEnd(interp, ap);
02587   free(temp_attr);
02588   return retval;
02589 } /*}}}*/
02590 
02591 /* MC_PrintAgentCode_chdl */
02592 EXPORTCH int
02593 MC_PrintAgentCode_chdl(void *varg) /*{{{*/
02594 {
02595   ChInterp_t interp;
02596   ChVaList_t ap;
02597   MCAgent_t agent;
02598   int retval;
02599 
02600   Ch_VaStart(interp, ap, varg);
02601   agent = Ch_VaArg(interp, ap, MCAgent_t);
02602   retval = MC_PrintAgentCode(agent);
02603   Ch_VaEnd(interp, ap);
02604   return retval;
02605 } /*}}}*/
02606 
02607 /* MC_RegisterService_chdl */
02608 EXPORTCH int
02609 MC_RegisterService_chdl(void *varg) /*{{{*/
02610 {
02611   ChInterp_t interp;
02612   ChVaList_t ap;
02613   int retval;
02614   MCAgency_t temp_attr;
02615   extern mc_platform_p g_mc_platform;
02616 
02617   /* varg arguments */
02618   MCAgent_t agent;
02619   char **serviceNames;
02620   int numServices;
02621 
02622   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02623   CHECK_NULL(temp_attr, exit(-1));
02624   temp_attr->mc_platform = g_mc_platform;
02625 
02626   Ch_VaStart(interp, ap, varg);
02627   agent = Ch_VaArg(interp, ap, MCAgent_t);
02628   serviceNames = Ch_VaArg(interp, ap, char **);
02629   numServices = Ch_VaArg(interp, ap, int);
02630 
02631   retval = MC_RegisterService(
02632       temp_attr,      /* agency */
02633       agent,          /* agent */ 
02634       0,              /* agent id */
02635       NULL,           /* agent name */
02636       serviceNames,   /* services */
02637       numServices
02638       );
02639   Ch_VaEnd(interp, ap);
02640   free(temp_attr);
02641   return retval;
02642 } /*}}}*/
02643 
02644 /* MC_ResumeAgency_chdl */
02645 EXPORTCH int
02646 MC_ResumeAgency_chdl(void *varg)
02647 {
02648   MCAgency_t temp_attr;
02649   int retval;
02650   extern mc_platform_p g_mc_platform;
02651 
02652   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02653   CHECK_NULL(temp_attr, exit(-1));
02654   temp_attr->mc_platform = g_mc_platform;
02655 
02656   retval = MC_ResumeAgency(temp_attr);
02657 
02658   free(temp_attr);
02659   return retval;
02660 }
02661 
02662 /* MC_RetrieveAgent_chdl */
02663 EXPORTCH MCAgent_t
02664 MC_RetrieveAgent_chdl(void *varg) /*{{{*/
02665 {
02666   MCAgency_t temp_attr;
02667   extern mc_platform_p g_mc_platform;
02668   MCAgent_t agent;
02669 
02670   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02671   CHECK_NULL(temp_attr, exit(-1));
02672   temp_attr->mc_platform = g_mc_platform;
02673 
02674   agent = MC_RetrieveAgent(temp_attr);
02675   free(temp_attr);
02676   return agent;
02677 } /*}}}*/
02678 
02679 /* MC_RetrieveAgentCode_chdl */
02680 EXPORTCH char *
02681 MC_RetrieveAgentCode_chdl(void *varg) /*{{{*/
02682 {
02683   ChInterp_t interp;
02684   ChVaList_t ap;
02685   MCAgent_t agent;
02686   char *retval;
02687 
02688   Ch_VaStart(interp, ap, varg);
02689   agent = Ch_VaArg(interp, ap, MCAgent_t);
02690   retval = MC_RetrieveAgentCode(agent);
02691   Ch_VaEnd(interp, ap);
02692   return retval;
02693 } /*}}}*/
02694 
02695 /* MC_SaveData_chdl */
02696 EXPORTCH int
02697 MC_SaveData_chdl(void* varg)
02698 {
02699   ChInterp_t interp;
02700   ChVaList_t ap;
02701   interpreter_variable_data_p interp_var_data;
02702   MCAgent_t agent;
02703   int progress;
02704   const char* name;
02705   int size;
02706   void* data;
02707   
02708   Ch_VaStart(interp, ap, varg);
02709   agent = Ch_VaArg(interp, ap, MCAgent_t);
02710   name = Ch_VaArg(interp, ap, char*);
02711   size = Ch_VaArg(interp, ap, int);
02712   data = Ch_VaArg(interp, ap, void*);
02713 
02714   progress = agent->datastate->task_progress;
02715 
02716   interp_var_data = interpreter_variable_data_New();
02717   interp_var_data->name = strdup(name);
02718   interp_var_data->size = size;
02719   interp_var_data->data_type = CH_VOIDPTRTYPE;
02720   interp_var_data->data = malloc(size);
02721   memcpy(interp_var_data->data, data, size);
02722 
02723   agent_variable_list_Add(
02724       agent->datastate->tasks[progress]->agent_variable_list,
02725       interp_var_data );
02726 
02727   return 0;
02728 }
02729 
02730 /* MC_SearchForService_chdl */
02731 EXPORTCH int
02732 MC_SearchForService_chdl(void *varg) /*{{{*/
02733 {
02734   ChInterp_t interp;
02735   ChVaList_t ap;
02736   int retval;
02737   MCAgency_t temp_attr;
02738   extern mc_platform_p g_mc_platform;
02739 
02740   /* Args */
02741   const char* searchString;
02742   char*** agentNames;
02743   char*** serviceNames;
02744   int** agentIDs;
02745   int* numResults;
02746 
02747   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02748   CHECK_NULL(temp_attr, exit(-1));
02749   temp_attr->mc_platform = g_mc_platform;
02750 
02751   Ch_VaStart(interp, ap, varg);
02752   searchString = Ch_VaArg(interp, ap, const char*);
02753   agentNames = Ch_VaArg(interp, ap, char***);
02754   serviceNames = Ch_VaArg(interp, ap, char***);
02755   agentIDs = Ch_VaArg(interp, ap, int**);
02756   numResults = Ch_VaArg(interp, ap, int*);
02757 
02758   retval = MC_SearchForService(
02759       temp_attr,
02760       searchString,
02761       agentNames,
02762       serviceNames,
02763       agentIDs,
02764       numResults
02765       );
02766   Ch_VaEnd(interp, ap);
02767   free(temp_attr);
02768   return retval;
02769 } /*}}}*/
02770 
02771 /* MC_SemaphorePost_chdl */
02772 EXPORTCH int
02773 MC_SemaphorePost_chdl(void *varg) /*{{{*/
02774 {
02775   MCAgency_t temp_attr;
02776   extern mc_platform_p g_mc_platform;
02777 
02778   ChInterp_t interp;
02779   ChVaList_t ap;
02780   int id;
02781   int retval;
02782 
02783   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02784   CHECK_NULL(temp_attr, exit(-1));
02785   temp_attr->mc_platform = g_mc_platform;
02786 
02787   Ch_VaStart(interp, ap, varg);
02788   id = Ch_VaArg(interp, ap, int );
02789   retval = MC_SemaphorePost(temp_attr, id);
02790   Ch_VaEnd(interp, ap);
02791   free(temp_attr);
02792   return retval;
02793 } /*}}}*/
02794 
02795 /* MC_SemaphoreWait_chdl */
02796 EXPORTCH int 
02797 MC_SemaphoreWait_chdl(void *varg) /*{{{*/
02798 {   
02799   MCAgency_t temp_attr;
02800   extern mc_platform_p g_mc_platform;
02801 
02802   ChInterp_t interp;
02803   ChVaList_t ap;
02804   int id;
02805   int retval;
02806 
02807   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02808   CHECK_NULL(temp_attr, exit(-1));
02809   temp_attr->mc_platform = g_mc_platform;
02810 
02811   Ch_VaStart(interp, ap, varg);
02812   id = Ch_VaArg(interp, ap, int );
02813   retval = MC_SemaphoreWait(temp_attr, id);
02814   Ch_VaEnd(interp, ap);
02815   free(temp_attr);
02816   return retval;
02817 } /*}}}*/
02818 
02819 /* MC_SendAgentMigrationMessage_chdl*/
02820 EXPORTCH int
02821 MC_SendAgentMigrationMessage_chdl(void *varg) /*{{{*/
02822 {
02823   MCAgency_t temp_attr;
02824   extern mc_platform_p g_mc_platform;
02825   const char *message, *hostname;
02826   int port, retval;
02827   ChInterp_t interp;
02828   ChVaList_t ap;
02829 
02830   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02831   CHECK_NULL(temp_attr, exit(-1));
02832   temp_attr->mc_platform = g_mc_platform;
02833 
02834   Ch_VaStart(interp, ap, varg);
02835   message = Ch_VaArg(interp, ap, char *);
02836   hostname = Ch_VaArg(interp, ap, char *);
02837   port = Ch_VaArg(interp, ap, int);
02838   retval = MC_SendAgentMigrationMessage(temp_attr, message, hostname, port);
02839   Ch_VaEnd(interp, ap);
02840   free(temp_attr);
02841   return retval;
02842 } /*}}}*/
02843 
02844 /* MC_SendAgentMigrationMessageFile_chdl*/
02845 EXPORTCH int
02846 MC_SendAgentMigrationMessageFile_chdl(void *varg) /*{{{*/
02847 {
02848   MCAgency_t temp_attr;
02849   char *filename, *hostname;
02850   int port, retval;
02851   ChInterp_t interp;
02852   ChVaList_t ap;
02853 
02854   temp_attr = NULL;
02855 
02856   Ch_VaStart(interp, ap, varg);
02857   filename = Ch_VaArg(interp, ap, char *);
02858   hostname = Ch_VaArg(interp, ap, char *);
02859   port = Ch_VaArg(interp, ap, int);
02860   retval = MC_SendAgentMigrationMessageFile(temp_attr, filename, hostname, port);
02861   Ch_VaEnd(interp, ap);
02862   return retval;
02863 } /*}}}*/
02864 
02865 EXPORTCH int
02866 MC_SendSteerCommand_chdl(void *varg) /*{{{*/
02867 {
02868   MCAgency_t temp_attr;
02869   int retval;
02870   enum MC_SteerCommand_e command;
02871   extern mc_platform_p g_mc_platform;
02872   ChInterp_t interp;
02873   ChVaList_t ap;
02874 
02875   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02876   CHECK_NULL(temp_attr, exit(-1));
02877   temp_attr->mc_platform = g_mc_platform;
02878 
02879   Ch_VaStart(interp, ap, varg);
02880   command = Ch_VaArg(interp, ap, enum MC_SteerCommand_e );
02881   retval = MC_SendSteerCommand(temp_attr, command);
02882   Ch_VaEnd(interp, ap);
02883   free(temp_attr);
02884   return retval;
02885 } /*}}}*/
02886 
02887 /* MC_SetAgentStatus_chdl */
02888 EXPORTCH int
02889 MC_SetAgentStatus_chdl(void *varg) /*{{{*/
02890 {
02891   MCAgent_t agent;
02892   int status;
02893   int ret;
02894   ChInterp_t interp;
02895   ChVaList_t ap;
02896 
02897   Ch_VaStart(interp, ap, varg);
02898   agent = Ch_VaArg(interp, ap, MCAgent_t);
02899   status = Ch_VaArg(interp, ap, int);
02900   ret = MC_SetAgentStatus(agent, status);
02901   Ch_VaEnd(interp, ap);
02902   return ret;
02903 } /*}}}*/
02904 
02905 /* MC_SetDefaultAgentStatus_chdl */
02906 EXPORTCH int
02907 MC_SetDefaultAgentStatus_chdl(void *varg) /*{{{*/
02908 {
02909   MCAgency_t temp_attr;
02910   extern mc_platform_p g_mc_platform;
02911   int status;
02912   int ret;
02913   ChInterp_t interp;
02914   ChVaList_t ap;
02915 
02916   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02917   CHECK_NULL(temp_attr, exit(1););
02918   temp_attr->mc_platform = g_mc_platform;
02919 
02920   Ch_VaStart(interp, ap, varg);
02921   status = Ch_VaArg(interp, ap, int);
02922   ret = MC_SetDefaultAgentStatus(temp_attr, status);
02923   Ch_VaEnd(interp, ap);
02924   free(temp_attr);
02925   return ret;
02926 } /*}}}*/
02927 
02928 /* MC_SyncDelete_chdl*/
02929 EXPORTCH int
02930 MC_SyncDelete_chdl(void *varg) /*{{{*/
02931 {
02932   MCAgency_t temp_attr;
02933   extern mc_platform_p g_mc_platform;
02934   int retval;
02935   ChInterp_t interp;
02936   ChVaList_t ap;
02937   int id;
02938 
02939   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02940   CHECK_NULL(temp_attr, exit(-1));
02941   temp_attr->mc_platform = g_mc_platform;
02942 
02943   Ch_VaStart(interp, ap, varg);
02944   id = Ch_VaArg(interp, ap, int);
02945   retval = MC_SyncDelete(temp_attr, id);
02946   Ch_VaEnd(interp, ap);
02947   free(temp_attr);
02948   return retval;
02949 } /*}}}*/
02950 
02951 /* MC_SyncInit_chdl*/
02952 EXPORTCH int
02953 MC_SyncInit_chdl(void *varg) /*{{{*/
02954 {
02955   MCAgency_t temp_attr;
02956   extern mc_platform_p g_mc_platform;
02957   int retval;
02958   ChInterp_t interp;
02959   ChVaList_t ap;
02960   int id;
02961 
02962   temp_attr = (MCAgency_t)malloc(sizeof(struct agency_s));
02963   CHECK_NULL(temp_attr, exit(-1));
02964   temp_attr->mc_platform = g_mc_platform;
02965 
02966   Ch_VaStart(interp, ap, varg);
02967   id = Ch_VaArg(interp, ap, int);
02968 
02969   retval = MC_SyncInit(temp_attr, id);
02970   Ch_VaEnd(interp, ap);
02971   free(temp_attr);
02972   return retval;
02973 } /*}}}*/
02974 
02975 /* MC_TerminateAgent_chdl */
02976 EXPORTCH int
02977 MC_TerminateAgent_chdl(void *varg) /*{{{*/
02978 {
02979   ChInterp_t interp;
02980   ChVaList_t ap;
02981   MCAgent_t agent;
02982   int retval;
02983 
02984   Ch_VaStart(interp, ap, varg);
02985   agent = Ch_VaArg(interp, ap, MCAgent_t);
02986   retval = MC_TerminateAgent(agent);
02987   Ch_VaEnd(interp, ap);
02988   return retval;
02989 } /*}}}*/
02990