job* crearJob(char* argv[]){ job* nuevo = (job*)malloc(sizeof(job)); nuevo->id = 0; nuevo->socketFd = 0; if( access( argv[2], F_OK ) == -1 ) { finalizarJob(FALLO_INGRESO); } if( access( argv[3], F_OK ) == -1 ) { finalizarJob(FALLO_INGRESO); } nuevo->rutaTransformador.cadena = string_duplicate(argv[2]); nuevo->rutaTransformador.longitud = string_length(nuevo->rutaTransformador.cadena); nuevo->rutaReductor.cadena = string_duplicate(argv[3]); nuevo->rutaReductor.longitud = string_length(nuevo->rutaReductor.cadena); nuevo->rutaDatos.cadena= string_duplicate(argv[4]); nuevo->rutaDatos.longitud = string_length(nuevo->rutaDatos.cadena); nuevo->rutaResultado.cadena = string_duplicate(argv[5]); nuevo->rutaResultado.longitud = string_length(nuevo->rutaResultado.cadena); estadisticas = crearEstadisticasProceso(); return nuevo; }
/* ---------------------------------------------------------------------- */ void copy_defaults (struct defaults *dest_ptr, struct defaults *src_ptr) /* ---------------------------------------------------------------------- */ { int i; dest_ptr->count_iso = src_ptr->count_iso; dest_ptr->density = src_ptr->density; dest_ptr->iso = (struct iso *) PHRQ_malloc (sizeof (struct iso) * src_ptr->count_iso); if (dest_ptr->iso == NULL) { malloc_error (); } else { for (i = 0; i < src_ptr->count_iso; i++) { dest_ptr->iso[i] = src_ptr->iso[i]; dest_ptr->iso[i].name = string_duplicate (src_ptr->iso[i].name); } } dest_ptr->pe = src_ptr->pe; dest_ptr->ph = src_ptr->ph; dest_ptr->redox = string_duplicate (src_ptr->redox); dest_ptr->temp = src_ptr->temp; dest_ptr->units = string_duplicate (src_ptr->units); dest_ptr->water = src_ptr->water; }
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; }
static void test_string_trim_right() { char *string; string = string_duplicate("Hola"); string_trim_right(&string); CU_ASSERT_STRING_EQUAL(string, "Hola"); free(string); string = string_duplicate("Hola "); string_trim_right(&string); CU_ASSERT_STRING_EQUAL(string, "Hola"); free(string); }
/*! * Callback for the foreach statement. * * \param element Current element in the hash table. * \param data Configuration object. * \return Always true. */ static bool _config_set_key_value (struct hashtable_t *element, void *data) { struct config_t *conf = (struct config_t *) data; char *sql = NULL; char *key = NULL; char *val = NULL; int type = TYPE_NULL; /* retrieve key/value pair */ key = allocate (element->size); memcpy (key, element->key, element->size); type = element->val.type; switch (type) { case TYPE_INT: val = string_duplicate ("%d", element->val.data.i); break; case TYPE_DOUBLE: val = string_duplicate ("%lf", (double) element->val.data.f); break; case TYPE_BOOLEAN: val = string_duplicate ("%s", element->val.data.b ? "true" : "false"); break; case TYPE_STRING: val = string_duplicate ("%s", element->val.data.s); break; default: break; } /* create SQL statement */ sql = string_duplicate (CONFIG_SQL_UPDATE, key, val, type); deallocate (key); deallocate (val); sqlite3_exec (conf->db, sql, NULL, NULL, NULL); /* if this fail, what can we do ? */ deallocate (sql); return true; }
static void test_string_equals_ignore_case() { char *string = string_duplicate("Hello WorLd"); CU_ASSERT_TRUE(string_equals_ignore_case(string, "hello world")); free(string); }
char * conf_add_group(struct conf *cf, struct command *cmd, void *conf) { rstatus_t status; uint8_t *p; struct array *a; struct string *field, *value; p = conf; a = (struct array *)(p + cmd->offset); field = array_push(a); if (field == NULL) { return CONF_ERROR; } string_init(field); value = array_top(&cf->arg); status = string_duplicate(field, value); if (status != NC_OK) { return CONF_ERROR; } return CONF_OK; }
/** * @brief ggs_match_off * * Parse a "match off" from a GGS input text. * * @param match GGS match off. * @param text GGS input text. * @return 'true' if the text is a valid match end. */ static bool ggs_match_off(GGSMatchOff *match, Text *text) { const char *line = text->line[0]; char word[WORD_SIZE]; line = parse_word(line, word, WORD_SIZE); if (strcmp("/os:", word) != 0) return false; line = parse_word(line, word, WORD_SIZE); if (strcmp("-", word) != 0) return false; line = parse_word(line, word, WORD_SIZE); if (strcmp("match", word) != 0) return false; line = parse_word(line, word, WORD_SIZE); match->id = string_duplicate(word); line = parse_word(line, word, WORD_SIZE); if (!ggs_player_set(&(match->player[0]), line, word)) return false; line = parse_skip_word(line); line = parse_word(line, word, WORD_SIZE); if (!ggs_player_set(&(match->player[1]), line, word)) return false; return true; }
tipoRespuesta* leerPagina(t_list* listaDeHuecosUtilizados,int pidProceso,int dirLogicaDePagina,int tamanioDePagina,char* particion, t_log* logger, int retardoDeLectura){ tipoRespuesta* respuestaASolicitudDeLectura; char* contenidoDePagina; char* textoALogear = string_new(); //buscarPIDEnListaDeHuecos tipoHuecoUtilizado* huecoDelProceso = buscarHuecoUtilizadoPorPID(listaDeHuecosUtilizados,pidProceso); //traducirDireccionLogicaEnFisica int direccionFisicaEnParticion = traducirDireccionLogicaAFisica(huecoDelProceso,dirLogicaDePagina); //direccionFisicaEnParticion es la posicion donde comienza la pagina en el archivo de particion //buscarEnContenidoEnParticion contenidoDePagina = string_duplicate(leerBloqueMapeado(particion,direccionFisicaEnParticion,tamanioDePagina)); //retornarContenidoDePagina respuestaASolicitudDeLectura = crearTipoRespuesta(PERFECTO,contenidoDePagina); sleep(retardoDeLectura); string_append_with_format(&textoALogear,"Lectura realizada | PID: %d | Byte inicial: %d | Tamanio: %d | Contenido: %s",pidProceso,dirLogicaDePagina*tamanioDePagina,string_length(contenidoDePagina),contenidoDePagina); logearSeguimiento(textoALogear,logger); free(textoALogear); free(contenidoDePagina); return respuestaASolicitudDeLectura; }
char* socket_ip(char* direccionCompleta){ char * dir = string_duplicate(direccionCompleta); string_append(&dir,"basura"); // Le agrego al final cualquier cosa, cuestion de que si me mandan "127.0.0.1:", pueda dividirlo correctamente char * resultado = ( string_split(dir, ":") )[0]; //Divido en el ":", en un array de char* y digo que me de la primera parte. free(dir); return resultado; }
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 inicializar_panel(t_tipo_proceso tipo_proceso, char* path){ char* tipo_proceso_str; if (tipo_proceso == KERNEL) tipo_proceso_str = "kernel"; else if (tipo_proceso == CPU) tipo_proceso_str = "cpu"; else tipo_proceso_str = "?"; proceso_tipo = tipo_proceso; char* logFile = string_duplicate(path); string_append(&logFile, tipo_proceso_str); string_append(&logFile, ".log"); remove(logFile); logger = log_create(logFile, tipo_proceso_str, true, LOG_LEVEL_INFO); log_info(logger, "Inicializando panel para %s, en \"%s\"", tipo_proceso_str, logFile); free(logFile); kernel_cpus_conectadas = list_create(); kernel_consolas_conectadas = list_create(); }
void label_init(t_label *label, t_token *label_token) { assert(label_token->type == TOKEN_TYPE_LABEL_DEF); label->name = string_duplicate(label_token->string_value); label->instr = NULL; label->position = label_token->position; }
char * conf_set_hashtag(struct conf *cf, struct command *cmd, void *conf) { rstatus_t status; uint8_t *p; struct string *field, *value; p = conf; field = (struct string *)(p + cmd->offset); if (field->data != CONF_UNSET_PTR) { return "is a duplicate"; } value = array_top(&cf->arg); if (value->len != 2) { return "is not a valid hash tag string with two characters"; } status = string_duplicate(field, value); if (status != NC_OK) { return CONF_ERROR; } return CONF_OK; }
rstatus_t stats_pool_copy_init(struct stats_pool *stp, struct server_pool *sp, struct hash_table **sit) { rstatus_t status; uint32_t nserver; string_init(&stp->name); string_duplicate(&stp->name, &sp->name); array_null(&stp->metric); array_null(&stp->server); status = array_init(&stp->metric, STATS_POOL_NFIELD, sizeof(struct stats_metric)); if (status != NC_OK) { return status; } nserver = array_n(&sp->server) == 0 ? array_n(&stp->server):array_n(&sp->server); status = array_init(&stp->server, nserver, sizeof(struct stats_server)); if (status != NC_OK) { return status; } (*sit) = assoc_create_table(sp->key_hash, array_n(&sp->server)); if ((*sit) == NULL) { return NC_ERROR; } return NC_OK; }
/** * @brief ggs_match_on * * Parse a "match on" from a GGS input text. * * @param match GGS match on. * @param text GGS input text. * @return 'true' if the text is a valid match start. */ static bool ggs_match_on(GGSMatchOn *match, Text *text) { const char *line = text->line[0]; char word[WORD_SIZE]; line = parse_word(line, word, WORD_SIZE); if (strcmp("/os:", word) != 0) return false; line = parse_word(line, word, WORD_SIZE); if (strcmp("+", word) != 0) return false; line = parse_word(line, word, WORD_SIZE); if (strcmp("match", word) != 0) return false; line = parse_word(line, word, WORD_SIZE); match->id = string_duplicate(word); line = parse_word(line, word, WORD_SIZE); if (!ggs_player_set(&(match->player[0]), line, word))return false; line = parse_skip_word(line); line = parse_word(line, word, WORD_SIZE); if (!ggs_player_set(&(match->player[1]), line, word)) return false; line = parse_skip_word(line); line = parse_word(line, word, WORD_SIZE); ggs_match_type_set(match->match_type, word); line = parse_word(line, word, WORD_SIZE); match->match_type->is_rated = (strcmp(word, "R") == 0) ? 1 : 0; return true; }
t_fileContent *getFileContent(char *archivoTemporal) { /*obtengo la ruta del archivo char *rutaArchivo = malloc(256); sprintf(rutaArchivo, "%s%s", directorioTemporal, archivoTemporal); */ char *rutaTemporal = string_duplicate("/tmp"); string_append(&rutaTemporal,archivoTemporal); //abrir el archivo int archivo = open(rutaTemporal,O_RDONLY); if (archivo == -1) { log_info(log_nodo, "FALLO AL ABRIR ARCHIVO EN GETFILECONTENT"); } //perror(""); //leer todo el archivo struct stat infoArchivo; stat(rutaTemporal, &infoArchivo); char *contenido = malloc(infoArchivo.st_size); read(archivo, contenido, infoArchivo.st_size); close(archivo); t_fileContent *fileContent = malloc(sizeof(t_fileContent)); fileContent->contenido = contenido; fileContent->size = infoArchivo.st_size; return fileContent; }
t_log* log_create(char* file, char *program_name, bool is_active_console, t_log_level detail) { t_log* logger = malloc(sizeof(t_log)); if (logger == NULL) { perror("Cannot create logger"); return NULL; } FILE *file_opened = NULL; if (file != NULL) { file_opened = txt_open_for_append(file); if (file_opened == NULL) { perror("Cannot create/open log file"); free(logger); return NULL; } } logger->file = file_opened; logger->is_active_console = is_active_console; logger->detail = detail; logger->pid = process_getpid(); logger->program_name = string_duplicate(program_name); return logger; }
int socket_puerto(char* direccionCompleta){ char * dir = string_duplicate("basura"); string_append(&dir,direccionCompleta); // Le agrego al principio cualquier cosa, cuestion de que si me mandan ":2532", pueda dividirlo correctamente int resultado = atoi(( string_split(dir, ":") )[1]); //Divido en el ":", en un array de char* y digo que me de la segunda parte en forma de int. free(dir); return resultado; }
static void test_string_to_upper() { char *string = string_duplicate("Hello World"); string_to_upper(string); CU_ASSERT_STRING_EQUAL(string, "HELLO WORLD"); free(string); }
static void test_string_to_lower() { char *string = string_duplicate("Hello World"); string_to_lower(string); CU_ASSERT_STRING_EQUAL(string, "hello world"); free(string); }
String &String::operator^=(CStrRef v) { const char *s1 = data(); const char *s2 = v.data(); int len1 = size(); int len2 = v.size(); char *copy = NULL; if (len2 < len1) { copy = string_duplicate(s2, len2); for (int i = 0; i < len2; i++) copy[i] ^= s1[i]; SmartPtr<StringData>::operator=(NEW(StringData)(copy, len2, AttachString)); } else { copy = string_duplicate(s1, len1); for (int i = 0; i < len1; i++) copy[i] ^= s2[i]; SmartPtr<StringData>::operator=(NEW(StringData)(copy, len1, AttachString)); } return *this; }
static rstatus_t conf_pool_init(struct conf_pool *cp, struct string *name) { rstatus_t status; string_init(&cp->name); string_init(&cp->listen.pname); string_init(&cp->listen.name); cp->listen.port = 0; memset(&cp->listen.info, 0, sizeof(cp->listen.info)); cp->listen.valid = 0; cp->hash = CONF_UNSET_HASH; string_init(&cp->hash_tag); cp->distribution = CONF_UNSET_DIST; cp->timeout = CONF_UNSET_NUM; cp->backlog = CONF_UNSET_NUM; cp->client_connections = CONF_UNSET_NUM; cp->tcpkeepalive = CONF_UNSET_NUM; string_init(&cp->redis_auth); cp->redis_db = CONF_UNSET_NUM; cp->server_connections = CONF_UNSET_NUM; array_null(&cp->groups); cp->sentinel_heartbeat = CONF_UNSET_NUM; array_null(&cp->sentinels); cp->valid = 0; status = string_duplicate(&cp->name, name); if (status != NC_OK) { return status; } status = array_init(&cp->groups, CONF_DEFAULT_GROUPS, sizeof(struct string)); if (status != NC_OK) { string_deinit(&cp->name); return status; } status = array_init(&cp->sentinels, CONF_DEFAULT_SENTINELS, sizeof(struct conf_server)); if (status != NC_OK) { array_deinit(&cp->groups); string_deinit(&cp->name); return status; } log_debug(LOG_VVERB, "init conf pool %p, '%.*s'", cp, name->len, name->data); return NC_OK; }
void agregarHeader(char** mensaje){ char* head=string_new(); char* numero=header(string_length(*mensaje)); string_append(&head,numero); string_append(&head,*mensaje); *mensaje=string_duplicate(head); free(numero); free (head); }
char* completarBloque(char* bloqueACompletar, int tamanioDeBloque){ int cantACompletar = tamanioDeBloque - string_length(bloqueACompletar); char* aux = string_duplicate(bloqueACompletar); string_append(&aux,string_repeat(CARACTER_VACIO,cantACompletar)); return aux; }
// Make sure that this StringData* is safe to modify. It may leave the pointer // untouched. It may create a new StringData, modify the pointer, and decref // the old data. void string_touch(StringData** data) { ca_assert((*data)->refCount > 0); if ((*data)->refCount == 1) return; StringData* dup = string_duplicate(*data); decref(*data); *data = dup; }
void ejecuta_reduce(t_job* job, t_reduce* reduce) { char* stream = string_duplicate(reduce->arch_tmp.nodo.ip); string_append(&stream, "|"); string_append(&stream, reduce->arch_tmp.nodo.nombre); string_append(&stream, "|"); string_append(&stream, string_duplicate(reduce->arch_tmp.nombre)); t_msg* message = string_message(EJECUTAR_REDUCE, stream, 3, reduce->arch_tmp.nodo.puerto, reduce->id, job->id); reduce->estado = EN_EJECUCION; enviar_mensaje(job->socket, message); void _genera_mensaje(t_temp* temp) { stream = string_duplicate(temp->nodo.ip); string_append(&stream, "|"); string_append(&stream, temp->nodo.nombre); string_append(&stream, "|"); string_append(&stream, string_duplicate(temp->nombre)); t_msg* message = string_message(ARCHIVOS_NODO_REDUCE, stream, 1, temp->nodo.puerto); enviar_mensaje(job->socket, message); }
static rstatus_t conf_pool_init(struct conf_pool *cp, struct string *name) { rstatus_t status; string_init(&cp->name); string_init(&cp->listen.pname); string_init(&cp->listen.name); string_init(&cp->redis_auth); cp->listen.port = 0; memset(&cp->listen.info, 0, sizeof(cp->listen.info)); cp->listen.valid = 0; cp->hash = CONF_UNSET_HASH; string_init(&cp->hash_tag); cp->distribution = CONF_UNSET_DIST; cp->timeout = CONF_UNSET_NUM; cp->backlog = CONF_UNSET_NUM; cp->client_connections = CONF_UNSET_NUM; cp->redis = CONF_UNSET_NUM; cp->tcpkeepalive = CONF_UNSET_NUM; cp->redis_db = CONF_UNSET_NUM; cp->proto = CONF_UNSET_PROTO; cp->preconnect = CONF_UNSET_NUM; cp->auto_eject_hosts = CONF_UNSET_NUM; cp->server_connections = CONF_UNSET_NUM; cp->server_retry_timeout = CONF_UNSET_NUM; cp->server_failure_limit = CONF_UNSET_NUM; array_null(&cp->server); cp->valid = 0; status = string_duplicate(&cp->name, name); if (status != NC_OK) { return status; } status = array_init(&cp->server, CONF_DEFAULT_SERVERS, sizeof(struct conf_server)); if (status != NC_OK) { string_deinit(&cp->name); return status; } log_debug(LOG_VVERB, "init conf pool %p, '%.*s'", cp, name->len, name->data); return NC_OK; }
void* orquestador(void* plat) { t_plataforma* plataforma = (t_plataforma*) plat; t_orquestador* self = orquestador_create(PUERTO_ORQUESTADOR, plataforma); t_socket_client* acceptClosure(t_socket_server* server) { t_socket_client* client = sockets_accept(server); t_mensaje* mensaje = mensaje_recibir(client); if (mensaje == NULL) { sockets_destroyClient(client); pthread_mutex_lock(&plataforma->logger_mutex); log_warning(plataforma->logger, "%s:%d -> Orquestador - Error al recibir datos en el accept", sockets_getIp(client->socket), sockets_getPort(client->socket)); pthread_mutex_unlock(&plataforma->logger_mutex); return NULL; } int tipo_mensaje = mensaje->type; mensaje_destroy(mensaje); switch (tipo_mensaje) { case M_HANDSHAKE_PERSONAJE: responder_handshake(client, plataforma->logger, &plataforma->logger_mutex, "Orquestador"); orquestador_guardar_personaje(self, client, plataforma); break; case M_HANDSHAKE_NIVEL: responder_handshake(client, plataforma->logger, &plataforma->logger_mutex, "Orquestador"); if (!procesar_handshake_nivel(self, client, plataforma)) { orquestador_send_error_message("Error al procesar el handshake", client); return NULL; } break; default: pthread_mutex_lock(&plataforma->logger_mutex); char* error_msg = string_from_format( "Tipo del mensaje recibido no válido tipo: %d", tipo_mensaje); log_warning(plataforma->logger, error_msg); mensaje_create_and_send(M_ERROR, string_duplicate(error_msg), strlen(error_msg) + 1, client); free(error_msg); pthread_mutex_unlock(&plataforma->logger_mutex); orquestador_send_error_message("Request desconocido", client); return NULL ; } return client; }
void replanificarMapFallado(t_job* job, t_map* map){ int idNodoNuevo = *(map->idNodoOpcion2); int idBloqueNuevo = *(map->idBloqueOpcion2); bool by_idNodo(t_nodo* n) { return (*(n->id) == idNodoNuevo); } t_nodo* nodo = list_find(nodosList, (void*)by_idNodo); //guardo valores anteriores int idNodoViejo = *(map->idNodo); int idBloqueViejo = *(map->idBloque); //actualizo el map *(map->idNodo) = idNodoNuevo; *(map->idBloque) = idBloqueNuevo; list_add(job->maps, map); char* mensajeAJob = string_new(); string_append(&mensajeAJob, MAP); string_append(&mensajeAJob, "*"); char* resultFileName = string_new(); string_append(&resultFileName, TEMPLATE); string_append(&mensajeAJob, nodo->ip); string_append(&mensajeAJob, ","); string_append(&mensajeAJob, nodo->puerto); string_append(&mensajeAJob, ","); string_append(&mensajeAJob, string_itoa(idNodoNuevo)); string_append(&mensajeAJob, ","); string_append(&mensajeAJob, string_itoa(idBloqueNuevo)); string_append(&mensajeAJob, ","); string_append(&mensajeAJob, string_duplicate(resultFileName)); string_append(&mensajeAJob, string_itoa(idNodoNuevo)); string_append(&mensajeAJob, string_itoa(idBloqueNuevo)); if(strlen(mensajeAJob) > 999){ char* nuevoheader = string_new(); string_append(&nuevoheader, SOY_MARTA); //1 digito string_append(&nuevoheader, string_itoa(strlen(mensajeAJob)));//4 digitos enviar(*(job->socket), "9999", 4); //falso header enviar(*(job->socket), nuevoheader, 5); //header de 5 }else{ sendHeader(SOY_MARTA, strlen(mensajeAJob), *(job->socket)); } enviar(*(job->socket), mensajeAJob, strlen(mensajeAJob)); printf("Replanificacion nodo %d, bloque %d enviada a job.\nNuevo map en nodo %d, bloque %d\n", idNodoViejo, idBloqueViejo, idNodoNuevo, idBloqueNuevo); }