int swapConfigFile()
{
//Crea Logs
t_log *errorLogger, *traceLogger;
traceLogger = log_create("LogTraceUMC.txt","UMCConfigFile",true,LOG_LEVEL_TRACE);
errorLogger = log_create("LogErroresUMC.txt","UMCConfigFile",true,LOG_LEVEL_ERROR);
//Declaracion de Variables
t_config *ptrConfig, *ptrConfigUpdate;
SwapConfigFile *ptrvaloresConfigFile;
ptrvaloresConfigFile = NULL;
ptrvaloresConfigFile = malloc(sizeof(SwapConfigFile));
ptrConfigUpdate = NULL;
//Se asigna a ptrConfig el archivo de configuracion. Si no lo encuentra, finaliza
//y lo advierte en el log
ptrConfig = config_create("/home/utnso/workspace/SwapConfigFile/Debug/config.txt");
if (ptrConfig == NULL){
log_error(errorLogger,"Archivo de configuración no disponible. No puede ejecutar el UMC.\n");
return EXIT_FAILURE;
} else {
log_trace(traceLogger,"Iniciando Proceso UMC.\n");
}
//El procedimiento carga los valores del Config File en las variables creadas
levantaConfigFileEnVariables(ptrvaloresConfigFile,ptrConfig);
log_trace(traceLogger,"Archivo de Configuracion levantado exitosamente.\n");
printf("%d\n\n", ptrvaloresConfigFile->puerto_escucha);
while (1)
{
huboUnCambio=0;
detectaCambiosEnConfigFile();
if (huboUnCambio)
{
ptrConfigUpdate = config_create("/home/utnso/workspace/SwapConfigFile/Debug/config.txt");
if(ptrConfigUpdate->properties->elements_amount==0) {
log_error(errorLogger,"No se puede levantar el Archivo de Configuracion.\n");
} else {
levantaConfigFileEnVariables(ptrvaloresConfigFile, ptrConfigUpdate);
printf("%d\n\n", ptrvaloresConfigFile->puerto_escucha);
log_trace(traceLogger,"Archivo de Configuracion actualizado y levantado.\n");
}
config_destroy(ptrConfigUpdate);
}
}
printf("%s\n\n", ptrvaloresConfigFile->nombre_swap);
liberaVariables(traceLogger, ptrConfig, errorLogger);
free(ptrvaloresConfigFile);
return EXIT_SUCCESS;
}; //Fin de Main
int leerArchivoConfiguracion(char *ruta_archivo) {
int devolver = 0;
config = config_create(ruta_archivo);
printf("Leyendo archivo de configuraciones: %s\n", ruta_archivo);
PUERTO_ESCUCHA = config_get_int_value(config, "PUERTO_ESCUCHA");
IP_SWAP = config_get_string_value(config, "IP_SWAP");
PUERTO_SWAP = config_get_int_value(config, "PUERTO_SWAP");
MAXIMO_MARCOS_POR_PROCESO=config_get_int_value(config,"MAXIMO_MARCOS_POR_PROCESO");
CANTIDAD_MARCOS=config_get_int_value(config,"CANTIDAD_MARCOS");
TAMANIO_MARCO=config_get_int_value(config,"TAMANIO_MARCOS");
ENTRADAS_TLB=config_get_int_value(config,"ENTRADAS_TLB");
TLB_HABILITADA=config_get_string_value(config,"TLB_HABILITADA");
RETARDO=config_get_int_value(config,"RETARDO");
printf("Puerto de la Memoria que escucha: %d\n", PUERTO_ESCUCHA);
printf("IP del Swap: %s\n", IP_SWAP);
printf("Puerto del Swap: %d\n", PUERTO_SWAP);
printf("Cantidad maxima de marcos por proceso: %d\n", MAXIMO_MARCOS_POR_PROCESO);
printf("Cantidad de Marcos: %d\n", CANTIDAD_MARCOS);
printf("Tamanio de cada marco: %d\n", TAMANIO_MARCO);
printf("Cantidad de entradas TLB: %d\n", ENTRADAS_TLB);
printf("TLB habilitada: %s\n", TLB_HABILITADA);
printf("Tiempo de retardo: %d\n", RETARDO);
puts("Listo.\n");
return devolver;
}
test_result_t test_parse_invalid(test_data_t data)
{
test_config_data_t *test_data = (test_config_data_t *)data;
test_result_t result = PASS;
unsigned line = 0;
unsigned col = 0;
config_t config = {0};
int ret = 0;
printf("%s\n", test_data->desc);
DEBUG_PRINT("%s\n", test_data->str);
config_create(&config);
ret = config_parse(&config, test_data->str, &line, &col);
if ((ret != test_data->parse_ret) || (line != test_data->parse_line) || (col != test_data->parse_col))
{
result = FAIL;
}
DEBUG_PRINT("config_parse returned: %d, '%s', line: %d, col: %d\n", ret, config_strerr(ret), line, col);
config_destroy(&config);
return result;
}
int main(int argc, char *argv[]) {
jobConfig = config_create(FILE_CONFIG);
logger = log_create(FILE_LOG, "JOB", true, LOG_LEVEL_TRACE);
pthread_mutex_init(&mutex_log, NULL);
signal(SIGCHLD, SIG_IGN);
//sem_t sem;
sem_init(&sem, 0, 0);
//test conexion con marta
conectar_con_marta();
log_trace(logger, "FIN TODO");
/* cleanup semaphores */
sem_destroy (&sem);
//desconecto al nodo
/*int socket = client_socket("192.168.1.37", 6001);
t_msg* msg = argv_message(-1, 0);
enviar_mensaje(socket, msg);
destroy_message(msg);
close(socket);*/
//finalizo el programa para que no intente conectar con el nodo
log_destroy(logger);
config_destroy(jobConfig);
return EXIT_SUCCESS;
}
/**
* Run the daemon.
* @param cfgfile: the config file name.
* @param cmdline_verbose: verbosity resulting from commandline -v.
* These increase verbosity as specified in the config file.
* @param debug_mode: if set, do not daemonize.
* @param log_default_identity: Default identity to report in logs
*/
static void
run_daemon(const char* cfgfile, int cmdline_verbose, int debug_mode, const char* log_default_identity)
{
struct config_file* cfg = NULL;
struct daemon* daemon = NULL;
int done_setup = 0;
if(!(daemon = daemon_init()))
fatal_exit("alloc failure");
while(!daemon->need_to_exit) {
if(done_setup)
verbose(VERB_OPS, "Restart of %s.", PACKAGE_STRING);
else verbose(VERB_OPS, "Start of %s.", PACKAGE_STRING);
/* config stuff */
if(!(cfg = config_create()))
fatal_exit("Could not alloc config defaults");
if(!config_read(cfg, cfgfile, daemon->chroot)) {
if(errno != ENOENT)
fatal_exit("Could not read config file: %s",
cfgfile);
log_warn("Continuing with default config settings");
}
apply_settings(daemon, cfg, cmdline_verbose, debug_mode, log_default_identity);
if(!done_setup)
config_lookup_uid(cfg);
/* prepare */
if(!daemon_open_shared_ports(daemon))
fatal_exit("could not open ports");
if(!done_setup) {
perform_setup(daemon, cfg, debug_mode, &cfgfile);
done_setup = 1;
} else {
/* reopen log after HUP to facilitate log rotation */
if(!cfg->use_syslog)
log_init(cfg->logfile, 0, cfg->chrootdir);
}
/* work */
daemon_fork(daemon);
/* clean up for restart */
verbose(VERB_ALGO, "cleanup.");
daemon_cleanup(daemon);
config_delete(cfg);
}
verbose(VERB_ALGO, "Exit cleanup.");
/* this unlink may not work if the pidfile is located outside
* of the chroot/workdir or we no longer have permissions */
if(daemon->pidfile) {
int fd;
/* truncate pidfile */
fd = open(daemon->pidfile, O_WRONLY | O_TRUNC, 0644);
if(fd != -1)
close(fd);
/* delete pidfile */
unlink(daemon->pidfile);
}
daemon_delete(daemon);
}
/** go ahead and read config, contact server and perform command and display */
static int
go(const char* cfgfile, char* svr, int argc, char* argv[])
{
struct config_file* cfg;
int fd, ret;
SSL_CTX* ctx;
SSL* ssl;
/* read config */
if(!(cfg = config_create()))
fatal_exit("out of memory");
if(!config_read(cfg, cfgfile, NULL))
fatal_exit("could not read config file");
if(!cfg->remote_control_enable)
log_warn("control-enable is 'no' in the config file.");
ctx = setup_ctx(cfg);
/* contact server */
fd = contact_server(svr, cfg, argc>0&&strcmp(argv[0],"status")==0);
ssl = setup_ssl(ctx, fd);
/* send command */
ret = go_cmd(ssl, argc, argv);
SSL_free(ssl);
#ifndef USE_WINSOCK
close(fd);
#else
closesocket(fd);
#endif
SSL_CTX_free(ctx);
config_delete(cfg);
return ret;
}
void initFileSystem()
{
logFile = log_create("./FileSystem.log","FileSystem", true, LOG_LEVEL_TRACE);
pthread_mutex_init(&mLogFile, NULL);
t_config* archivoConfig = config_create("./FileSystem.config");
PUERTO_LISTEN = config_get_int_value(archivoConfig, "PUERTO_LISTEN");
char* tmp = config_get_string_value(archivoConfig, "IP_LISTEN");
strcpy(IP_LISTEN,tmp);
free(tmp);
LISTA_NODOS = config_get_int_value(archivoConfig, "LISTA_NODOS");
//config_destroy(archivoConfig);
listaArchivos = list_create();
pthread_mutex_init(&mListaArchivos, NULL);
listaDirs = list_create();
pthread_mutex_init(&mListaDirs, NULL);
t_reg_directorio* raiz = malloc(sizeof(t_reg_directorio));
strcpy(raiz->directorio, "\0");
raiz->padre = -1;
list_add(listaDirs, raiz);
initConsola();
initComandos();
initConexiones();
leerPersistencia();
}
void obtenerDatosAlgorimo(informacion_planificacion_t* datosAlgoritmo) {
t_config* conF = config_create(CONFIG_PATH);
if (config_has_property(conF, "Nombre")) {
datosAlgoritmo->nombreNivel = malloc(
strlen(config_get_string_value(conF, "Nombre")) + 1);
strcpy(datosAlgoritmo->nombreNivel,
config_get_string_value(conF, "Nombre"));
}
if (config_has_property(conF, "algoritmo")) {
char* algoritmo = config_get_string_value(conF, "algoritmo");
datosAlgoritmo->algoritmo =
strcmp("RR", algoritmo) == 0 ? ROUND_ROBIN : SRDF;
}
if (config_has_property(conF, "quantum")) {
datosAlgoritmo->quantum = config_get_int_value(conF, "quantum");
}
if (config_has_property(conF, "retardo")) {
datosAlgoritmo->retardo = config_get_int_value(conF, "retardo");
}
config_destroy(conF);
}
char *config_get(const char *section, const char *name, const char *default_value)
{
struct config_value *cv;
debug(D_CONFIG, "request to get config in section '%s', name '%s', default_value '%s'", section, name, default_value);
pthread_rwlock_rdlock(&config_rwlock);
struct config *co = config_find_section(section);
if(!co) co = config_create(section);
cv = config_value_index_find(co, name, 0);
if(!cv) {
cv = config_value_create(co, name, default_value);
if(!cv) return NULL;
}
cv->flags |= CONFIG_VALUE_USED;
if((cv->flags & CONFIG_VALUE_LOADED) || (cv->flags & CONFIG_VALUE_CHANGED)) {
// this is a loaded value from the config file
// if it is different that the default, mark it
if(!(cv->flags & CONFIG_VALUE_CHECKED)) {
if(strcmp(cv->value, default_value) != 0) cv->flags |= CONFIG_VALUE_CHANGED;
cv->flags |= CONFIG_VALUE_CHECKED;
}
}
pthread_rwlock_unlock(&config_rwlock);
return(cv->value);
}
const char *config_set(const char *section, const char *name, const char *value)
{
struct config_value *cv;
debug(D_CONFIG, "request to set config in section '%s', name '%s', value '%s'", section, name, value);
pthread_rwlock_wrlock(&config_rwlock);
struct config *co = config_find_section(section);
if(!co) co = config_create(section);
cv = config_value_index_find(co, name, 0);
if(!cv) cv = config_value_create(co, name, value);
cv->flags |= CONFIG_VALUE_USED;
if(strcmp(cv->value, value) != 0) cv->flags |= CONFIG_VALUE_CHANGED;
free(cv->value);
cv->value = strdup(value);
if(!cv->value) fatal("Cannot allocate config.value");
pthread_rwlock_unlock(&config_rwlock);
return value;
}
int leerConfiguracion(char *ruta, datosConfiguracion **datos) {
t_config* archivoConfiguracion = config_create(ruta);//Crea struct de configuracion
if (archivoConfiguracion == NULL) {
return 0;
} else {
int cantidadKeys = config_keys_amount(archivoConfiguracion);
if (cantidadKeys < 7) {
return 0;
} else {
(*datos)->puerto = buscarInt(archivoConfiguracion, "PUERTO");
char* nombreSwap=string_new();
string_append(&nombreSwap,config_get_string_value(archivoConfiguracion, "NOMBRE_SWAP"));
(*datos)->nombre_swap =nombreSwap;
(*datos)->cantidadPaginas = buscarInt(archivoConfiguracion, "CANTIDAD_PAGINAS");
(*datos)->tamPagina = buscarInt(archivoConfiguracion, "TAMANIO_PAGINA");
(*datos)->retardoAcceso = buscarInt(archivoConfiguracion, "RETARDO_ACCESO");
(*datos)->retardoCompactacion = buscarInt(archivoConfiguracion, "RETARDO_COMPACTACION");
char* ip=string_new();
string_append(&ip,config_get_string_value(archivoConfiguracion,"IP"));
(*datos)->ip=ip;
config_destroy(archivoConfiguracion);
return 1;
}
}
}
t_param_plat leer_archivo_plataforma_config() {
t_config* config;
t_param_plat param;
log_in_disk_plat(LOG_LEVEL_TRACE,
"comienzo lectura archivo de configuracion plataforma en el %s ",
PATH_CONFIG_PLATAFORMA);
config = config_create(PATH_CONFIG_PLATAFORMA);
param.PUERTO = config_get_int_value(config, "PUERTO");
param.SEGUNDOS_ESPERA = config_get_double_value(config, "SEGUNDOS_ESPERA");
param.CUANTUM = config_get_int_value(config, "CUANTUM");
log_in_disk_plat(LOG_LEVEL_TRACE,
"Parametros planificador puerto %d segundos de planificacions %.2f cuantum %d ",
param.PUERTO, param.SEGUNDOS_ESPERA, param.CUANTUM);
//param.planificador_nivel = config_get_array_value(config, "planDeNiveles");
//solo entro en el loop si el mivel de log es LOG_LEVEL_TRACE
// if (LOG_LEVEL_TRACE == 0) {
// int i = 0;
// while (param.planificador_nivel[i] != '\0') {
// log_in_disk_plat(LOG_LEVEL_TRACE, "Niveles de planificador %s ",
// param.planificador_nivel[i]);
// i++;
// }
// }
return param;
}
tipoConfigSWAP* cargarArchivoDeConfiguracionDeSWAP(char* rutaDelArchivoDeConfiguracion){
t_config* archivoCfg = config_create(rutaDelArchivoDeConfiguracion);
tipoConfigSWAP* cfg = crearConfigSWAP();
validarErrorYAbortar(config_has_property(archivoCfg,PUERTO_ESCUCHA)
&& config_has_property(archivoCfg,NOMBRE_SWAP)
&& config_has_property(archivoCfg,CANTIDAD_PAGINAS)
&& config_has_property(archivoCfg,TAMANIO_PAGINA)
&& config_has_property(archivoCfg,RETARDO_COMPACTACION),
"Las claves del archivo de configuracion no coinciden con las que requiere el SWAP");
cfg->puertoDeEscucha = config_get_int_value(archivoCfg,PUERTO_ESCUCHA);
cfg->nombreDeSWAP = string_duplicate(config_get_string_value(archivoCfg,NOMBRE_SWAP));
cfg->cantidadDePaginas = config_get_int_value(archivoCfg,CANTIDAD_PAGINAS);
cfg->retardoDeCompactacion = config_get_int_value(archivoCfg,RETARDO_COMPACTACION);
cfg->tamanioDePagina = config_get_int_value(archivoCfg,TAMANIO_PAGINA);
config_destroy(archivoCfg);
return cfg;
}
void init(){
LOGGER = log_create(LOG_PATH, "MaRTA", true, LOG_LEVEL_DEBUG);
CONF = config_create(CONF_PATH); //HACK estaba mal el nombre de la funcion o no la encontraba o no se
if(LOGGER == NULL){
perror("ERROR! no pudo levantar ni el log!");
exit(EXIT_FAILURE);
}
if(CONF == NULL){
log_error(LOGGER, "\nERROR AL LEVANTAR ARCHIVO DE CONFIGURACION\n( Don't PANIC! Si estas por consola ejecuta: ln -s ../%s %s )\n\n"
, CONF_PATH
, CONF_PATH);
exit(EXIT_FAILURE);
}
// if(!validarConfig()){ //HACK no lo necesitaba, no entendi el codigo del map y no me servia, anda :P
// log_error(LOGGER, "No pudo obtenerse alguno de los parametros de configuracion");
// exit(EXIT_FAILURE);
// }
mapa_nodos = dictionary_create();
lista_jobs = list_create();
pthread_mutex_init(&mutex_mapa_nodos, NULL);
pthread_mutex_init(&mutex_lista_jobs, NULL);
log_info(LOGGER, "intenta conectarse a la ip %s con puerto %d", config_get_string_value(CONF, "IP_FS"), config_get_int_value(CONF, "PUERTO_FS"));
socketFS = conectarAServidor(config_get_string_value(CONF, "IP_FS"), config_get_int_value(CONF, "PUERTO_FS"));
while (socketFS == -1) {
log_info(LOGGER, "Filesystem no levantado. Se reintenta conexion en unos segundos");
sleep(5);
socketFS = conectarAServidor(config_get_string_value(CONF, "IP_FS"), config_get_int_value(CONF, "PUERTO_FS"));
}
header_t header;
initHeader(&header);
header.tipo = MARTA_TO_FS_HANDSHAKE;
header.largo_mensaje = 0;
header.cantidad_paquetes = 1;
log_info(LOGGER, "Conectado a FS! envio header %s", getDescription(header.tipo));
enviar_header(socketFS, &header);
t_mensaje mensaje;
memset(&mensaje, 0, sizeof(t_mensaje));
recibir_t_mensaje(socketFS, &mensaje);
log_info(LOGGER, "recibo respuesta %s de FS", getDescription(mensaje.tipo));
while(mensaje.tipo != ACK){
log_info(LOGGER, "Todavia el FS no esta disponible. Header recibido: %s. Reintento en 5 segundos", getDescription(header.tipo));
sleep(5);
enviar_header(socketFS, &header);
recibir_t_mensaje(socketFS, &mensaje);
}
recibirNodosFS();
log_info(LOGGER, "%s: FS está operativo. Continúo", getDescription(header.tipo));
}
void leerConfiguracion(void){
t_config* config=config_create(PATH_config);
configuracion_programa.ip_kernel = config_get_string_value(config,"Direccion IP para conectarse al Kernel");
configuracion_programa.puerto_kernel = config_get_int_value(config,"Puerto TCP para recibir conexiones del Kernel");
}
void inicializar_CPU(char *path, uint32_t *retardo) {
t_config* config = config_create(path);
*retardo = config_get_int_value(config,"RETARDO");
uint16_t puertoMSP = config_get_int_value(config,"PUERTO_MSP");
char *direccionIpMSP = config_get_string_value(config,"IP_MSP");
uint16_t puertoKernel = config_get_int_value(config,"PUERTO_KERNEL");
char *direccionIpKernel = config_get_string_value(config,"IP_KERNEL");
if((Kernel = client_socket(direccionIpKernel, puertoKernel)) < 0) {
puts("ERROR: No se pudo conectar al Kernel.");
exit(EXIT_FAILURE);
}
t_msg *handshake = id_message(CPU_CONNECT);
enviar_mensaje(Kernel, handshake);
destroy_message(handshake);
if((MSP = client_socket(direccionIpMSP, puertoMSP)) < 0) {
puts("ERROR: No se pudo conectar a la MSP.");
exit(EXIT_FAILURE);
}
config_destroy(config);
MapRegistros['A'-'A'] = &Registros.registros_programacion[0];
MapRegistros['B'-'A'] = &Registros.registros_programacion[1];
MapRegistros['C'-'A'] = &Registros.registros_programacion[2];
MapRegistros['D'-'A'] = &Registros.registros_programacion[3];
MapRegistros['E'-'A'] = &Registros.registros_programacion[4];
MapRegistros['K'-'A'] = &Registros.K;
MapRegistros['I'-'A'] = &Registros.I;
MapRegistros['M'-'A'] = &Registros.M;
MapRegistros['P'-'A'] = &Registros.P;
MapRegistros['S'-'A'] = &Registros.S;
MapRegistros['X'-'A'] = &Registros.X;
inicializar_tabla_instrucciones();
}
void levantarArchivoConfiguracionPlataforma() {
t_config *config;
config = config_create(PATH_CONFIG_PLATAFORMA);
if (config->properties->elements_amount == 0) {
printf("\nERROR AL LEVANTAR ARCHIVO DE CONFIGURACION %s \n", PATH_CONFIG_PLATAFORMA);
perror("\nERROR AL LEVANTAR ARCHIVO DE CONFIGURACION\n( Don't PANIC! Si estas por consola ejecuta: ln -s ../plataforma.conf plataforma.conf )\n\n");
config_destroy(config);
exit(-1);
}
//Levanto los parametros necesarios para el planificador
configPlat.PUERTO = config_get_int_value(config, "PUERTO");
strcpy(configPlat.KOOPA, config_get_string_value(config, "KOOPA"));
strcpy(configPlat.SCRIPT, config_get_string_value(config, "SCRIPT"));
strcpy(configPlat.FILESYSTEM, config_get_string_value(config, "FILESYSTEM"));
configPlat.SLEEP_KOOPA = config_get_int_value(config, "SLEEP_KOOPA");
configPlat.RD = config_get_int_value(config, "RD");
strcpy(configPlat.LOG_PATH, config_get_string_value(config, "LOG_PATH"));
configPlat.LOG_NIVEL = obtenerLogLevel( config_get_string_value(config, "LOG_NIVEL"));
configPlat.LOG_CONSOLA = config_get_int_value(config, "LOG_CONSOLA");
// Una vez que se levantaron los datos del archivo de configuracion
// puedo/debo destruir la estructura config.
config_destroy(config);
}
tipoConfigCPU* cargarArchivoDeConfiguracionDeCPU(char* rutaDelArchivoDeConfiguracionDelCPU){
t_config* archivoCfg = config_create(rutaDelArchivoDeConfiguracionDelCPU);
tipoConfigCPU* cfg = crearConfigCPU();
validarErrorYAbortar(config_has_property(archivoCfg,IP_PLANIFICADOR)
&& config_has_property(archivoCfg,PUERTO_PLANIFICADOR)
&& config_has_property(archivoCfg,IP_MEMORIA)
&& config_has_property(archivoCfg,PUERTO_MEMORIA)
&& config_has_property(archivoCfg,CANTIDAD_HILOS)
&& config_has_property(archivoCfg,RETARDO),
"Las claves del archivo de configuracion no coinciden con las que requiere el CPU");
cfg->ipPlanificador = string_duplicate(config_get_string_value(archivoCfg,IP_PLANIFICADOR));
cfg->puertoPlanificador = config_get_int_value(archivoCfg,PUERTO_PLANIFICADOR);
cfg->ipMemoria = string_duplicate(config_get_string_value(archivoCfg,IP_MEMORIA));
cfg->puertoMemoria = config_get_int_value(archivoCfg,PUERTO_MEMORIA);
cfg->cantidadDeHilos = config_get_int_value(archivoCfg,CANTIDAD_HILOS);
cfg->retardo = config_get_int_value(archivoCfg,RETARDO);
config_destroy(archivoCfg);
return cfg;
}
struct config_file* config_create_forlib(void)
{
struct config_file* cfg = config_create();
if(!cfg) return NULL;
/* modifications for library use, less verbose, less memory */
free(cfg->chrootdir);
cfg->chrootdir = NULL;
cfg->verbosity = 0;
cfg->outgoing_num_ports = 16; /* in library use, this is 'reasonable'
and probably within the ulimit(maxfds) of the user */
cfg->outgoing_num_tcp = 2;
cfg->msg_cache_size = 1024*1024;
cfg->msg_cache_slabs = 1;
cfg->rrset_cache_size = 1024*1024;
cfg->rrset_cache_slabs = 1;
cfg->infra_cache_slabs = 1;
cfg->use_syslog = 0;
cfg->key_cache_size = 1024*1024;
cfg->key_cache_slabs = 1;
cfg->neg_cache_size = 100 * 1024;
cfg->donotquery_localhost = 0; /* allow, so that you can ask a
forward nameserver running on localhost */
cfg->val_log_level = 2; /* to fill why_bogus with */
cfg->val_log_squelch = 1;
return cfg;
}
void
readConfig(char *path)
{
t_config *configKernel;
configKernel = config_create(path);
configuration.ipUMV = config_get_string_value(configKernel, "IPUMV");
configuration.ipKernel = config_get_string_value(configKernel, "IPKERNEL");
configuration.puertoUMV = config_get_string_value(configKernel, "PUERTO_UMV");
/*configuration.puertoKERNEL = config_get_string_value(configKernel,
"PUERTO_KERNEL");*/
configuration.puertoProg = config_get_string_value(configKernel,
"PUERTO_PROG");
configuration.puertoCPU = config_get_string_value(configKernel, "PUERTO_CPU");
configuration.quantum = config_get_int_value(configKernel, "QUANTUM");
configuration.grado_multiprog = config_get_int_value(configKernel,
"MULTIPROGRAMACION");
configuration.retardo = config_get_int_value(configKernel, "RETARDO");
configuration.tamanio_pila = config_get_int_value(configKernel,
"TAMANIO_STACK");
configuration.semaforos = config_get_array_value(configKernel, "SEMAFOROS");
configuration.valor_semaforos = config_get_array_value(configKernel,
"VALOR_SEMAFORO");
configuration.valorHIO = config_get_array_value(configKernel, "HIO");
configuration.var_compartidas = config_get_array_value(configKernel,
"VARIABLES_GLOBALES");
configuration.idHIO = config_get_array_value(configKernel, "ID_HIO");
//config_destroy(configKernel); TODO esto tiene un leak mas grande que uan casa
}
static int
wallet_save_keys(struct wallet *wallet)
{
struct config *cfg;
int res;
int n;
n = hashtable_getnumentries(wallet->hash_keys);
Log(LGPFX" saving %u key%s in %sencrypted wallet %s.\n",
n, n > 1 ? "s" : "",
wallet->pass ? "encrypted" : "NON-",
wallet->filename);
cfg = config_create();
config_setint64(cfg, n, "numKeys");
if (wallet->pass) {
char saltStr[80];
int64 count = 0;
bool s;
res = RAND_bytes(wallet->ckey->salt, sizeof wallet->ckey->salt);
if (res != 1) {
res = ERR_get_error();
Log(LGPFX" RAND_bytes failed: %d\n", res);
goto exit;
}
str_snprintf_bytes(saltStr, sizeof saltStr, NULL,
wallet->ckey->salt, sizeof wallet->ckey->salt);
config_setstring(cfg, saltStr, "encryption.salt");
s = crypt_set_key_from_passphrase(wallet->pass, wallet->ckey, &count);
ASSERT(s);
ASSERT(count >= CRYPT_NUM_ITERATIONS_OLD);
config_setint64(cfg, count, "encryption.numIterations");
}
hashtable_for_each(wallet->hash_keys, wallet_save_key_cb, cfg);
file_rotate(wallet->filename, 1);
res = file_create(wallet->filename);
if (res) {
Log(LGPFX" failed to create file '%s': %s\n",
wallet->filename, strerror(res));
goto exit;
}
res = file_chmod(wallet->filename, 0600);
if (res) {
Log(LGPFX" failed to chmod 0600 wallet.dat: %s\n",
strerror(res));
goto exit;
}
res = config_write(cfg, wallet->filename);
exit:
config_free(cfg);
return res;
}
void leerConfiguracion(void){
config=config_create(PATH);
configuracion_cpu.ip_kernel=config_get_string_value(config,"Direccion IP para conectarse al Kernel");
configuracion_cpu.puerto_kernel=config_get_int_value(config,"Puerto TCP para conectarse al Kernel");
configuracion_cpu.ip_umv=config_get_string_value(config,"Direccion IP para conectarse a la UMV");
configuracion_cpu.puerto_umv=config_get_int_value(config,"Puerto TCP para conectarse a la UMV");
}
int bot_create(struct bot* b)
{
b->conn = (conn_t*)malloc(sizeof(conn_t));
b->conf = (conf_t*)malloc(sizeof(conf_t));
conn_create(b->conn);
config_create(b->conf);
return 0;
}
void levantar_configuraciones() {
t_config * archivo_configuracion = config_create("CPU.confg");
config_cpu.PUERTO_NUCLEO = config_get_string_value(archivo_configuracion, "PUERTO_NUCLEO");
config_cpu.IP_NUCLEO = config_get_string_value(archivo_configuracion, "IP_NUCLEO");
config_cpu.PUERTO_UMC = config_get_string_value(archivo_configuracion, "PUERTO_UMC");
config_cpu.IP_UMC = config_get_string_value(archivo_configuracion, "IP_UMC");
}
void obtenerConfiguracion(char* nombre_archivo) {
t_config* config;
configuracion = (t_Datos_configuracion*) malloc(sizeof(t_Datos_configuracion));
char* path = file_combine(PATH_CONFIG, nombre_archivo);
config = config_create(path);
if (config_has_property(config, "IP_MARTA")) {
configuracion->ip_marta = strdup(config_get_string_value(config, "IP_MARTA"));
} else {
log_error_consola("El archivo de configuracion %s debe tener un IP_MARTA", path);
exit(1);
}
if (config_has_property(config, "REDUCE")) {
configuracion->reduce = read_whole_file(config_get_string_value(config, "REDUCE"));
configuracion->tamanio_reduce = file_get_size(config_get_string_value(config, "REDUCE"));
} else {
log_error_consola("El archivo de configuracion %s debe tener un REDUCE", path);
exit(1);
}
if (config_has_property(config, "MAPPER")) {
configuracion->mapper = read_whole_file(config_get_string_value(config, "MAPPER"));
configuracion->tamanio_mapper = file_get_size(config_get_string_value(config, "MAPPER"));
} else {
log_error_consola("El archivo de configuracion %s debe tener un MAPPER", path);
exit(1);
}
if (config_has_property(config, "PUERTO_MARTA")) {
configuracion->puerto_marta = config_get_int_value(config, "PUERTO_MARTA");
} else {
log_error_consola("El archivo de configuracion %s debe tener un PUERTO_MARTA", path);
exit(1);
}
if (config_has_property(config, "COMBINER")) {
configuracion->combiner = !strcmp(config_get_string_value(config, "COMBINER"), "SI") ? 1 : 0;
} else {
log_error_consola("El archivo de configuracion %s debe tener un COMBINER", path);
exit(1);
}
if (config_has_property(config, "RESULTADO")) {
configuracion->resultado = strdup(config_get_string_value(config, "RESULTADO"));
} else {
log_error_consola("El archivo de configuracion %s debe tener un RESULTADO", path);
exit(1);
}
if (config_has_property(config, "ARCHIVOS")) {
configuracion->archivos = strdup(config_get_string_value(config, "ARCHIVOS"));
} else {
log_error_consola("El archivo de configuracion %s debe tener un ARCHIVOS", path);
exit(1);
}
log_info_consola("El archivo de configuracion %s fue cargado con exito", path);
config_destroy(config);
}
t_param_persoje leer_personaje_config() {
t_config* config;
t_param_persoje param;
t_recusos *list_recursos; //declaro el tipo nodo
char *aux_char;
char *aux_str;
char **aux;
int i;
log_in_disk_per(LOG_LEVEL_TRACE,
"comienzo lectura archivo de configuracion del personaje en el %s ",
PATH_CONFIG_PERSONAJE);
param.RECURSOS = list_create(); //creo lista de recursos
config = config_create(PATH_CONFIG_PERSONAJE);
//param.nom_nivel = nivel; //copio el nombre del nivel que pase por parametro en el main
param.NOMBRE = config_get_string_value(config, "NOMBRE");
aux_char = config_get_string_value(config, "SIMBOLO");
param.SMBOLO = aux_char[0];
param.PLAN_NIVELES = config_get_array_value(config, "PLANDENIVELES");
param.VIDAS = config_get_int_value(config, "VIDAS");
aux_char = config_get_string_value(config, "PLATAFORMA");
aux = string_split(aux_char, ":");
param.IP = aux[0];
param.PUERTO_PLATAFORMA = atoi(aux[1]);
i = 0;
while (param.PLAN_NIVELES[i] != '\0') {
list_recursos = malloc(sizeof(t_recusos));
//sprintf(aux_str, "OBJ[%s]", param.PLAN_NIVELES[i]);
aux_str = string_from_format("OBJ[%s]", param.PLAN_NIVELES[i]);
log_in_disk_per(LOG_LEVEL_TRACE, "Niveles de planificador %s ",
param.PLAN_NIVELES[i]);
list_recursos->RECURSOS = config_get_array_value(config, aux_str);
strcpy(list_recursos->NOMBRE, param.PLAN_NIVELES[i]);
list_add(param.RECURSOS, list_recursos); //agrego el nuevo nodo
log_in_disk_per(LOG_LEVEL_TRACE,
"Niveles de planificador %s con los recursos %s",
param.PLAN_NIVELES[i],
config_get_string_value(config, aux_str));
i++;
}
return param;
}
////////////////////////////////////////////////////PROGRAMA PRINCIPAL////////////////////////////////////////////////////
int main (){
nivelTerminado=false;
huboCambios=false;
listaDeEnemigos = list_create();
items = list_create(); // CREO LA LISTA DE ITEMS
listaPersonajesRecursos = list_create(); //CREO LA LISTA DE PERSONAJES CON SUS RECURSOS
config = config_create(RUTA); //CREO LA RUTA PARA EL ARCHIVO DE CONFIGURACION
pthread_mutex_init(&mutex_mensajes, NULL );
pthread_mutex_init(&mutex_listas, NULL );
pthread_mutex_init(&mutex_log, NULL );
pthread_mutex_init(&mx_lista_items,NULL);
leerArchivoConfiguracion(); //TAMBIEN CONFIGURA LA LISTA DE RECURSOS POR NIVEL
dibujar();
crearHiloInotify(hiloInotify);
socketDeEscucha=handshakeConPlataforma();
//SE CREA UN SOCKET NIVEL-PLATAFORMA DONDE RECIBE LOS MENSAJES POSTERIORMENTE
if (crearLosEnemigos){
pthread_mutex_lock(&mutex_log);
log_info(logger,"Se levantaron los enemigos");
pthread_mutex_unlock(&mutex_log);
crearHilosEnemigos();
}
if(activarInterbloqueo){
crearHiloInterbloqueo();
}
while(1){
if(socketDeEscucha!=-1){
mensajesConPlataforma(socketDeEscucha); //ACA ESCUCHO TODOS LOS MENSAJES EXCEPTO HANDSHAKE
}else{
pthread_mutex_lock(&mutex_log);
log_info(logger, "Hubo un error al leer el socket y el programa finalizara su ejecucion");
pthread_mutex_unlock(&mutex_log);
eliminarEstructuras();
break;
}
}
return true;
}
void actualizarDelay(int fd) {
char buffer[1024];
read( fd, buffer, 1024 ); //leo para q el select no entre otra vez
t_config *s_cfg = config_create("cfgRfs.txt");
if(config_has_property(s_cfg,"delay")) {
delay = (config_get_int_value(s_cfg,"delay"))*1000;
}
}
inline Actor
pstring_new(Config cfg, char * p, int n)
{
if (n <= 0) { return a_empty_string; }
String s = (String)config_create(cfg, sizeof(STRING), beh_string);
s->_act.eqv = string_eqv_method; // override eqv procedure
s->p = p; // may, or may not, have '\0' terminator
s->n = integer_new(cfg, n); // pre-defined length
return (Actor)s;
}
inline Actor
cstring_new(Config cfg, char * p)
{
if (*p == '\0') { return a_empty_string; }
String s = (String)config_create(cfg, sizeof(STRING), beh_string);
s->_act.eqv = string_eqv_method; // override eqv procedure
s->p = p; // must have '\0' terminator
s->n = a_minus_one; // unknown length
return (Actor)s;
}
