Mobile-C: /home/dko/projects/mobilec/trunk/src/mc

00001 /* SVN FILE INFO
00002  * $Revision: 174 $ : Last Committed Revision
00003  * $Date: 2008-06-24 10:50:29 -0700 (Tue, 24 Jun 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 <sys/socket.h>
00038 #include <netdb.h>
00039 #include <netinet/in.h>
00040 #include <arpa/inet.h>
00041 #endif
00042 #include "include/acc.h"
00043 #include "include/mc_platform.h"
00044 
00045 #define DEFAULT_HOSTNAME_LENGTH 200
00046 mc_platform_p
00047 mc_platform_Initialize(MCAgency_t agency)
00048 {
00049   int i;
00050 #ifdef _WIN32 /* WinSock variables */
00051   WORD wVersionRequested = MAKEWORD(1,1);
00052   int nret;
00053 #endif
00054   struct hostent* localhost;
00055   char hostname[DEFAULT_HOSTNAME_LENGTH];
00056   mc_platform_p mc_platform;
00057   
00058   /* Allocate Memory */
00059   mc_platform = (mc_platform_p)malloc(sizeof(mc_platform_t));
00060   CHECK_NULL(mc_platform, agency->last_error = MC_ERR_MEMORY; return NULL);
00061 
00062   /* Initialize members */
00063   mc_platform->err = 0;
00064 #ifdef MC_SECURITY
00065   mc_platform->enable_security = agency->enable_security;
00066 #endif
00067   mc_platform->default_agentstatus = agency->default_agentstatus;
00068 
00069   for(i = 0; i < MC_THREAD_ALL; i++) {
00070     mc_platform->stack_size[i] = agency->stack_size[i];
00071   }
00072 
00073   /* WINDOWS ONLY: Initialize WinSock */
00074 #ifdef _WIN32
00075   nret = WSAStartup(wVersionRequested, &(mc_platform->wsaData));
00076   if (nret != 0) {
00077         printf("\nWSAStartup Error %d. %s:%d\n", nret, __FILE__,__LINE__);
00078         exit(0);
00079   }
00080   if (mc_platform->wsaData.wVersion != wVersionRequested) {
00081         printf("\nWrong Winsock Version %s:%d\n", __FILE__,__LINE__);
00082         exit(0);
00083   }
00084 #endif /* _WIN32 */
00085  
00086   gethostname(hostname, DEFAULT_HOSTNAME_LENGTH);
00087   if (strlen(hostname) < 1) {
00088           strcpy(hostname, "localhost");
00089   }
00090   localhost = gethostbyname(hostname); /* FIXME */
00091   if(localhost == NULL) {
00092 #ifdef _WIN32
00093           printf("Fatal Error: %d  %s:%d\n", WSAGetLastError(), __FILE__, __LINE__);
00094 #else
00095           fprintf(stderr, "Fatal Error %s:%d\n", __FILE__, __LINE__);
00096 #endif
00097           exit(0);
00098   }
00099 
00100   mc_platform->hostname = (char*)malloc(sizeof(char)*DEFAULT_HOSTNAME_LENGTH);
00101   CHECK_NULL(mc_platform->hostname, 
00102       agency->last_error = MC_ERR_MEMORY;return NULL);
00103   strcpy(mc_platform->hostname, inet_ntoa( *(struct in_addr*)localhost->h_addr) );
00104   mc_platform->hostname = realloc(
00105       mc_platform->hostname,
00106       sizeof(char) * (strlen(mc_platform->hostname)+1)
00107       );
00108   CHECK_NULL(mc_platform->hostname, 
00109       agency->last_error = MC_ERR_MEMORY;return NULL);
00110   
00111   mc_platform->port = agency->portno;
00112 
00113   mc_platform->interp_options = NULL;
00114 
00115 #ifdef MC_SECURITY
00116   if (agency->enable_security) {
00117     mc_platform->asm_message_queue = message_queue_New();
00118     mc_platform->asm_queue         = asm_queue_New();
00119   }
00120 #endif
00121   mc_platform->message_queue     = message_queue_New();
00122   mc_platform->agent_queue       = agent_queue_New();
00123   mc_platform->connection_queue  = connection_queue_New();
00124   
00125   mc_platform->syncList          = syncListInit();
00126   mc_platform->barrier_queue     = barrier_queue_New();
00127 
00128   /* Allocate sync variables */
00129   mc_platform->MC_signal_cond = (COND_T*)malloc(sizeof(COND_T));
00130   mc_platform->MC_sync_cond   = (COND_T*)malloc(sizeof(COND_T));
00131   mc_platform->MC_signal_lock = (MUTEX_T*)malloc(sizeof(MUTEX_T));
00132   mc_platform->MC_sync_lock   = (MUTEX_T*)malloc(sizeof(MUTEX_T));
00133   mc_platform->MC_steer_lock  = (MUTEX_T*)malloc(sizeof(MUTEX_T));
00134   mc_platform->MC_steer_cond  = (COND_T*)malloc(sizeof(COND_T));
00135 
00136   /* Check memory */
00137   CHECK_NULL( mc_platform->MC_signal_cond,
00138       agency->last_error = MC_ERR_MEMORY;return NULL );
00139   CHECK_NULL( mc_platform->MC_sync_cond  ,
00140       agency->last_error = MC_ERR_MEMORY;return NULL );
00141   CHECK_NULL( mc_platform->MC_signal_lock,
00142       agency->last_error = MC_ERR_MEMORY;return NULL );
00143   CHECK_NULL( mc_platform->MC_sync_lock  ,
00144       agency->last_error = MC_ERR_MEMORY;return NULL );
00145   CHECK_NULL( mc_platform->MC_steer_lock ,
00146       agency->last_error = MC_ERR_MEMORY;return NULL );
00147   CHECK_NULL( mc_platform->MC_steer_cond ,
00148       agency->last_error = MC_ERR_MEMORY;return NULL );
00149 
00150   /* Init sync variables */
00151   COND_INIT ( mc_platform->MC_signal_cond );
00152   COND_INIT ( mc_platform->MC_sync_cond );
00153   MUTEX_INIT( mc_platform->MC_signal_lock );
00154   MUTEX_INIT( mc_platform->MC_sync_lock );
00155   MUTEX_INIT( mc_platform->MC_steer_lock );
00156   COND_INIT ( mc_platform->MC_steer_cond );
00157 
00158   /* Initialize quit flag */
00159   mc_platform->quit = 0;
00160   mc_platform->quit_lock = (MUTEX_T*)malloc(sizeof(MUTEX_T));
00161   MUTEX_INIT(mc_platform->quit_lock);
00162 
00163   /* Initialize MC_signal flag */
00164   mc_platform->MC_signal = MC_NO_SIGNAL;
00165 
00166   /* Allocate and init giant lock */
00167   mc_platform->giant = 1;
00168   mc_platform->giant_lock = (MUTEX_T*)malloc(sizeof(MUTEX_T));
00169   CHECK_NULL(mc_platform->giant_lock,
00170       agency->last_error = MC_ERR_MEMORY;return NULL );
00171   mc_platform->giant_cond = (COND_T*)malloc(sizeof(COND_T));
00172   CHECK_NULL(mc_platform->giant_cond,
00173       agency->last_error = MC_ERR_MEMORY;return NULL );
00174 
00175   MUTEX_INIT( mc_platform->giant_lock );
00176   COND_INIT ( mc_platform->giant_cond );
00177 
00178   /* Initialize Agency Modules */
00179   mc_platform->df         = df_Initialize(mc_platform);
00180   mc_platform->ams        = ams_Initialize(mc_platform);
00181   mc_platform->acc        = acc_Initialize(mc_platform);
00182   mc_platform->cmd_prompt = cmd_prompt_Initialize(mc_platform);
00183 #ifdef MC_SECURITY
00184   if (agency->enable_security) {
00185     mc_platform->security_manager = asm_Initialize(mc_platform);
00186   }
00187 #endif
00188   if (GET_THREAD_MODE(agency->threads, MC_THREAD_DF)) {
00189     df_Start(mc_platform);
00190     MUTEX_LOCK(mc_platform->df->waiting_lock);
00191     /* Wait for the thread to fully initialize before continuing */
00192     while(mc_platform->df->waiting == 0) {
00193       COND_WAIT(mc_platform->df->waiting_cond, mc_platform->df->waiting_lock);
00194     }
00195     MUTEX_UNLOCK(mc_platform->df->waiting_lock);
00196   }
00197   if (GET_THREAD_MODE(agency->threads, MC_THREAD_AMS)) {
00198     ams_Start(mc_platform);
00199     MUTEX_LOCK(mc_platform->ams->waiting_lock);
00200     /* Wait for the thread to fully initialize before continuing */
00201     while(mc_platform->ams->waiting == 0) {
00202       COND_WAIT(mc_platform->ams->waiting_cond, mc_platform->ams->waiting_lock);
00203     }
00204     MUTEX_UNLOCK(mc_platform->ams->waiting_lock);
00205   }
00206   if (GET_THREAD_MODE(agency->threads, MC_THREAD_ACC)) {
00207     acc_Start(mc_platform);
00208     MUTEX_LOCK(mc_platform->acc->waiting_lock);
00209     /* Wait for the thread to fully initialize before continuing */
00210     while(mc_platform->acc->waiting == 0) {
00211       COND_WAIT(mc_platform->acc->waiting_cond, mc_platform->acc->waiting_lock);
00212     }
00213     MUTEX_UNLOCK(mc_platform->acc->waiting_lock);
00214   }
00215   if (GET_THREAD_MODE(agency->threads, MC_THREAD_CP))
00216     cmd_prompt_Start(mc_platform);
00217 #ifdef MC_SECURITY
00218   if (agency->enable_security) {
00219     asm_Start(mc_platform);
00220     MUTEX_LOCK(mc_platform->security_manager->waiting_lock);
00221     /* Wait for the thread to fully initialize before continuing */
00222     while(mc_platform->security_manager->waiting == 0) {
00223       COND_WAIT(
00224           mc_platform->security_manager->waiting_cond,
00225           mc_platform->security_manager->waiting_lock);
00226     }
00227     MUTEX_UNLOCK(mc_platform->security_manager->waiting_lock);
00228   }
00229 #endif
00230 
00231   return mc_platform;
00232 }
00233 
00234 int
00235 mc_platform_Destroy(mc_platform_p platform)
00236 {
00237 #ifdef MC_SECURITY
00238   if (platform->enable_security) {
00239     message_queue_Destroy(platform->asm_message_queue);
00240   }
00241 #endif
00242   message_queue_Destroy(platform->message_queue);
00243 
00244   agent_queue_Destroy(platform->agent_queue);
00245 
00246   connection_queue_Destroy(platform->connection_queue);
00247 
00248 #ifdef MC_SECURITY
00249   asm_queue_Destroy(platform->asm_queue);
00250 #endif
00251 
00252   df_Destroy(platform->df);
00253 
00254   ams_Destroy(platform->ams);
00255 
00256 #ifdef MC_SECURITY
00257   asm_Destroy(platform->security_manager);
00258 #endif
00259   
00260   acc_Destroy(platform->acc);
00261 
00262   cmd_prompt_Destroy(platform->cmd_prompt);
00263 
00264   /* FIXME: Destroy syncList and barrierList here */
00265   barrier_queue_Destroy(platform->barrier_queue);
00266 
00267   COND_DESTROY(platform->MC_signal_cond);
00268   free(platform->MC_signal_cond);
00269   COND_DESTROY(platform->MC_sync_cond);
00270   free(platform->MC_sync_cond);
00271   MUTEX_DESTROY(platform->MC_signal_lock);
00272   free(platform->MC_signal_lock);
00273   MUTEX_DESTROY(platform->MC_sync_lock);
00274   free(platform->MC_sync_lock);
00275 
00276   MUTEX_DESTROY(platform->MC_steer_lock);
00277   free(platform->MC_steer_lock);
00278   COND_DESTROY(platform->MC_steer_cond);
00279   free(platform->MC_steer_cond);
00280 
00281   MUTEX_DESTROY(platform->giant_lock);
00282   free(platform->giant_lock);
00283   COND_DESTROY(platform->giant_cond);
00284   free(platform->giant_cond);
00285 
00286   MUTEX_DESTROY(platform->quit_lock);
00287 
00288   /* Free up the interp options */
00289   if (platform->interp_options != NULL) {
00290     if (platform->interp_options->chhome != NULL) {
00291       free(platform->interp_options->chhome);
00292     }
00293     free(platform->interp_options);
00294   }
00295 
00296   free(platform);
00297   return MC_SUCCESS;
00298 }
00299 
00300   
00301
/home/dko/projects/mobilec/trunk/src/mc_platform.c
