自学教程：C++ string_duplicate函数代码示例

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;}

/* ---------------------------------------------------------------------- */voidcopy_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_tstats_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_tconf_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_tconf_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);}