Context Navigation

ogAdmClient.c @ 5701de1

Visit:

918-git-images-111dconfigfileconfigure-oglivegit-imageslgromero-new-oglivemainmaint-cronmount-efivarfsmultivmmultivm-ogboot-installerogClonningEngineogboot-installer-jenkinsoglive-ipv6test-python-scriptsticket-301ticket-50ticket-50-oldticket-577ticket-585ticket-611ticket-612ticket-693ticket-700ubu24tplunification2use-local-agent-oglivevarios-instalacionwebconsole3

Last change on this file since 5701de1 was 75c38a2, checked in by alonso <alonso@…>, 15 years ago
git-svn-id: https://opengnsys.es/svn/trunk@972 a21b9725-9963-47de-94b9-378ad31fedc9
Property mode set to `100644`
File size: 83.4 KB

Rev	Line
[75c38a2]	1	//****************************************************************************************************************************************************
	2	// Aplicación OpenGNSys
	3	// Autor: José Manuel Alonso.
	4	// Licencia: Open Source
	5	// Fichero: ogAdmClient.c
	6	// Descripción:
	7	// Este módulo de la aplicación OpenGNSys implementa las comunicaciones con el Cliente.
	8	// ****************************************************************************************************************************************************
	9	#include "ogAdmClient.h"
	10	#include "ogAdmLib.c"
	11	//______________________________________________________________________________________________________
	12	// Función: ValidacionParametros
	13	//
	14	// Descripción:
	15	// Valida que los parametros de ejecución del programa sean correctos
	16	// Parámetros:
	17	// - argc: Número de argumentos
	18	// - argv: Puntero a cada argumento
	19	// Devuelve:
	20	// true si los argumentos pasados son correctos y false en caso contrario
	21	// Especificaciones:
	22	// La sintaxis de los argumentos es la siguiente
	23	// -f Archivo de configuración del cliente
	24	// -l Archivo de logs
	25	// -d Nivel de debuger (Mensages que se escribirán en el archivo de logs)
	26	//______________________________________________________________________________________________________
	27	int ValidacionParametros(int argc,char*argv[])
	28	{
	29	int i;
	30
	31	for(i = 1; i < argc; i++){
	32	if (argv[i][0] == '-'){
	33	switch (tolower(argv[i][1])){
	34	case 'f':
	35	if (argv[i+1]!=NULL)
	36	strcpy(szPathFileCfg, argv[i+1]);
	37	else
	38	return(false); // Error en el argumento archivo de configuración
	39	break;
	40	case 'l':
	41	if (argv[i+1]!=NULL)
	42	strcpy(szPathFileLog, argv[i+1]); // Error en el argumento archivo de log
	43	else
	44	return(false);
	45	break;
	46	case 'd':
	47	if (argv[i+1]!=NULL){
	48	ndebug=atoi(argv[i+1]);
	49	if(ndebug<1 )
	50	ndebug=1; // Por defecto el nivel de debug es 1
	51	}
	52	else
	53	return(false); // Error en el argumento nivel de debug
	54	break;
	55	default:
	56	return(false);
	57	break;
	58	}
	59	}
	60	}
	61	return(true);
	62	}
	63	//______________________________________________________________________________________________________
	64	// Función: CrearArchivoLog
	65	//
	66	// Descripción:
	67	// Abre el archivo de log para añadir registros desde el principio y si no existe lo crea de nuevo
	68	// Parámetros:
	69	// - szPathFileLog: Nombre del archivo
	70	// Devuelve:
	71	// true si la acción ha sido correcta y false en caso contrario
	72	//______________________________________________________________________________________________________
	73	int CrearArchivoLog(char* szPathFileLog)
	74	{
	75	return(true);
	76	FILE* FLog;
	77	FLog=fopen(szPathFileLog,"wt"); // Abre de log para escritura al comienzo
	78	if(FLog!=NULL){
	79	fclose(FLog);
	80	return(true);
	81	}
	82	return(false);
	83	}
	84	//______________________________________________________________________________________________________
	85	// Función: LeeFileConfiguracion
	86	//
	87	// Descripción:
	88	// Lee el fichero de configuración y toma el valor de los parámetros de configuración
	89	// Parámetros:
	90	// Ninguno
	91	// Devuelve:
	92	// true si todos los parámetros de configuración son correctos y false en caso contrario
	93	//______________________________________________________________________________________________________
	94	int LeeFileConfiguracion()
	95	{
	96	long lSize;
	97	char * buffer,lineas[100],dualparametro[2];
	98	char ch[2];
	99	int i,numlin,resul;
	100	FILE* Fsalida;
	101
	102	if(szPathFileCfg==NULL) return(false); // Nombre del fichero de configuración erróneo
	103
	104	Fsalida = fopen ( szPathFileCfg , "rb" ); // Abre fichero de configuración
	105	if (Fsalida==NULL)
	106	return(false); // Error de apertura del fichero de configuración
	107	fseek (Fsalida , 0 , SEEK_END);
	108	lSize = ftell (Fsalida); // Obtiene tamaño del fichero.
	109	rewind (Fsalida); // Coloca puntero de lectura al principio
	110
	111	buffer =(char*)ReservaMemoria(lSize); // Toma memoria para el buffer de lectura.
	112	if (buffer == NULL)
	113	return(false); // Error de reserva de memoria para buffer de lectura
	114	fread (buffer,1,lSize,Fsalida); // Lee contenido del fichero
	115	fclose(Fsalida);
	116
	117	//inicializar variables globales
	118	IPlocal[0]='\0'; // IP local
	119	Servidorhidra[0]='\0'; // IP servidor de Administración
	120	Puerto[0]='\0'; // Puerto de comunicaciones con el servidor de administración
	121	HIDRACHEIMAGENES[0]='\0'; // Path al directorio donde están las imágenes (en la caché)
	122	HIDRASRVIMAGENES[0]='\0'; // Path al directorio donde están las imágenes (en el repositorio)
	123	HIDRASRVCMD[0]='\0'; // Path del directorio del repositorio donde se depositan los comandos para el cliente
	124	HIDRASCRIPTS[0]='\0'; // Path al directorio donde estan los scripts de interface con la API de funciones
	125
	126	strcpy(ch,"\n"); // Carácter delimitador (salto de linea)
	127	numlin=split_parametros(lineas,buffer,ch); // Toma lineas del fichero
	128	for (i=0;i<numlin;i++){
	129	strcpy(ch,"="); // Caracter delimitador
	130	split_parametros(dualparametro,lineas[i],ch); // Toma nombre del parámetros
	131	resul=strcmp(dualparametro[0],"ServerIP");
	132	if(resul==0)
	133	strcpy(Servidorhidra,dualparametro[1]);
	134	else{
	135	resul=strcmp(dualparametro[0],"Puerto");
	136	if(resul==0)
	137	strcpy(Puerto,dualparametro[1]);
	138	else{
	139	resul=strcmp(dualparametro[0],"ClientScripts");
	140	if(resul==0)
	141	strcpy(HIDRASCRIPTS,dualparametro[1]);
	142	else{
	143	resul=strcmp(dualparametro[0],"UrlMenu");
	144	if(resul==0)
	145	strcpy(URLMENU,dualparametro[1]);
	146	else{
	147	resul=strcmp(dualparametro[0],"UrlMsg");
	148	if(resul==0)
	149	strcpy(URLMSG,dualparametro[1]);
	150	else
	151	return(false);
	152	}
	153	}
	154	}
	155	}
	156	}
	157	return(true);
	158	}
	159
	160	//______________________________________________________________________________________________________
	161	// Función: UltimoError
	162	//
	163	// Descripción:
	164	// Almacena el último error producido y lo registra en el log
	165	// Parámetros:
	166	// - herror: Código del error
	167	// - modulo: Función donde se produjo el error
	168	//______________________________________________________________________________________________________
	169	void UltimoError(int herror,char*modulo)
	170	{
	171	e.herror=herror;
	172	if(herror>MAXERROR){
	173	strcpy(e.msg,tbErrores[MAXERROR]);
	174	}
	175	else
	176	strcpy(e.msg,tbErrores[herror]);
	177	strcpy(e.modulo,modulo);
	178	sprintf(msglog,"Error en el Servicio: %d.-(%s) en modulo %s",e.herror,e.msg,e.modulo);
	179	RegistraLog(msglog,false);
	180	}
	181
	182	//______________________________________________________________________________________________________
	183	// Función: UltimoErrorScript
	184	//
	185	// Descripción:
	186	// Almacena el último error producido al ejecutar un script de la API y lo registra en el log
	187	// Parámetros:
	188	// - herror: Código del error
	189	// - modulo: Función donde se produjo el error
	190	//______________________________________________________________________________________________________
	191	void UltimoErrorScript(int herror,char*modulo)
	192	{
	193	e.herror=herror;
	194	if(herror>MAXERRORSCRIPT){
	195	strcpy(e.msg,tbErroresScripts[MAXERRORSCRIPT]);
	196	}
	197	else
	198	strcpy(e.msg,tbErroresScripts[herror]);
	199	strcpy(e.modulo,modulo);
	200	sprintf(msglog,"Error al ejecutar Script %d.-(%s) en modulo %s",e.herror,e.msg,e.modulo);
	201	RegistraLog(msglog,false);
	202	}
	203
	204
	205	//______________________________________________________________________________________________________
	206	// Función: EjecutarCodigo
	207	//
	208	// Descripción:
	209	// Ejecuta un script de la shell creando un proceso hijo para ello
	210	// Parámetros:
	211	// - script: Nombre del script de la shell
	212	// - parametros: Parámetros que se le pasarán al script
	213	// - salida: Recoge la salida por pantalla que genera el script
	214	// - swasci: Filtra la respuesta del script:
	215	// true=Elimina de la respuesta caracteres menores de asci 32
	216	// false= No los elimina
	217	// Devuelve:
	218	// Código de error de la ejecución. ( Ver tabla de código de errores en la documentación)
	219	// Especificaciones:
	220	// El parámetro salida recoge la salida por pantalla que se genera en la ejecución del script siempre que
	221	// sea disinto de NULL, esto es, si al llamar a la función este parámetro es NULL no se recogerá dicha salida.
	222	//______________________________________________________________________________________________________
	223	int EjecutarCodigo ( char script,char parametros,char *salida,int swasci)
	224	{
	225	int descr[2]; /* Descriptores de E y S de la turbería */
	226	int bytesleidos; /* Bytes leidos en el mensaje */
	227	int resul;
	228	int estado;
	229	pid_t pid;
	230	char buffer[512];
	231	pipe (descr);
	232	int i,nargs;
	233
	234	if(ndebug>2){
	235	sprintf(msglog,"Ejecución del script: %s",script);
	236	RegistraLog(msglog,false);
	237	}
	238
	239	nargs=split_parametros(argumentos,parametros," "); // Crea matriz de los argumentos del scripts
	240	for(i=nargs;i<MAXARGS;i++){
	241	argumentos[i]=NULL;
	242	}
	243
	244	if(ndebug>2){
	245	for(i=0;i<nargs;i++){
	246	sprintf(msglog,"Parámetro %d del script: %s",i,argumentos[i]);
	247	RegistraLog(msglog,false);
	248	}
	249	}
	250
	251	if((pid=fork())==0){
	252	/* Proceso hijo que ejecuta el script */
	253	close (descr[LEER]);
	254	dup2 (descr[ESCRIBIR], 1);
	255	close (descr[ESCRIBIR]);
	256	resul=execv(script,argumentos);
	257	//resul=execlp (script, script, argumentos[0],argumentos[1],NULL);
	258	exit(resul);
	259	}
	260	else {
	261	if (pid ==-1){
	262	sprintf(msglog,"***Error en la creación del proceso hijo pid=%d",pid);
	263	RegistraLog(msglog,false);
	264	return(-1);
	265	}
	266	/* Proceso padre que lee la salida del script */
	267	close (descr[ESCRIBIR]);
	268	bytesleidos = read (descr[LEER], buffer, 512);
	269	while(bytesleidos>0){
	270	if(salida!=(char*)NULL){ // Si se solicita retorno de información...
	271	buffer[bytesleidos]='\0';
	272	for(i=bytesleidos-1;i>=0;i--){
	273	if(buffer[i]<32 && swasci) // Caracter Asci menor de 32
	274	buffer[i]='\0';
	275	}
	276	strcat(salida,buffer);
	277	}
	278	bytesleidos = read (descr[LEER], buffer, 512);
	279	}
	280	close (descr[LEER]);
	281	if(ndebug>2){
	282	sprintf(msglog,"Información devuelta %s",salida);
	283	RegistraLog(msglog,false);
	284	}
	285	//kill(pid,SIGQUIT);
	286	waitpid(pid,&estado,0);
	287	resul=WEXITSTATUS(estado);
	288	if(ndebug>2){
	289	sprintf(msglog,"Estatus de finalización del script:%d",resul);
	290	RegistraLog(msglog,false);
	291	}
	292	return(resul);
	293	}
	294	return(-1);
	295	}
	296	//______________________________________________________________________________________________________
	297	// Función: EjecutarScript
	298	//
	299	// Descripción:
	300	// Ejecuta un script de la shell creando un proceso hijo para ello
	301	// Parámetros:
	302	// - script: Nombre del script de la shell
	303	// - parametros: Parámetros que se le pasarán al script
	304	// - salida: Recoge la salida por pantalla que genera el script
	305	// - swasci: Filtra la respuesta del script:
	306	// true=Elimina de la respuesta caracteres menores de asci 32
	307	// false= No los elimina
	308	// Devuelve:
	309	// Código de error de la ejecución. ( Ver tabla de código de errores en la documentación)
	310	// Especificaciones:
	311	// El parámetro salida recoge la salida desde un fichero que se genera en la ejecución del script siempre que
	312	// sea distinto de NULL, esto es, si al llamar a la función este parámetro es NULL no se recogerá dicha salida.
	313	//______________________________________________________________________________________________________
	314	int EjecutarScript ( char script,char parametros,char *salida,int swasci)
	315	{
	316	int descr[2]; /* Descriptores de E y S de la turbería */
	317	int resul,bytesleidos,estado;
	318	pid_t pid;
	319	pipe (descr);
	320	int i,nargs;
	321	FILE *Fretorno;
	322	char buffer[512];
	323
	324	if(ndebug>2){
	325	sprintf(msglog,"Ejecución del script: %s",script);
	326	RegistraLog(msglog,false);
	327	}
	328
	329	nargs=split_parametros(argumentos,parametros," "); // Crea matriz de los argumentos del scripts
	330	for(i=nargs;i<MAXARGS;i++){
	331	argumentos[i]=NULL;
	332	}
	333	if(ndebug>2){
	334	for(i=0;i<nargs;i++){
	335	sprintf(msglog,"Parámetro %d del script: %s",i,argumentos[i]);
	336	RegistraLog(msglog,false);
	337	}
	338	}
	339	if(salida!=(char*)NULL){ // Si se solicita retorno de información...
	340	Fretorno = fopen("/tmp/retorno","w" );
	341	if (Fretorno==NULL){
	342	return(8); // Error en la eliminación del archivo temporal de intercambio"
	343	}
	344	fclose(Fretorno);
	345	}
	346	if((pid=fork())==0){
	347	/* Proceso hijo que ejecuta el script */
	348	close (descr[LEER]);
	349	dup2 (descr[ESCRIBIR], 1);
	350	close (descr[ESCRIBIR]);
	351	resul=execv(script,argumentos);
	352	//resul=execlp (script, script, argumentos[0],argumentos[1],NULL);
	353	exit(resul);
	354	}
	355	else {
	356	if (pid ==-1){
	357	sprintf(msglog,"***Error en la creación del proceso hijo pid=%d",pid);
	358	RegistraLog(msglog,false);
	359	return(-1);
	360	}
	361	/* Proceso padre que lee la salida del script */
	362	close (descr[ESCRIBIR]);
	363	bytesleidos = read (descr[LEER], buffer, 512);
	364	while(bytesleidos>0){
	365	bytesleidos = read (descr[LEER], buffer, 512);
	366	}
	367	close (descr[LEER]);
	368	if(salida!=(char*)NULL){ // Si se solicita retorno de información...
	369	FILE *Fretorno = fopen("/tmp/retorno","rb" );
	370	long lSize;
	371	if (Fretorno!=NULL){
	372	fseek (Fretorno , 0 , SEEK_END); // Obtiene tamaño del fichero.
	373	lSize = ftell (Fretorno);
	374	rewind (Fretorno);
	375	if(lSize>LONGITUD_SCRIPTSALIDA){
	376	lSize=LONGITUD_SCRIPTSALIDA;
	377	RegistraLog("***Aviso, la información de salida excede de la longitud permitida. Puede haberse truncado",false);
	378	}
	379	fread (salida,1,lSize,Fretorno); // Lee contenido del fichero
	380	for(i=lSize-1;i>=0;i--){
	381	if(salida[i]<32 && swasci) // Caracter Asci menor de 32
	382	salida[i]='\0';
	383	}
	384	fclose(Fretorno);
	385	}
	386	else
	387	return(9); // Error en la eliminación del archivo temporal de intercambio"
	388
	389	}
	390
	391	if(ndebug>2){
	392	sprintf(msglog,"Información devuelta %s",salida);
	393	RegistraLog(msglog,false);
	394	}
	395	//kill(pid,SIGQUIT);
	396	waitpid(pid,&estado,0);
	397	resul=WEXITSTATUS(estado);
	398	if(ndebug>2){
	399	sprintf(msglog,"Estatus de finalización del script:%d",resul);
	400	RegistraLog(msglog,false);
	401	}
	402	return(resul);
	403	}
	404	return(-1);
	405	}
	406	//______________________________________________________________________________________________________
	407	// Función: ReservaMemoria
	408	//
	409	// Descripción:
	410	// Reserva memoria para una variable
	411	// Parámetros:
	412	// - lon: Longitud en bytes de la reserva
	413	// Devuelve:
	414	// Un puntero a la zona de memoria reservada que ha sido previamente rellena con ceros o nulos
	415	//______________________________________________________________________________________________________
	416	char* ReservaMemoria(int lon)
	417	{
	418	char *mem;
	419	mem=(char*)malloc(lon);
	420	if(mem!=NULL)
	421	memset(mem,0,lon);
	422	return(mem);
	423	}
	424	//______________________________________________________________________________________________________
	425	// Función: TCPConnect
	426	//
	427	// Descripción:
	428	// Crea un socket y lo conecta a un servidor
	429	// Parámetros:
	430	// - ips : La Dirección IP del servidor
	431	// - port : Puerto para la comunicación
	432	// Devuelve:
	433	// Un socket para comunicaciones por protocolo TCP
	434	//______________________________________________________________________________________________________
	435	SOCKET TCPConnect(char ips,char port)
	436	{
	437	SOCKET s;
	438	struct sockaddr_in server;
	439
	440	s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	441	if (s == INVALID_SOCKET){
	442	return (INVALID_SOCKET);
	443	}
	444	server.sin_family = AF_INET;
	445	server.sin_port = htons((short)atoi(port));
	446	server.sin_addr.s_addr = inet_addr(ips);
	447
	448	if (connect(s, (struct sockaddr *)&server, sizeof(server)) == INVALID_SOCKET)
	449	return (INVALID_SOCKET);
	450
	451	return(s);
	452	}
	453	//______________________________________________________________________________________________________
	454	// Función: TCPClose
	455	//
	456	// Descripción:
	457	// Cierra una conexión establecida a través de un socket
	458	// Parámetros:
	459	// - s : El socket que implementa la conexión
	460	//______________________________________________________________________________________________________
	461	void TCPClose(SOCKET s){
	462	close(s);
	463	}
	464	//______________________________________________________________________________________________________
	465	// Función: AbreConexionTCP
	466	//
	467	// Descripción:
	468	// Abre la conexión entre el cliente y el servidor de administración
	469	// Parámetros:
	470	// Ninguno
	471	// Devuelve:
	472	// True si abre la conexión o false en caso contrario.
	473	//______________________________________________________________________________________________________
	474	int AbreConexionTCP()
	475	{
	476	BOOLEAN swloop=true;
	477	int vez=0;
	478
	479	while(swloop){
	480	sock=TCPConnect(Propiedades.servidorhidra,Propiedades.puerto);
	481	if(sock!= INVALID_SOCKET){
	482	return(true);
	483	}
	484	if(swloop){
	485	vez++;
	486	if (vez>MAXCNX){
	487	swloop=false;
	488	UltimoError(2,"AbreConexionTCP()");
	489	return(false);
	490	}
	491	}
	492	sleep(5); // Espera dos cinco antes de intentar una nueva conexión con el Servidor de Administración
	493	}
	494	return(true);
	495	}
	496	//______________________________________________________________________________________________________
	497	// Función: CierraConexionTCP
	498	//
	499	// Descripción:
	500	// Cierra la conexión entre el cliente y el servidor de administración
	501	// Parámetros:
	502	// Ninguno
	503	//______________________________________________________________________________________________________
	504	void CierraConexionTCP()
	505	{
	506	TCPClose(sock);
	507	}
	508	//______________________________________________________________________________________________________
	509	// Función: EnviaTramasHidra
	510	//
	511	// Descripción:
	512	// Envía una trama TCP al Servidor de Administración
	513	// Parámetros:
	514	// s: socket TCP
	515	// trama: contenido a enviar
	516	// Devuelve:
	517	// true si el envío ha sido correcto o false en caso contrario
	518	//______________________________________________________________________________________________________
	519	int EnviaTramasHidra(SOCKET s,TRAMA *trama)
	520	{
	521	int lon;
	522
	523	trama->arroba='@'; // cabecera de la trama
	524	strcpy(trama->identificador,"JMMLCAMDJ"); // identificador de la trama
	525	trama->ejecutor='1'; // Origen del envío 1=el servidor de administración 2=el cliente 3=el repositorio de imágenes
	526
	527	lon=strlen(trama->parametros); // Compone la trama
	528	lon+=sprintf(trama->parametros+lon,"iph=%s\r",Propiedades.IPlocal); // Ip del ordenador
	529	lon+=sprintf(trama->parametros+lon,"ido=%s\r",Propiedades.idordenador); // Identificador del ordenador
	530	return(TCPWrite(s,trama));
	531	}
	532
	533	//______________________________________________________________________________________________________
	534	// Función: TCPWrite
	535	//
	536	// Descripción:
	537	// Envia una trama por la red (TCP)
	538	// Parámetros:
	539	// s: socket TCP
	540	// trama: contenido a enviar
	541	// Devuelve:
	542	// true si el envío ha sido correcto o false en caso contrario
	543	//______________________________________________________________________________________________________
	544	int TCPWrite(SOCKET s,TRAMA* trama)
	545	{
	546	int nLeft,idx,ret;
	547
	548	Encriptar((char*)trama);
	549	nLeft = strlen((char*)trama);
	550	idx = 0;
	551	while(nLeft > 0){
	552	ret = send(s,(char*)&trama[idx], nLeft, 0);
	553	if (ret == 0)
	554	break;
	555	else
	556	if (ret == SOCKET_ERROR){
	557	return(false);
	558	}
	559	nLeft -= ret;
	560	idx += ret;
	561	}
	562	return(true);
	563	}
	564
	565	//______________________________________________________________________________________________________
	566	// Función: UDPConnect
	567	//
	568	// Descripción:
	569	// Crea un socket UDP para la comunicación con su repositorio
	570	// Parámetros:
	571	// Ninguno
	572	// Devuelve:
	573	// Un socket para comunicaciones por protocolo UDP
	574	//______________________________________________________________________________________________________
	575	SOCKET UDPConnect()
	576	{
	577	SOCKET socket_c;
	578
	579	socket_c = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
	580	if (socket_c == SOCKET_ERROR)
	581	return (INVALID_SOCKET);
	582	return(socket_c);
	583	}
	584	//______________________________________________________________________________________________________
	585	// Función: EnviaTramaRepo
	586	//
	587	// Descripción:
	588	// Envía una trama UDP a su repositorio de imágenes
	589	// Parámetros:
	590	// s: socket UDP
	591	// trama: contenido a enviar
	592	// iprepo: Dirección IP del repositorio
	593	// puertorepo: Puerto de destino donde el repositorio espera la trama
	594	// Devuelve:
	595	// true si el envío ha sido correcto o false en caso contrario
	596	//______________________________________________________________________________________________________
	597	int EnviaTramaRepo(SOCKET s,TRAMA* trama, char* iprepo,char *puertorepo)
	598	{
	599	int ret,lon;
	600	struct sockaddr_in addrRepo;
	601
	602	trama->arroba='@'; // cabecera de la trama
	603	strcpy(trama->identificador,"JMMLCAMDJ"); // identificador de la trama
	604	trama->ejecutor='2'; // Origen del envío 1=el servidor 2=el cliente 3=el repositorio de imágenes
	605
	606	lon=strlen(trama->parametros); // Compone la trama
	607	lon+=sprintf(trama->parametros+lon,"iph=%s\r",Propiedades.IPlocal); // Ip local del ordenador
	608	lon+=sprintf(trama->parametros+lon,"ido=%s\r",Propiedades.idordenador); // identificador del ordenador
	609
	610	addrRepo.sin_family = AF_INET;
	611	addrRepo.sin_port = htons((short)atoi(puertorepo)); // Puerto del repositorio
	612	addrRepo.sin_addr.s_addr = inet_addr(iprepo); // Dirección IP del repositorio
	613
	614	Encriptar((char*)trama); // Encripta la trama
	615	ret = sendto(s,(char )trama,lon+11,0,(struct sockaddr )&addrRepo, sizeof(addrRepo));
	616	if (ret == SOCKET_ERROR)
	617	return(false);
	618	return true;
	619	}
	620	//______________________________________________________________________________________________________
	621	// Función: RecibeTramaRepo
	622	//
	623	// Descripción:
	624	// Recibe una trama UDP por la red
	625	// Parámetros:
	626	// s: socket UDP con el que se envío anteriormente una trama al repositorio
	627	// sw: Si es true se desencripta la trama, en caso contrario no
	628	// Devuelve:
	629	// true si la receción ha sido correcta o false en caso contrario
	630	//______________________________________________________________________________________________________
	631	int RecibeTramaRepo(SOCKET s,int sw)
	632	{
	633	int ret;
	634	struct sockaddr_in addrRepo;
	635
	636	socklen_t iAddrSize = sizeof(addrRepo);
	637	ret = recvfrom(s,(char )trama, LONGITUD_TRAMA,0,(struct sockaddr )&addrRepo,&iAddrSize);
	638	if (ret != SOCKET_ERROR){
	639	if(sw)
	640	Desencriptar((char*)trama); // Desencripta la trama
	641	return(true);
	642	}
	643	return(false);
	644	}
	645	//______________________________________________________________________________________________________
	646	// Función: CreateTextFile
	647	//
	648	// Descripción:
	649	// Crea un fichero de texto local y escribe en él cierto contenido
	650	// Parámetros:
	651	// - nomfile: Nombre del fichero
	652	// - texto: Texto a escribir en el fichero
	653	// Devuelve:
	654	// - La longitud en bytes del contenido escrito
	655	//______________________________________________________________________________________________________
	656	long CreateTextFile(char nomfile,char texto)
	657	{
	658	long lSize;
	659	FILE *f;
	660	f = fopen(nomfile,"wt");
	661	if(!f){ // El fichero por algún motivo no ha podido crearse
	662	UltimoError(3,"CreateTextFile()");
	663	return(0);
	664	}
	665	lSize=strlen(texto);
	666	fwrite(texto,1,lSize,f); // Escribe el contenido del fichero
	667	fclose(f);
	668	return(lSize);
	669	}
	670	//______________________________________________________________________________________________________
	671	// Función: ExisteFichero
	672	//
	673	// Descripción:
	674	// Comprueba si un archivo existe en su repositorio
	675	// Parámetros:
	676	// - nomfile : Nombre del fichero
	677	// Devuelve:
	678	// true si el archivo existe o false en caso contrario
	679	// ________________________________________________________________________________________________________
	680	int ExisteFichero(char *nomfile)
	681	{
	682	SOCKET udpsock;
	683	int res;
	684
	685	udpsock=UDPConnect();
	686	if (udpsock == INVALID_SOCKET){
	687	UltimoError(15,"ExisteFichero()");
	688	return(false);
	689	}
	690	sprintf(trama->parametros,"nfn=ExisteFichero\rnfl=%s\r",nomfile); // Nombre de la función a ejecutar en el servidor de administración
	691	if(EnviaTramaRepo(udpsock,trama,Propiedades.iprepo,Propiedades.puertorepo)){
	692	res=RecibeTramaRepo(udpsock,TRUE);
	693	close(udpsock);
	694	if(res)
	695	return(GestionTramas(trama));
	696	}
	697	else{
	698	UltimoError(16,"ExisteFichero()");
	699	return(false);
	700	}
	701	return(true);
	702	}
	703	//______________________________________________________________________________________________________
	704	// Función: RemoveFile
	705	//
	706	// Descripción:
	707	// Elimina un fichero del repositorio
	708	// Parámetros:
	709	// - nomfile : Nombre del fichero
	710	// Devuelve:
	711	// true si el archivo se ha eliminado correctamente o false en caso contrario
	712	// ________________________________________________________________________________________________________
	713	int RemoveFile(char *nomfile)
	714	{
	715	SOCKET udpsock;
	716	int res;
	717
	718	udpsock=UDPConnect();
	719	if (udpsock == INVALID_SOCKET){
	720	UltimoError(15,"RemoveFile()");
	721	return(false);
	722	}
	723	sprintf(trama->parametros,"nfn=EliminaFichero\rnfl=%s\r",nomfile); // Nombre de la función a ejecutar en el servidor de administración
	724	if(EnviaTramaRepo(udpsock,trama,Propiedades.iprepo,Propiedades.puertorepo)){
	725	res=RecibeTramaRepo(udpsock,TRUE);
	726	close(udpsock);
	727	if(res)
	728	return(GestionTramas(trama));
	729	}
	730	else{
	731	UltimoError(16,"RemoveFile()");
	732	return(false);
	733	}
	734	return(true);
	735	}
	736	//______________________________________________________________________________________________________
	737	// Función: LoadTextFile
	738	//
	739	// Descripción:
	740	// Lee un fichero del repositorio
	741	// Parámetros:
	742	// - nomfile : Nombre del fichero
	743	// Devuelve:
	744	// true si el proceso es correcto y false en caso contrario
	745	// Especificaciones:
	746	// En los parametros de la trama se copian el contenido del del archivo de comandos
	747	// ________________________________________________________________________________________________________
	748	int LoadTextFile(char *nomfile)
	749	{
	750	SOCKET udpsock;
	751	int res;
	752	char *txt;
	753
	754	udpsock=UDPConnect();
	755	if (udpsock == INVALID_SOCKET){
	756	UltimoError(15,"LoadTextFile()");
	757	return(false);
	758	}
	759	sprintf(trama->parametros,"nfn=LeeFicheroTexto\rnfl=%s\r",nomfile); // Nombre de la función a ejecutar en el servidor de administración
	760	if(EnviaTramaRepo(udpsock,trama,Propiedades.iprepo,Propiedades.puertorepo)){
	761	res=RecibeTramaRepo(udpsock,TRUE);
	762	close(udpsock);
	763	if(res){
	764	if(GestionTramas(trama)){
	765	txt=toma_parametro("txt",trama->parametros); // Toma contenido del fichero de comandos
	766	strcpy(trama->parametros,txt);
	767	if(ndebug>4){
	768	sprintf(msglog,"Archivo de comando:\r%s",trama->parametros);
	769	RegistraLog(msglog,false);
	770	}
	771	return(true); // Devuelve contrenido del fichero
	772	}
	773	else{
	774	UltimoError(3,"LoadTextFile()");
	775	return(false);
	776	}
	777	}
	778	else{
	779	UltimoError(16,"LoadTextFile()");
	780	return(false);
	781	}
	782	}
	783	else{
	784	UltimoError(16,"LoadTextFile()");
	785	return(false);
	786	}
	787	}
	788	//______________________________________________________________________________________________________
	789	// Función: recibeFichero
	790	//
	791	// Descripción:
	792	// Se trae un fichero del repositorio y lo coloca en el diretorio /tmp
	793	// Parámetros:
	794	// - nomfilesrc : Nombre completo del fichero fuente
	795	// - nomfiledst : Nombre completo del fichero destino
	796	// Devuelve:
	797	// true si el proceso es correcto y false en caso contrario
	798	// Especificaciones:
	799	// En los parametros de la trama se copian el contenido del del archivo de comandos
	800	// ________________________________________________________________________________________________________
	801	int recibeFichero(char nomfilesrc, char nomfiledst)
	802	{
	803	SOCKET udpsock;
	804	int blk,lsize,res;
	805	char b,l;
	806	FILE *f;
	807
	808	udpsock=UDPConnect();
	809	if (udpsock == INVALID_SOCKET){
	810	UltimoError(15,"recibeFichero()");
	811	return(false);
	812	}
	813
	814	f=fopen(nomfiledst,"wb");
	815	if(!f){
	816	RegistraLog("*** No se ha podido crear archivo",false);
	817	return(false);
	818	}
	819
	820	sprintf(trama->parametros,"nfn=mandaFichero\rnfl=%s\r",nomfilesrc); // Nombre de la función a ejecutar en el servidor de administración
	821	if(EnviaTramaRepo(udpsock,trama,Propiedades.iprepo,Propiedades.puertorepo)){
	822	b=&trama->arroba; // Puntero al comienzo de la trama para colocar el bloque leido
	823	l=b+sizeof(blk); // Puntero después del dato bloque para colocar los bytes leidos
	824	do{
	825	res=RecibeTramaRepo(udpsock,FALSE);
	826	if(res){
	827	memcpy(&blk,b,sizeof(blk));
	828	memcpy(&lsize,l,sizeof(lsize));
	829	if(lsize>0)
	830	lsize=fwrite (trama->parametros,1,lsize,f); // Escribe contenido en el fichero
	831	else{
	832	fclose(f);
	833	close(udpsock);
	834	return(true);
	835	}
	836	}
	837	else{
	838	RegistraLog("*** Error de recepción de archivo",false);
	839	break;
	840	}
	841	EnviaTramaRepo(udpsock,trama,Propiedades.iprepo,Propiedades.puertorepo); // Confirmación;
	842	}while(lsize>0);
	843	fclose(f);
	844	}
	845	else{
	846	UltimoError(16,"recibeFichero()");
	847	fclose(f);
	848	return(false);
	849	}
	850	close(udpsock);
	851	return(true);
	852	}
	853	//______________________________________________________________________________________________________
	854	// Función: sesionMulticast
	855	//
	856	// Descripción:
	857	// Notifica a su repositorio que esta preparado para recibir datos por multicast
	858	// Parámetros:
	859	// - sm : identificador de la sesión multicast
	860	// - nipes : Número de ordenadores necesarios para comenzar la sesión
	861	// Devuelve:
	862	// true si el archivo existe o false en caso contrario
	863	// ________________________________________________________________________________________________________
	864	int sesionMulticast(char sm,char nipes)
	865	{
	866	SOCKET udpsock;
	867	int res;
	868
	869	udpsock=UDPConnect();
	870	if (udpsock == INVALID_SOCKET){
	871	UltimoError(15,"sesionMulticast()");
	872	return(false);
	873	}
	874	sprintf(trama->parametros,"nfn=sesionMulticast\ride=%s\riph=%s\rnip=%s\r",sm,IPlocal,nipes); // Nombre de la función a ejecutar en el servidor de administración
	875	res=EnviaTramaRepo(udpsock,trama,Propiedades.iprepo,Propiedades.puertorepo);
	876	close(udpsock);
	877	if(!res)
	878	UltimoError(16,"sesionMulticast()");
	879	return(res);
	880	}
	881	//______________________________________________________________________________________________________
	882	// Función: ProcesaComandos
	883	//
	884	// Descripción:
	885	// Espera comando desde el Servidor de Administración para ejecutarlos
	886	// Parámetros:
	887	// Ninguno
	888	// Devuelve:
	889	// true si el archivo se ha eliminado correctamente o false en caso contrario
	890	// ________________________________________________________________________________________________________
	891	int ProcesaComandos()
	892	{
	893	sprintf(filecmd,"/comandos/CMD_%s",Propiedades.IPlocal); // Nombre del fichero de comandos
	894	if(ExisteFichero(filecmd)) // Borra fichero de comandos si previamente exista de anteriores procesos
	895	RemoveFile(filecmd);
	896	if(!DisponibilidadComandos(true)){ // Notifica al servidor de Adminsitración su disponibilidad para recibir comandos
	897	UltimoError(0,"ProcesaComandos()");
	898	return(false);
	899	}
	900	PRCCMD=true;
	901	while(PRCCMD){ // Bucle de espera de comandos interactivos
	902	if(ExisteFichero(filecmd)){ // Busca fichero de comandos
	903	RegistraLog("Comando recibido desde el Servidor de Administración",false);
	904	if(!LoadTextFile(filecmd)){ // Toma comando
	905	UltimoError(1,"ProcesaComandos()");
	906	return(false);
	907	}
	908	GestionTramas(trama); // Analiza la trama y ejecuta el comando
	909	RegistraLog("Procesa comandos pendientes",false);
	910	ComandosPendientes(); // Bucle para procesar comandos pendientes
	911	RegistraLog("Disponibilidad para comandos interactivos activada ...",false);
	912	if(!DisponibilidadComandos(true)){ // Notifica al servidor de Administración su disponibilidad para recibir comandos
	913	UltimoError(0,"ProcesaComandos()");
	914	return(false);
	915	}
	916	if(!RemoveFile(filecmd)){ // Lo elimina
	917	UltimoError(0,"ProcesaComandos()");
	918	return(false);
	919	}
	920	}
	921	sleep(1); // Espera 1 segundo antes de volver a esperar comandos
	922	}
	923	return(true);
	924	}
	925	//______________________________________________________________________________________________________
	926	// Función: DisponibilidadComandos
	927	//
	928	// Descripción:
	929	// Notifica al servidor su disponibilidad a recibir comandos ( Lgica negativa )
	930	// Parámetros:
	931	// - swdis : Indica disponibilidad si es true y NO disponibilidad en caso de ser false
	932	// Devuelve:
	933	// true si el proceso es correcto y false en caso contrario
	934	// ________________________________________________________________________________________________________
	935	int DisponibilidadComandos(int swdis)
	936	{
	937	int lon;
	938
	939	lon=sprintf(trama->parametros,"nfn=DisponibilidadComandos\r");
	940	if(!swdis)
	941	lon+=sprintf(trama->parametros+lon,"swd=0\r"); // No disponible
	942	else
	943	lon+=sprintf(trama->parametros+lon,"swd=1\r"); // Disponible
	944
	945	if(AbreConexionTCP()){
	946	if(!EnviaTramasHidra(sock,trama)){
	947	UltimoError(21,"DisponibilidadComandos()"); // No se pudo recuperar la configuración hardware
	948	return(false);
	949	}
	950	if(!recibe_tramas(sock,trama)){
	951	UltimoError(22,"DisponibilidadComandos()"); // No se pudo recuperar la configuración hardware
	952	return(false);
	953	}
	954	CierraConexionTCP();
	955	GestionTramas(trama); // Analiza la trama
	956	}
	957	else{
	958	UltimoError(2,"DisponibilidadComandos()");
	959	return(false);
	960	}
	961	return(true);
	962	}
	963	//______________________________________________________________________________________________________
	964	// Función: GestionTramas
	965	//
	966	// Descripción:
	967	// Gestiona las tramas recibidas por la red
	968	// Parámetros:
	969	// - trama : Una trama recibida
	970	// Devuelve:
	971	// true o false dependiendo del éxito en la ejecución del comandoo si se trata de una trama
	972	// del Servidor de Administración o bien del resultado de la petición de información al repositorio
	973	// ________________________________________________________________________________________________________
	974	int GestionTramas(TRAMA *trama)
	975	{
	976	TRAMA *nwtrama=NULL;
	977	int res;
	978	char *nombrefuncion;
	979
	980	INTROaFINCAD(trama->parametros);
	981	nombrefuncion=toma_parametro("nfn",trama->parametros);
	982	nwtrama=(TRAMA*)ReservaMemoria(LONGITUD_TRAMA); // Reserva buffer para la trama devuelta
	983	if(!nwtrama){
	984	UltimoError(1,"GestionTramas()");
	985	return(false);
	986	}
	987	if(ndebug>6){
	988	sprintf(msglog,"Gestión de tramas.-Función a ejecutar:%s",nombrefuncion);
	989	RegistraLog(msglog,false);
	990	}
	991	// Mensajes entre el cliente y el Servidor de Administración
	992	res=strcmp(nombrefuncion,"Apagar");
	993	if(res==0)
	994	return(Apagar(trama,nwtrama));
	995
	996	res=strcmp(nombrefuncion,"Arrancar");
	997	if(res==0)
	998	return(Arrancar(trama,nwtrama));
	999
	1000	res=strcmp(nombrefuncion,"Reiniciar");
	1001	if(res==0)
	1002	return(Reiniciar(trama,nwtrama));
	1003
	1004	res=strcmp(nombrefuncion,"IniciarSesion");
	1005	if(res==0)
	1006	return(IniciarSesion(trama,nwtrama));
	1007
	1008	res=strcmp(nombrefuncion,"RESPUESTA_InclusionCliente");
	1009	if(res==0)
	1010	return(RESPUESTA_InclusionCliente(trama));
	1011
	1012	res=strcmp(nombrefuncion,"Actualizar");
	1013	if(res==0)
	1014	return(Actualizar());
	1015
	1016	res=strcmp(nombrefuncion,"ConsolaRemota");
	1017	if(res==0)
	1018	return(ConsolaRemota(trama,nwtrama));
	1019
	1020	res=strcmp(nombrefuncion,"NoComandosPtes");
	1021	if(res==0)
	1022	return(NoComandosPtes());
	1023
	1024	res=strcmp(nombrefuncion,"Cortesia");
	1025	if(res==0)
	1026	return(Cortesia());
	1027
	1028
	1029	res=strcmp(nombrefuncion,"ExecShell");
	1030	if(res==0)
	1031	return(ExecShell(trama,nwtrama));
	1032
	1033	res=strcmp(nombrefuncion,"CrearPerfilSoftware");
	1034	if(res==0)
	1035	return(CrearPerfilSoftware(trama,nwtrama));
	1036
	1037	res=strcmp(nombrefuncion,"RestaurarImagen");
	1038	if(res==0)
	1039	return(RestaurarImagen(trama,nwtrama));
	1040
	1041	res=strcmp(nombrefuncion,"TomaConfiguracion");
	1042	if(res==0)
	1043	return(TomaConfiguracion(trama,nwtrama));
	1044
	1045	res=strcmp(nombrefuncion,"InventarioHardware");
	1046	if(res==0)
	1047	return(InventarioHardware(trama,nwtrama));
	1048
	1049	res=strcmp(nombrefuncion,"InventarioSoftware");
	1050	if(res==0)
	1051	return(InventarioSoftware(trama,nwtrama));
	1052
	1053	res=strcmp(nombrefuncion,"ParticionaryFormatear");
	1054	if(res==0)
	1055	return(ParticionaryFormatear(trama,nwtrama));
	1056
	1057	// Mensajes entre el cliente y el repositorio
	1058	res=strcmp(nombrefuncion,"Respuesta_ExisteFichero");
	1059	if(res==0){
	1060	res=atoi(toma_parametro("res",trama->parametros));
	1061	return(res);
	1062	}
	1063
	1064	res=strcmp(nombrefuncion,"Respuesta_EliminaFichero");
	1065	if(res==0){
	1066	res=atoi(toma_parametro("res",trama->parametros));
	1067	return(res);
	1068	}
	1069
	1070	res=strcmp(nombrefuncion,"Respuesta_LeeFicheroTexto");
	1071	if(res==0){
	1072	res=atoi(toma_parametro("res",trama->parametros));
	1073	return(res);
	1074	}
	1075	return(true);
	1076	}
	1077	//______________________________________________________________________________________________________
	1078	// Función: Cortesia
	1079	//
	1080	// Descripción:
	1081	// Respuesta estandar del Servidor de Administración
	1082	// Parámetros:
	1083	// Ninguno
	1084	// Devuelve:
	1085	// true siempre
	1086	// Especificaciones:
	1087	// Esta función se ejecuta de forma estandar para cerrar la conversación con el Servidor de Administración
	1088	//______________________________________________________________________________________________________
	1089	int Cortesia(){
	1090	return(true);
	1091	}
	1092	//______________________________________________________________________________________________________
	1093	// Función: NoComandosPtes
	1094	//
	1095	// Descripción:
	1096	// Conmuta el switch de los comandos pendientes y lo pone a false
	1097	// Parámetros:
	1098	// Ninguno
	1099	// Devuelve:
	1100	// true siempre
	1101	// Especificaciones:
	1102	// Cuando se ejecuta esta función se sale del bucle que recupera los comandos pendientes en el servidor y
	1103	// el cliente pasa a a estar disponible para recibir comandos desde el éste.
	1104	//______________________________________________________________________________________________________
	1105	int NoComandosPtes(){
	1106	CMDPTES=false; // Corta el bucle de comandos pendientes
	1107	return(true);
	1108	}
	1109	//______________________________________________________________________________________________________
	1110	// Función: TomaIPlocal
	1111	//
	1112	// Descripción:
	1113	// Recupera la IP local
	1114	// Parámetros:
	1115	// Ninguno
	1116	// Devuelve:
	1117	// Una cadena con el valor de la IP en formato xxx.xxx.xxx.xxx
	1118	// Especificaciones:
	1119	// En caso de no encontrar la IP o generarse algún error se devuelve la dirección 0.0.0.0
	1120	//______________________________________________________________________________________________________
	1121	int TomaIPlocal()
	1122	{
	1123	int herror;
	1124	//strcpy(IPlocal,"10.1.15.9");
	1125	//return(true);
	1126
	1127	sprintf(cmdshell,"%s/admGetIpAddress",HIDRASCRIPTS);
	1128	herror=EjecutarScript (cmdshell,NULL,IPlocal,true);
	1129	RegistraLog(msglog,false);
	1130	if(herror){
	1131	UltimoErrorScript(herror,"TomaIPlocal()"); // Se ha producido algún error
	1132	return(false);
	1133	}
	1134	return(true);
	1135	}
	1136	//______________________________________________________________________________________________________
	1137	// Función: cuestionCache
	1138	//
	1139	// Descripción:
	1140	// Procesa la cache en caso de existir.
	1141	// Parámetros:
	1142	// tamcache : Tamaño de la cache
	1143	// Devuelve:
	1144	// true o false dependiendo de si se ha ejecutado correctamente el script de configuración
	1145	//
	1146	//
	1147	//______________________________________________________________________________________________________
	1148	int cuestionCache(char* tamcache)
	1149	{
	1150	int herror;
	1151
	1152	if(ndebug>3){
	1153	sprintf(msglog,"Tamaño de la cache: %s",tamcache);
	1154	RegistraLog(msglog,false);
	1155	}
	1156
	1157	sprintf(cmdshell,"%s/initCache",HIDRASCRIPTS);
	1158	sprintf(parametros,"%s %s","initCache",tamcache);
	1159
	1160
	1161	herror=EjecutarScript (cmdshell,parametros,NULL,true);
	1162	if(herror){
	1163	UltimoErrorScript(herror,"cuestionCache()"); // Se ha producido algún error
	1164	return(false);
	1165	}
	1166	if(tamcache>0)
	1167	CACHEEXISTS=true;
	1168	else
	1169	CACHEEXISTS=false;
	1170
	1171	return(true);
	1172	}
	1173	//______________________________________________________________________________________________________
	1174	// Función: InclusionCliente
	1175	// Descripción:
	1176	// Abre una sesión en el servidor de administración y registra al cliente en el sistema
	1177	// Parámetros:
	1178	// Ninguno
	1179	// Devuelve:
	1180	// true si el registro ha tenido éxito o false en caso contrario
	1181	//______________________________________________________________________________________________________
	1182	int InclusionCliente()
	1183	{
	1184	int lon;
	1185	char *parametroscfg;
	1186
	1187	parametroscfg=(char*)ReservaMemoria(256);
	1188	if(!parametroscfg){
	1189	UltimoError(1,"InclusionCliente()"); // No se pudo reservar memoria
	1190	return(false);
	1191	}
	1192
	1193	char disco=(char)ReservaMemoria(2);
	1194	sprintf(disco,"1"); // Siempre el disco 1
	1195	parametroscfg=LeeConfiguracion(disco); // Toma configuración
	1196
	1197	if(ndebug>3){
	1198	sprintf(msglog,"CONFIGURACION=%s",parametroscfg);
	1199	RegistraLog(msglog,false);
	1200	}
	1201
	1202	if(!parametroscfg){
	1203	UltimoError(18,"InclusionCliente()"); // No se pudo recuperar la configuración hardware
	1204	return(false);
	1205	}
	1206	lon=sprintf(trama->parametros,"nfn=InclusionCliente\r"); // Nombre de la función a ejecutar en el servidor de Adminsitración
	1207	lon+=sprintf(trama->parametros+lon,"cfg=%s\r",parametroscfg); // Configuración de los Sistemas Operativos del cliente
	1208	if(AbreConexionTCP()){
	1209	RegistraLog("Enviando peticion de inclusion al Servidor de Administración",false);
	1210	if(!EnviaTramasHidra(sock,trama)){
	1211	UltimoError(21,"InclusionCliente()"); // No se pudo recuperar la configuración hardware
	1212	return(false);
	1213	}
	1214	RegistraLog("Recibiendo respuesta del Servidor de Administración",false);
	1215	if(!recibe_tramas(sock,trama)){
	1216	UltimoError(22,"InclusionCliente()"); // No se pudo recuperar la configuración hardware
	1217	return(false);
	1218	}
	1219	CierraConexionTCP();
	1220	if(!GestionTramas(trama)){ // Analiza la trama
	1221	UltimoError(0,"InclusionCliente()");
	1222	return(false);
	1223	}
	1224	return(true);
	1225	}
	1226	else{
	1227	UltimoError(2,"InclusionCliente()"); // No se pudo conectar con el servidor de administración
	1228	return(false);
	1229	}
	1230	return(true);
	1231	}
	1232	//______________________________________________________________________________________________________
	1233	// Función: RESPUESTA_InclusionCliente
	1234	//
	1235	// Descripción:
	1236	// Respuesta del servidor de administración a la petición de inicio enviando los datos identificativos del cliente y otras configuraciones
	1237	// Parámetros:
	1238	// trama: Trama recibida por el cliente desde el Servidor de Administración
	1239	// Devuelve:
	1240	// true si el registro ha tenido éxito o false en caso contrario
	1241	//______________________________________________________________________________________________________
	1242	int RESPUESTA_InclusionCliente(TRAMA *trama)
	1243	{
	1244	strcpy(Propiedades.idordenador,toma_parametro("ido",trama->parametros)); // Identificador del ordenador
	1245	strcpy(Propiedades.nombreordenador,toma_parametro("npc",trama->parametros)); // Nombre del ordenador
	1246	strcpy(Propiedades.idaula,toma_parametro("ida",trama->parametros)); // Identificador del aula a la que pertenece
	1247	strcpy(Propiedades.idperfilhard,toma_parametro("ifh",trama->parametros)); // Identificador del perfil hardware del ordenador
	1248	strcpy(Propiedades.servidorhidra,toma_parametro("hrd",trama->parametros)); // Dirección IP del servidor de Administración
	1249	strcpy(Propiedades.puerto,toma_parametro("prt",trama->parametros)); // Puerto de comunicación con el servidor de Administración
	1250	strcpy(Propiedades.iprepo,toma_parametro("ipr",trama->parametros)); // Dirección IP del repositorio
	1251	strcpy(Propiedades.puertorepo,toma_parametro("rep",trama->parametros)); // Puerto de comunicación con el repositorio
	1252	strcpy(Propiedades.cache,toma_parametro("che",trama->parametros)); // Tamaño de la cache
	1253
	1254	// Guarda items del menú
	1255	char* cabmenu=toma_parametro("cmn",trama->parametros);
	1256	if (cabmenu){
	1257	swmnu=true;
	1258	char *auxCab[15];
	1259	split_parametros(auxCab,cabmenu,"&"); // Caracter separador de los elementos de un item
	1260	strcpy(CabMnu.titulo,auxCab[0]); // Tìtulo del menú
	1261	strcpy(CabMnu.coorx,auxCab[1]); // Coordenada x del menú público
	1262	strcpy(CabMnu.coory,auxCab[2]); // Coordenada y del menú público
	1263	strcpy(CabMnu.modalidad,auxCab[3]); // Modalidad de columnas del menú público
	1264	strcpy(CabMnu.scoorx,auxCab[4]); // Coordenada x del menú privado
	1265	strcpy(CabMnu.scoory,auxCab[5]); // Coordenada y del menú privado
	1266	strcpy(CabMnu.smodalidad,auxCab[6]); // Modalidad de columnas del menú privado
	1267	strcpy(CabMnu.resolucion,auxCab[7]); // Resolución de pantalla
	1268	}
	1269	/char menu=toma_parametro("mnu",trama->parametros); // Menú estandar
	1270
	1271	char* auxMenu[MAXITEMS],auxItem[10];
	1272	int iMnu=split_parametros(auxMenu,menu,"?"); // Caracter separador de los item
	1273	int i,nitem;
	1274
	1275	for( i = 0; i<iMnu; i++){
	1276	struct s_Item Item;
	1277	nitem=split_parametros(auxItem,auxMenu[i],"&"); // Caracter separador de los elementos de un item
	1278	strcpy(Item.idaccionmenu,auxItem[0]); // Identificador de la acción
	1279	strcpy(Item.urlimg,auxItem[1]); // Url de la imagen del item
	1280	strcpy(Item.literal,auxItem[2]); // Literal del item
	1281	strcpy(Item.tipoitem,auxItem[3]); // Tipo de item ( Público o privado )
	1282	strcpy(Item.tipoaccion,auxItem[4]); // Tipo de acción ( Procedimiento,Tarea oTrabajo )
	1283	tbMenu[i]=Item;
	1284	}
	1285	contitems=i; // Número de items totales de los dos menús
	1286	*/
	1287	return(true);
	1288	}
	1289	//______________________________________________________________________________________________________
	1290	// Función: ComandosPendientes
	1291	//
	1292	// Parámetros:
	1293	// Ninguno
	1294	// Descripción:
	1295	// Búsqueda de acciones pendientes en el servidor de administración
	1296	//______________________________________________________________________________________________________
	1297	int ComandosPendientes()
	1298	{
	1299	CMDPTES=true;
	1300	while(CMDPTES){
	1301	sprintf(trama->parametros,"nfn=ComandosPendientes\r"); // Nombre de la función a ejecutar en el servidor de administración
	1302	if(AbreConexionTCP()){
	1303	if(!EnviaTramasHidra(sock,trama)){
	1304	UltimoError(21,"ComandosPendientes()"); // No se pudo recuperar la configuración hardware
	1305	return(false);
	1306	}
	1307	if(!recibe_tramas(sock,trama)){
	1308	UltimoError(22,"ComandosPendientes()"); // No se pudo recuperar la configuración hardware
	1309	return(false);
	1310	}
	1311	CierraConexionTCP();
	1312	GestionTramas(trama); // Analiza la trama
	1313	}
	1314	else{
	1315	UltimoError(2,"ComandosPendientes()"); // No se pudo conectar con el servidor de Administración
	1316	return(false);
	1317	}
	1318	}
	1319	CMDPTES=false;
	1320	return(true);
	1321	}
	1322	//_____________________________________________________________________________________________________
	1323	// Función: Arrancar
	1324	//
	1325	// Descripción:
	1326	// Contesta ante un comando de arrancar
	1327	// Parámetros:
	1328	// - trama: Trama recibida con las especificaciones del comando
	1329	// - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
	1330	// Devuelve:
	1331	// true siempre
	1332	//_____________________________________________________________________________________________________
	1333	int Arrancar(TRAMA trama,TRAMA nwtrama)
	1334	{
	1335	sprintf(nwtrama->parametros,"nfn=RESPUESTA_Arrancar\r");
	1336	return(RespuestaEjecucionComando(trama,nwtrama,true));
	1337	}
	1338	//_____________________________________________________________________________________________________
	1339	// Función: Apagar
	1340	//
	1341	// Descripción:
	1342	// Apaga el cliente
	1343	// Parámetros:
	1344	// - trama: Trama recibida con las especificaciones del comando
	1345	// - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
	1346	// Devuelve:
	1347	// true si el proceso fue correcto o false en caso contrario
	1348	//_____________________________________________________________________________________________________
	1349	int Apagar(TRAMA trama,TRAMA nwtrama)
	1350	{
	1351	int res;
	1352
	1353	sprintf(nwtrama->parametros,"nfn=RESPUESTA_Apagar\r");
	1354	res=RespuestaEjecucionComando(trama,nwtrama,true);
	1355	sprintf(cmdshell,"poweroff");
	1356	res=ExecBash(cmdshell);
	1357	if(!res){
	1358	UltimoErrorScript(10,"Reiniciar()"); // Se ha producido algún error
	1359	}
	1360	return(res);
	1361	}
	1362	//______________________________________________________________________________________________________
	1363	// Función: Reiniciar
	1364	//
	1365	// Descripción:
	1366	// Reinicia el cliente
	1367	// Parámetros:
	1368	// - trama: Trama recibida con las especificaciones del comando
	1369	// - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
	1370	// Devuelve:
	1371	// true si el proceso fue correcto o false en caso contrario
	1372	//______________________________________________________________________________________________________
	1373	int Reiniciar(TRAMA trama,TRAMA nwtrama)
	1374	{
	1375	int res;
	1376
	1377	sprintf(nwtrama->parametros,"nfn=RESPUESTA_Reiniciar\r");
	1378	res=RespuestaEjecucionComando(trama,nwtrama,true);
	1379	sprintf(cmdshell,"reboot");
	1380	res=ExecBash(cmdshell);
	1381	if(!res){
	1382	UltimoErrorScript(10,"Reiniciar()"); // Se ha producido algún error
	1383	}
	1384	return(res);
	1385	}
	1386	//______________________________________________________________________________________________________
	1387	// Función: IniciarSesion
	1388	//
	1389	// Descripción:
	1390	// Inicia Sesión en algún sistema operativo instalado en la máquina
	1391	// Parámetros:
	1392	// - trama: Trama recibida con las especificaciones del comando
	1393	// - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
	1394	// Devuelve:
	1395	// true si el proceso fue correcto o false en caso contrario
	1396	// *** En ese proceso se devuelve correcto aún sabiendo que no se se sabe si va a funcionar
	1397	// pero esto evita que si se ha lanzado con seguimiento, la tarea no quede sin norificar.
	1398	//______________________________________________________________________________________________________
	1399	int IniciarSesion(TRAMA trama,TRAMA nwtrama)
	1400	{
	1401	int res;
	1402	char *particion=toma_parametro("par",trama->parametros);
	1403	char disco=(char)ReservaMemoria(2);
	1404	sprintf(disco,"1"); // Siempre el disco 1
	1405
	1406	sprintf(nwtrama->parametros,"nfn=RESPUESTA_IniciarSesion\r");
	1407	res=RespuestaEjecucionComando(trama,nwtrama,true);
	1408	sprintf(cmdshell,"%s/admBootOs %s %s",HIDRASCRIPTS,disco,particion);
	1409	res=ExecBash(cmdshell);
	1410	if(!res){
	1411	UltimoErrorScript(10,"IniciarSesion()"); // Se ha producido algún error
	1412	}
	1413	return(res);
	1414	}
	1415	//______________________________________________________________________________________________________
	1416	// Función: Actualizar
	1417	//
	1418	// Descripción:
	1419	// Actualiza los datos de un ordenador como si volviera a solicitar la entrada en el sistema al servidor de administración
	1420	// Parámetros:
	1421	// Ninguno
	1422	// Devuelve:
	1423	// true si el proceso fue correcto o false en caso contrario
	1424	//______________________________________________________________________________________________________
	1425	int Actualizar()
	1426	{
	1427	int res;
	1428
	1429	MuestraMensaje(1,NULL);
	1430	res=InclusionCliente();
	1431	//cuestionCache(Propiedades.cache);
	1432	MuestraMenu(URLMENU);
	1433	//kill(pidmenu,SIGQUIT);
	1434	return(res);
	1435	}
	1436	//______________________________________________________________________________________________________
	1437	// Función: CrearPerfilSoftware
	1438	//
	1439	// Descripción:
	1440	// Genera una imagen de una partición
	1441	// Parámetros:
	1442	// - trama: Trama recibida con las especificaciones del comando
	1443	// - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
	1444	// Devuelve:
	1445	// true si el proceso fue correcto o false en caso contrario
	1446	//_____________________________________________________________________________________________________
	1447	int CrearPerfilSoftware(TRAMAtrama,TRAMAnwtrama)
	1448	{
	1449	int res=0;
	1450	char *wparticion=toma_parametro("par",trama->parametros); // Partición de donde se crear el perfil
	1451	char *widperfilsoft=toma_parametro("ifs",trama->parametros); // Perfil software a crear
	1452	char *widperfilhard=toma_parametro("ifh",trama->parametros); // Perfil hardware del ordenador
	1453	char *wnemonico=toma_parametro("nem",trama->parametros); // Nemónico del S.O. de la partición
	1454
	1455	char disco=(char)ReservaMemoria(2);
	1456	sprintf(disco,"1"); // Siempre el disco 1
	1457
	1458	char pathperfil[250];
	1459	sprintf(pathperfil,"%s/%s",HIDRACHEIMAGENES,wnemonico); // Path del perfil creado
	1460
	1461	char fileperfil[64];
	1462	sprintf(fileperfil,"PS%s_PH%s",widperfilsoft,widperfilhard); // Nombre de la imagen ( del perfil creado)
	1463
	1464	char filemasterboot[64];
	1465	sprintf(filemasterboot,"PS%s_PH%s.msb",widperfilsoft,widperfilhard); // Idem para el sector de arranque MBR
	1466	res=CrearPerfil(disco,fileperfil,pathperfil,wparticion,Propiedades.iprepo);
	1467	RegistraLog("Finalizada la creacion del perfil software",false);
	1468	int lon;
	1469	lon=sprintf(nwtrama->parametros,"nfn=RESPUESTA_CrearPerfilSoftware\r");
	1470	lon+=sprintf(nwtrama->parametros+lon,"ifs=%s\r",widperfilsoft);
	1471	lon+=sprintf(nwtrama->parametros+lon,"ifh=%s\r",widperfilhard);
	1472	RespuestaEjecucionComando(trama,nwtrama,res);
	1473	return(res);
	1474	}
	1475	//______________________________________________________________________________________________________
	1476	// Función: CrearPerfil
	1477	//
	1478	// Descripción:
	1479	// Crea una imagen de una partición
	1480	// Parámetros:
	1481	// -disco Disco a clonar 1,2,3..
	1482	// -fileimg Nombre de la imagen
	1483	// -pathimg Ruta de la imagen
	1484	// -particion Partición a clonar
	1485	// -iprepo Dirección IP del repositorio ( Si es la IP local el repositorio será la caché)
	1486	// Devuelve:
	1487	// true si el proceso fue correcto o false en caso contrario
	1488	//______________________________________________________________________________________________________
	1489	int CrearPerfil(char* disco,char* fileimg,char* pathimg,char* particion,char*iprepo)
	1490	{
	1491	int herror;
	1492
	1493	MuestraMensaje(2,NULL);
	1494
	1495	sprintf(cmdshell,"%s/admCreateImage",HIDRASCRIPTS);
	1496	sprintf(parametros,"%s %s %s %s %s","createImage",disco,particion,"REPO",fileimg);
	1497
	1498	if(ndebug>3){
	1499	sprintf(msglog,"Creando Imagen disco:%s, partición:%s, Repositorio:%s, Imagen:%s, Ruta:%s",disco,particion,Propiedades.iprepo,fileimg,"");
	1500	RegistraLog(msglog, false);
	1501	}
	1502
	1503	herror=EjecutarScript(cmdshell,parametros,NULL,true);
	1504	if(herror)
	1505	MuestraMensaje(10,NULL);
	1506	else
	1507	MuestraMensaje(9,NULL);
	1508	MuestraMenu(URLMENU);
	1509
	1510	if(herror){
	1511	UltimoErrorScript(herror,"CrearPerfil()"); // Se ha producido algún error
	1512	return(false);
	1513	}
	1514	else
	1515	return(true);
	1516	}
	1517	//______________________________________________________________________________________________________
	1518	// Función: Nemonico
	1519	//
	1520	// Descripción:
	1521	// Devuelve el código de un nemonico de S.O.
	1522	// Parámetros:
	1523	// -nem Nemonico del S.O.
	1524	// Devuelve:
	1525	// El código del nemónico
	1526	//______________________________________________________________________________________________________
	1527	int Nemonico(char* nem)
	1528	{
	1529	if(strcmp(nem,"MsDos")==0)
	1530	return(MsDos);
	1531	if(strcmp(nem,"Win98")==0)
	1532	return(Win98);
	1533	if(strcmp(nem,"Win2K")==0)
	1534	return(Win2K);
	1535	if(strcmp(nem,"WinXP")==0)
	1536	return( WinXP);
	1537	if(strcmp(nem,"Linux")==0)
	1538	return(Linux);
	1539	return(0);
	1540	}
	1541	//______________________________________________________________________________________________________
	1542	// Función: RestaurarImagen
	1543	//
	1544	// Descripción:
	1545	// Restaura una imagen en una partición
	1546	// Parámetros:
	1547	// - trama: Trama recibida con las especificaciones del comando
	1548	// - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
	1549	// Devuelve:
	1550	// true si el proceso fue correcto o false en caso contrario
	1551	//______________________________________________________________________________________________________
	1552	int RestaurarImagen(TRAMAtrama,TRAMAnwtrama)
	1553	{
	1554	int res=0;
	1555	int idxpath;
	1556
	1557	char disco=(char)ReservaMemoria(2);
	1558	sprintf(disco,"1"); // Siempre el disco 1
	1559
	1560	char *wparticion=toma_parametro("par",trama->parametros); // partición de donde se crear el perfil
	1561	char *widimagen=toma_parametro("idi",trama->parametros); // Identificador de la imagen
	1562	char *widperfilsoft=toma_parametro("ifs",trama->parametros); // Perfil software
	1563	char *widperfilhard=toma_parametro("ifh",trama->parametros); // Perfil hardware
	1564	char *wpathimagen=toma_parametro("pth",trama->parametros); // Indica si la imagen se descargar de la caché o del repositorio
	1565	char *wprotclona=toma_parametro("mcl",trama->parametros); // Protocolo de clonacion
	1566	char *widenvio=toma_parametro("ide",trama->parametros); // Identificador del envio
	1567	char *wnipes=toma_parametro("nip",trama->parametros); // Ipes de los clientes
	1568
	1569	if(wpathimagen=='\0') wpathimagen="1"; // Por defecto de caché
	1570	idxpath=atoi(wpathimagen);
	1571	if(!CACHEEXISTS) idxpath=2; // Sin no existe cache siempre desde el servidor
	1572
	1573	char fileperfil[64];
	1574	sprintf(fileperfil,"PS%s_PH%s",widperfilsoft,widperfilhard); // Nombre del fichero del perfil creado
	1575	res=RestaurandoImagen(disco,fileperfil,wparticion,tbPathImg[idxpath],wprotclona,widenvio,wnipes);
	1576
	1577	// Toma la nueva configuración
	1578	char *parametroscfg=LeeConfiguracion(disco);
	1579	RegistraLog("Finalizada la restauracion de imagen", false);
	1580
	1581	int lon;
	1582	lon=sprintf(nwtrama->parametros,"nfn=RESPUESTA_RestaurarImagen\r");
	1583	lon+=sprintf(nwtrama->parametros+lon,"cfg=%s\r",parametroscfg);
	1584	lon+=sprintf(nwtrama->parametros+lon,"idi=%s\r",widimagen);
	1585	lon+=sprintf(nwtrama->parametros+lon,"par=%s\r",wparticion);
	1586	RespuestaEjecucionComando(trama,nwtrama,res);
	1587	return(res);
	1588	}
	1589	//______________________________________________________________________________________________________
	1590	// Función: RestaurandoImagen
	1591	//
	1592	// Descripción:
	1593	// Restaura na imagen en una partición
	1594	// Parámetros:
	1595	// -disco Disco a clonar 1,2,3..
	1596	// -fileimg Nombre de la imagen
	1597	// -particion Partición a clonar
	1598	// -pathImg Ruta de la imagen
	1599	// -protclona Protocolo de clonación para la imagen
	1600	// -idenvio Identificador de la sesión Multicast
	1601	// -nipes Número de ordenadores
	1602	// Devuelve:
	1603	// true si el proceso fue correcto o false en caso contrario
	1604	//____________________________________________________________________________________________________
	1605	int RestaurandoImagen(char* disco,char fileimg,char particion,char pathImg,char protclona,char* idenvio,char *nipes)
	1606	{
	1607	int herror;
	1608
	1609	MuestraMensaje(3,NULL);
	1610
	1611	sprintf(cmdshell,"%s/admRestoreImage",HIDRASCRIPTS);
	1612	sprintf(parametros,"%s %s %s %s %s %s %s %s","admRestoreImage",pathImg,fileimg,disco,particion,protclona,idenvio,nipes);
	1613
	1614	herror=EjecutarScript(cmdshell,parametros,NULL,true);
	1615	if(herror) // Restauración correcta
	1616	MuestraMensaje(12,NULL);
	1617	else
	1618	MuestraMensaje(11,NULL);
	1619	MuestraMenu(URLMENU);
	1620
	1621	if(herror){
	1622	UltimoErrorScript(herror,"RestaurandoImagen()"); // Se ha producido algún error
	1623	return(false);
	1624	}
	1625	else{
	1626	if(strcmp(protclona,"MULTICAST")==0){
	1627	if(!sesionMulticast(idenvio,nipes))
	1628	RegistraLog("***Error en el proceso de preparación de transferencia multicast", false);
	1629	}
	1630	return(true);
	1631	}
	1632	}
	1633	//______________________________________________________________________________________________________
	1634	// Función: ParticionaryFormatear
	1635	//
	1636	// Descripción:
	1637	// Modifica la tabla de particiones del sector de arranque master y formatea particiones
	1638	// Parámetros:
	1639	// - trama: Trama recibida con las especificaciones del comando
	1640	// - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
	1641	// Devuelve:
	1642	// true si el proceso fue correcto o false en caso contrario
	1643	//____________________________________________________________________________________________________
	1644	int ParticionaryFormatear(TRAMAtrama,TRAMAnwtrama)
	1645	{
	1646	int res,i,parfor;
	1647	char* parametroscfg;
	1648	char ch[2],*parhdc[8];
	1649	char *PrimaryPartitions=toma_parametro("ppa",trama->parametros);
	1650	char *LogicalPartitions=toma_parametro("lpa",trama->parametros);
	1651	char *HDCleanPartition=toma_parametro("hdc",trama->parametros);
	1652
	1653	char disco=(char)ReservaMemoria(2);
	1654	sprintf(disco,"1"); // Siempre el disco 1
	1655
	1656
	1657	RegistraLog("Creando o modificando tabla de particiones", false);
	1658	//Pantallas
	1659	MuestraMensaje(4,NULL);
	1660	res=Particionar(disco,PrimaryPartitions,LogicalPartitions); // Creando las particiones
	1661	if(res)
	1662	MuestraMensaje(13,NULL);
	1663	else
	1664	MuestraMensaje(14,NULL);
	1665
	1666	if(res){
	1667	strcpy(ch,";"); // Caracter delimitador
	1668	parfor=split_parametros(parhdc,HDCleanPartition,ch);
	1669	for(i = 0; i<parfor; i++){ // Formateando particiones
	1670	//Pantallas
	1671	MuestraMensaje(5,NULL);
	1672	res=Formatear(disco,parhdc[i]);
	1673	if(res)
	1674	MuestraMensaje(15,NULL);
	1675	else
	1676	MuestraMensaje(16,NULL);
	1677	if(!res) break;
	1678	}
	1679	}
	1680	MuestraMenu(URLMENU);
	1681	RegistraLog("Finalizado el particionado y formateado de particiones", false);
	1682	parametroscfg=LeeConfiguracion(disco); // Toma la nueva configuración
	1683
	1684	int lon;
	1685	lon=sprintf(nwtrama->parametros,"nfn=RESPUESTA_ParticionaryFormatear\r");
	1686	lon+=sprintf(nwtrama->parametros+lon,"cfg=%s\r",parametroscfg);
	1687	RespuestaEjecucionComando(trama,nwtrama,res);
	1688
	1689	return(res);
	1690	}
	1691	//______________________________________________________________________________________________________
	1692	// Función: Particionar
	1693	//
	1694	// Descripción:
	1695	// Modifica la tabla de particiones del sector de arranque master pero SIN formatear ninguna partición
	1696	// Parámetros:
	1697	// - disco: Número del disco
	1698	// - PrParticion: Cadena con la sintaxis de particionado de las particiones primarias
	1699	// - LoParticion: Cadena con la sintaxis de particionado de las particiones secundarias
	1700	// Devuelve:
	1701	// true si el proceso fue correcto o false en caso contrario
	1702	//______________________________________________________________________________________________________
	1703	int Particionar(char* disco,char* PrParticion,char* LoParticion)
	1704	{
	1705	if (strlen(PrParticion)>0){
	1706	if(Particionando(disco,PrParticion,"admCreatePrimaryPartitions")){ // Particiones Primarias
	1707	if (strlen(LoParticion)>0)
	1708	return(Particionando(disco,PrParticion,"admCreateLogicalPartitions")); // Particiones Logicas
	1709	else
	1710	return(true);
	1711	}
	1712	else
	1713	return(false);
	1714	}
	1715	if (strlen(LoParticion)>0)
	1716	return(Particionando(disco,PrParticion,"admCreateLogicalPartitions"));
	1717	else
	1718	return(false);
	1719	}
	1720	//______________________________________________________________________________________________________
	1721	// Función: Particionando
	1722	//
	1723	// Descripción:
	1724	// Modifica la tabla de particiones del sector de arranque master pero SIN formatear ninguna partición
	1725	// Parámetros:
	1726	// - disco: Disco en el que se modificará la tabla de particiones 1,2,3..
	1727	// - StxParticion: Cadena con la sintaxis de particionado de las particiones primarias
	1728	// - script: Nombre del script que se ejecutará
	1729	// Devuelve:
	1730	// true si el proceso fue correcto o false en caso contrario
	1731	// Especificaciones:
	1732	// Esta función es auxiliar de la anterior y es llamda por esta en dos ocasiones, para las particiones Primarias y Lógicas
	1733	//______________________________________________________________________________________________________
	1734	int Particionando(char* disco,char* stxParticion,char* script)
	1735	{
	1736	int herror;
	1737
	1738	sprintf(cmdshell,"%s/%s",HIDRASCRIPTS,script);
	1739	sprintf(parametros,"%s %s %s",script,disco,stxParticion);
	1740
	1741	sprintf(msglog,"Modificando tabla de particiones:%s disco:%s, cadena:%s",script,disco,stxParticion);
	1742	if(ndebug>1){
	1743	RegistraLog(msglog, false);
	1744	}
	1745	herror=EjecutarScript(cmdshell,parametros,NULL,true);
	1746	if(herror){
	1747	UltimoErrorScript(herror,"Particionar()"); // Se ha producido algún error
	1748	return(false);
	1749	}
	1750	else
	1751	return(true);
	1752	}
	1753	//______________________________________________________________________________________________________
	1754	// Función: Formatear
	1755	//
	1756	// Descripción:
	1757	// Formatea una partición
	1758	// Parámetros:
	1759	// - disco: Número del disco
	1760	// - particion: Número de partición a formatear
	1761	// Devuelve:
	1762	// true si el proceso fue correcto o false en caso contrario
	1763	//______________________________________________________________________________________________________
	1764	int Formatear(char* disco,char* particion)
	1765	{
	1766	int herror;
	1767
	1768	sprintf(cmdshell,"%s/admFormatFs",HIDRASCRIPTS);
	1769	sprintf(parametros,"%s %s %s","FormatFs",disco,particion);
	1770	herror=EjecutarScript(cmdshell,parametros,NULL,true);
	1771	if(herror){
	1772	UltimoErrorScript(herror,"Formatear()"); // Se ha producido algún error
	1773	return(false);
	1774	}
	1775	return(true);
	1776	}
	1777	//______________________________________________________________________________________________________
	1778	// Función: SetCachePartitionSize
	1779	//
	1780	// Descripción:
	1781	// Dimensiona el tamaño de la caché
	1782	// Parámetros:
	1783	// - t : Tamaño a asignar de la caché
	1784	// Devuelve:
	1785	// true si el proceso fue correcto o false en caso contrario
	1786	// ________________________________________________________________________________________________________
	1787	int SetCachePartitionSize(int t)
	1788	{
	1789	return(true);
	1790	}
	1791	//___________________________________________________________________________________________________
	1792	//
	1793	//
	1794	//______________________________________________________________________________________________________
	1795	// Función: AutoexecClienteHidra
	1796	//
	1797	// Parámetros:
	1798	// Ninguno
	1799	// Descripción:
	1800	// Ejecuta un fichero autoexec preparado para el cliente
	1801	// ________________________________________________________________________________________________________
	1802	int AutoexecClienteHidra()
	1803	{
	1804	sprintf(fileini,"/autoexec/INI_%s",Propiedades.IPlocal); // Nombre del fichero autoexec
	1805	if(ExisteFichero(fileini)){
	1806	if(LoadTextFile(fileini)){ // Lee fichero autoexec
	1807	GestionTramas(trama); // Analiza la trama
	1808	}
	1809	else{
	1810	UltimoError(6,"AutoexecClienteHidra()");
	1811	return(false);
	1812	}
	1813	}
	1814	return(true);
	1815	}
	1816	//______________________________________________________________________________________________________
	1817	// Función: LeeConfiguracion
	1818	//
	1819	// Descripción:
	1820	// Recupera la configuración de particiones del ordenador
	1821	// Parámetros:
	1822	// disco: Disco a analizar 1,2,3..
	1823	// Devuelve:
	1824	// Una cadena con la configuración del cliente (ver manual)
	1825	// ________________________________________________________________________________________________________
	1826	char* LeeConfiguracion(char* disco)
	1827	{
	1828	int herror;
	1829	char *cadenaparticiones;
	1830	char *nomso;
	1831
	1832	cadenaparticiones=(char*)ReservaMemoria(LONGITUD_SCRIPTSALIDA);
	1833	sprintf(cmdshell,"%s/admListPrimaryPartitions",HIDRASCRIPTS);
	1834	sprintf(parametros,"%s %s","admListPrimaryPartitions",disco);
	1835	herror=EjecutarScript(cmdshell,parametros,cadenaparticiones,true);
	1836	if(herror){
	1837	UltimoErrorScript(herror,"LeeConfiguracion()"); // Se ha producido algún error
	1838	return(NULL);
	1839	}
	1840	struct s_Particiones *tbcfg[MAXPARTICIONES];
	1841	char duplasparticiones[MAXPARTICIONES],duplaparticion[2];
	1842
	1843	int iPar=split_parametros(duplasparticiones,cadenaparticiones," "); // Caracter separatorio de los elementos de un item
	1844
	1845	if(ndebug>4){
	1846	sprintf(msglog,"Número de particiones detectadas %d",iPar);
	1847	RegistraLog(msglog,false);
	1848	}
	1849	int i,j;
	1850	for( i = 0; i<iPar; i++){
	1851	split_parametros(duplaparticion,duplasparticiones[i],":");
	1852	tbcfg[i]=(struct s_Particiones*)ReservaMemoria(sizeof(struct s_Particiones)); // Toma espacio para tabla de configuraciones
	1853	strcpy(tbcfg[i]->tipopart,duplaparticion[0]); // Tipo de partición
	1854	strcpy(tbcfg[i]->tamapart,duplaparticion[1]); // Tamaño de partición
	1855	sprintf(tbcfg[i]->numpart,"%d",i+1); // Número de partición
	1856
	1857	for(j=0;j<ntiposo;j++){
	1858	if(strcmp(tiposos[j].tipopart,duplaparticion[0])==0 && strcmp(tiposos[j].tipopart,"LINUX-SWAP")!=0 && strcmp(tiposos[j].tipopart,"EMPTY")!=0){
	1859	nomso=TomaNomSO(disco,i+1);
	1860	if(nomso!=NULL){ // Averigua qué sistema operativo está instalado en la partición
	1861	strcpy(tbcfg[i]->tiposo,tiposos[j].tiposo); // Nombre S.O.
	1862	strcpy(tbcfg[i]->nombreso,nomso); // Nombre completo S.O.
	1863	}
	1864	else{
	1865	strcpy(tbcfg[i]->tiposo,""); // Nombre S.O.
	1866	strcpy(tbcfg[i]->nombreso,""); // Nombre completo S.O.
	1867	}
	1868	break;
	1869	}
	1870	}
	1871	}
	1872	char *cfg=ReservaMemoria(LONGITUD_CONFIGURACION);
	1873	if(!cfg){
	1874	UltimoError(1,"LeeConfiguracion()");
	1875	return(NULL);
	1876	}
	1877	int lon=0;
	1878	for( i = 0; i<iPar; i++){
	1879	lon+=sprintf(cfg+lon,"@cfg\n");
	1880	lon+=sprintf(cfg+lon,"tiposo=%s\n",tbcfg[i]->tiposo);
	1881	lon+=sprintf(cfg+lon,"tipopart=%s\n",tbcfg[i]->tipopart);
	1882	lon+=sprintf(cfg+lon,"tamapart=%s\n",tbcfg[i]->tamapart);
	1883	lon+=sprintf(cfg+lon,"numpart=%s\n",tbcfg[i]->numpart);
	1884	lon+=sprintf(cfg+lon,"nombreso=%s\t",tbcfg[i]->nombreso);
	1885	}
	1886	return(cfg);
	1887	}
	1888	//______________________________________________________________________________________________________
	1889	// Función: TomaNomSO
	1890	//
	1891	// Descripción:
	1892	// Recupera el nombre del sistema operativo instalado en una partición
	1893	// Parámetros:
	1894	// disco: Disco 1,2,3..
	1895	// particion: Número de la partición
	1896	// Devuelve:
	1897	// Una cadena con el nombre del S.O.
	1898	// ________________________________________________________________________________________________________
	1899	char* TomaNomSO(char*disco,int particion)
	1900	{
	1901	int herror,lon;
	1902	char *infosopar;
	1903	char* sover[2];
	1904	char ch[2];
	1905
	1906	infosopar=(char*)ReservaMemoria(LONGITUD_SCRIPTSALIDA); // Información del S.O. de la partición
	1907
	1908	sprintf(cmdshell,"%s/admGetOsVersion",HIDRASCRIPTS);
	1909	sprintf(parametros,"%s %s %d","admGetOsVersion",disco,particion);
	1910	herror=EjecutarScript(cmdshell,parametros,infosopar,true);
	1911	if(herror){
	1912	UltimoErrorScript(herror,"TomaNomSO()"); // Se ha producido algún error
	1913	return(NULL);
	1914	}
	1915	if(strlen(infosopar)==0) return(NULL); // NO Existe S.O. en la partición
	1916	strcpy(ch,":");// caracter delimitador (dos puntos)
	1917	lon=split_parametros(sover,infosopar,ch);
	1918	return(sover[1]);
	1919	}
	1920	//______________________________________________________________________________________________________
	1921	// Función: MuestraMenu
	1922	//
	1923	// Descripción:
	1924	// Muestra menú del cliente
	1925	// Parámetros:
	1926	//
	1927	// urp: Path o url de la página web que muestra el menu del cliente
	1928	//
	1929	// Devuelve:
	1930	// True si muestra el menú
	1931	// ________________________________________________________________________________________________________
	1932	int MuestraMenu(char *urp)
	1933	{
	1934	return(true);
	1935
	1936	int nargs,resul;
	1937
	1938	if(ndebug>4){
	1939	sprintf(msglog,"Url:%s",urp);
	1940	RegistraLog(msglog, false);
	1941	}
	1942
	1943	if(pidmenu>0)
	1944	kill(pidmenu,SIGQUIT); // Se carga el proceso hijo anterior y se queda sólo el actual
	1945
	1946	//sprintf(cmdshell,"%s/admMenuBrowser",HIDRASCRIPTS);
	1947	//sprintf(parametros,"%s %s","admMenuBrowser",urp);
	1948
	1949	sprintf(cmdshell,"/opt/opengnsys/bin/browser");
	1950	sprintf(parametros,"%s %s %s","browser","-qws",urp);
	1951
	1952	nargs=split_parametros(argumentos,parametros," "); // Crea matriz de los argumentos del scripts
	1953	if((pidmenu=fork())==0){
	1954	/* Proceso hijo que ejecuta el script */
	1955	resul=execv(cmdshell,argumentos);
	1956	exit(resul);
	1957	}
	1958	else {
	1959	if (pidmenu ==-1){
	1960	UltimoErrorScript(23,"MuestraMenu()"); // Se ha producido algún error
	1961	return(false);
	1962	}
	1963	}
	1964	return(true);
	1965	}
	1966	//______________________________________________________________________________________________________
	1967	// Función: MuestraMensaje
	1968	//
	1969	// Descripción:
	1970	// Envia una página al browser con un mensaje determinado
	1971	// Parámetros:
	1972	// - idx: Indice de la cadena del mensaje
	1973	// - msg: Mensaje
	1974	// ________________________________________________________________________________________________________
	1975	void MuestraMensaje(int idx,char*msg){
	1976	if(msg)
	1977	sprintf(urlpag,"%s?msg=%s",URLMSG,URLEncode(msg)); // Url de la página de mensajes
	1978	else
	1979	sprintf(urlpag,"%s?idx=%d",URLMSG,idx); // Url de la página de mensajes
	1980	MuestraMenu(urlpag);
	1981	}
	1982	//______________________________________________________________________________________________________
	1983	// Función: InventarioHardware
	1984	//
	1985	// Descripción:
	1986	// Recupera la configuración de hardware del ordenador
	1987	// Parámetros:
	1988	// - trama: Trama recibida con las especificaciones del comando
	1989	// - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
	1990	// Devuelve:
	1991	// true si el proceso fue correcto o false en caso contrario
	1992	// Especificaciones:
	1993	// Lo que se envía al servidor es una cadena con el formato de salida del script que ejecuta
	1994	// está función. (Vease scripts hidraHardwareInfo)
	1995	// ________________________________________________________________________________________________________
	1996	int InventarioHardware(TRAMA trama,TRAMA nwtrama)
	1997	{
	1998	int herror,res;
	1999	char *parametroshrd;
	2000
	2001	MuestraMensaje(6,NULL);
	2002
	2003	parametroshrd=(char*)ReservaMemoria(LONGITUD_SCRIPTSALIDA);
	2004	sprintf(cmdshell,"%s/admListHardwareInfo",HIDRASCRIPTS);
	2005
	2006	herror=EjecutarScript(cmdshell,NULL,parametroshrd,true);
	2007
	2008	if(herror)
	2009	MuestraMensaje(0,msglog);
	2010	else
	2011	MuestraMensaje(17,NULL);
	2012	MuestraMenu(URLMENU);
	2013
	2014	if(herror){
	2015	UltimoErrorScript(herror,"InventarioHardware()"); // Se ha producido algún error
	2016	}
	2017	res=(herror==0); // Si se ha producido algún error el resultado de la ejecución de error
	2018
	2019	int lon;
	2020	lon=sprintf(nwtrama->parametros,"nfn=RESPUESTA_TomaHardware\r");
	2021	lon+=sprintf(nwtrama->parametros+lon,"hrd=%s\r",parametroshrd);
	2022	lon+=sprintf(nwtrama->parametros+lon,"ipr=%s\r",Propiedades.iprepo);
	2023	lon+=sprintf(nwtrama->parametros+lon,"rep=%s\r",Propiedades.puertorepo);
	2024
	2025	RespuestaEjecucionComando(trama,nwtrama,res);
	2026	return(res);
	2027	}
	2028	//______________________________________________________________________________________________________
	2029	// Función: InventarioSoftware
	2030	//
	2031	// Descripción:
	2032	// Recupera la configuración de software del ordenador
	2033	// Parámetros:
	2034	// - trama: Trama recibida con las especificaciones del comando
	2035	// - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
	2036	// Devuelve:
	2037	// true si el proceso fue correcto o false en caso contrario
	2038	// Especificaciones:
	2039	// Lo que se envía al servidor es una cadena con el formato de salida del script que ejecuta
	2040	// está función. (Vease scripts hidraSoftwareInfo)
	2041	// ________________________________________________________________________________________________________
	2042	int InventarioSoftware(TRAMA trama,TRAMA nwtrama)
	2043	{
	2044	int herror,res;
	2045	char parametrossft,infopar;
	2046	char *particion=toma_parametro("par",trama->parametros); // Toma partición
	2047	//char *tipo=toma_parametro("tpl",trama->parametros); // Toma tipo de listado
	2048
	2049	char disco=(char)ReservaMemoria(2);
	2050	sprintf(disco,"1"); // Siempre el disco 1
	2051
	2052	MuestraMensaje(7,NULL);
	2053
	2054	sprintf(cmdshell,"%s/admListSoftwareInfo",HIDRASCRIPTS);
	2055	sprintf(parametros,"%s %s %s","admListSoftwareInfo",disco,particion);
	2056
	2057	parametrossft=(char*)ReservaMemoria(LONGITUD_SCRIPTSALIDA);
	2058
	2059	herror=EjecutarScript(cmdshell,parametros,parametrossft,true);
	2060	if(herror)
	2061	MuestraMensaje(20,NULL);
	2062	else
	2063	MuestraMensaje(19,NULL);
	2064	MuestraMenu(URLMENU);
	2065
	2066	if(herror){
	2067	UltimoErrorScript(herror,"InventarioSoftware()"); // Se ha producido algún error
	2068	}
	2069	res=(herror==0); // Si se ha producido algún error el resultado de la ejecución de error
	2070	// Toma tipo de partición
	2071	infopar=(char*)ReservaMemoria(16); //Tipo de partición
	2072	if(res && infopar){
	2073	sprintf(cmdshell,"%s/admGetFsType",HIDRASCRIPTS);
	2074	sprintf(parametros,"%s %s %s","getFsType",disco,particion);
	2075	herror=EjecutarScript(cmdshell,parametros,infopar,true);
	2076	if(herror){
	2077	UltimoErrorScript(herror,"InventarioSoftware()"); // Se ha producido algún error
	2078	}
	2079	}
	2080	int lon;
	2081	lon=sprintf(nwtrama->parametros,"nfn=RESPUESTA_TomaSoftware\r");
	2082	lon+=sprintf(nwtrama->parametros+lon,"sft=%s\r",parametrossft);
	2083	lon+=sprintf(nwtrama->parametros+lon,"par=%s\r",particion);
	2084	lon+=sprintf(nwtrama->parametros+lon,"tfs=%s\r",infopar);
	2085	lon+=sprintf(nwtrama->parametros+lon,"ipr=%s\r",Propiedades.iprepo);
	2086	lon+=sprintf(nwtrama->parametros+lon,"rep=%s\r",Propiedades.puertorepo);
	2087
	2088	RespuestaEjecucionComando(trama,nwtrama,res);
	2089	return(res);
	2090	}
	2091	//______________________________________________________________________________________________________
	2092	// Función: TomaConfiguracion
	2093	//
	2094	// Descripción:
	2095	// Toma la configuración de particiones de un ordenador
	2096	// Parámetros:
	2097	// - trama: Trama recibida con las especificaciones del comando
	2098	// - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
	2099	// Devuelve:
	2100	// true si el proceso fue correcto o false en caso contrario
	2101	// ________________________________________________________________________________________________________
	2102	int TomaConfiguracion(TRAMA trama,TRAMA nwtrama)
	2103	{
	2104	char* parametroscfg;
	2105
	2106	char disco=(char)ReservaMemoria(2);
	2107	sprintf(disco,"1"); // Siempre el disco 1
	2108
	2109	parametroscfg=LeeConfiguracion(disco);
	2110
	2111	int lon;
	2112	lon=sprintf(nwtrama->parametros,"nfn=RESPUESTA_TomaConfiguracion\r");
	2113	lon+=sprintf(nwtrama->parametros+lon,"cfg=%s\r",parametroscfg);
	2114	RespuestaEjecucionComando(trama,nwtrama,true);
	2115
	2116	return(true);
	2117	}
	2118	//______________________________________________________________________________________________________
	2119	// Función: ExecShell
	2120	//
	2121	// Descripción:
	2122	// Ejecuta un script de la Shell
	2123	// Parámetros:
	2124	// - trama: Trama recibida con las especificaciones del comando
	2125	// - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
	2126	// Devuelve:
	2127	// true si el proceso fue correcto o false en caso contrario
	2128	// ________________________________________________________________________________________________________
	2129	int ExecShell(TRAMA trama,TRAMA nwtrama)
	2130	{
	2131	int res;
	2132
	2133	char* wscript=toma_parametro("scp",trama->parametros); // Código del script
	2134	char* codigo=URLDecode(wscript); // Decodifica el código recibido con formato URLCode
	2135
	2136	//Pantallas
	2137	MuestraMensaje(8,NULL);
	2138	res=ExecBash(codigo);
	2139	if(res)
	2140	MuestraMensaje(21,NULL);
	2141	else
	2142	MuestraMensaje(22,NULL);
	2143	MuestraMenu(URLMENU);
	2144
	2145	if(!res){
	2146	UltimoErrorScript(10,"ExecShell()"); // Se ha producido algún error
	2147	}
	2148
	2149	char disco=(char)ReservaMemoria(2);
	2150	sprintf(disco,"1"); // Siempre el disco 1
	2151	char* parametroscfg=LeeConfiguracion(disco);
	2152	int lon;
	2153	lon=sprintf(nwtrama->parametros,"nfn=RESPUESTA_ExecShell\r");
	2154	lon+=sprintf(nwtrama->parametros+lon,"cfg=%s\r",parametroscfg);
	2155	RespuestaEjecucionComando(trama,nwtrama,res);
	2156	return(true);
	2157	}
	2158	//______________________________________________________________________________________________________
	2159	// Función: ConsolaRemota
	2160	//
	2161	// Descripción:
	2162	// Ejecuta un comando de la Shell y envia el eco al servidor (Consola remota)
	2163	// Parámetros:
	2164	// - trama: Trama recibida con las especificaciones del comando
	2165	// - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
	2166	// Devuelve:
	2167	// true siempre
	2168	// ________________________________________________________________________________________________________
	2169	int ConsolaRemota(TRAMA trama,TRAMA nwtrama)
	2170	{
	2171	FILE* f;
	2172	long lSize;
	2173	int herror;
	2174
	2175	char* comando=toma_parametro("cmd",trama->parametros); // Código del comando
	2176	sprintf(filecmdshell,"%s/%s","/tmp","_hidrascript_");
	2177	f = fopen(filecmdshell,"wt"); // Abre fichero de script
	2178	if(f==NULL)
	2179	RegistraLog("*** No se puede crear fichero temporal para ejecutar la consola remota", false);
	2180	else{
	2181	lSize=strlen(comando);
	2182	fwrite(comando,1,lSize,f); // Escribe el código a ejecutar
	2183	fclose(f);
	2184	sprintf(cmdshell,"/bin/chmod"); // Da permiso de ejecución al fichero
	2185	sprintf(parametros,"%s %s %s","/bin/chmod","+x",filecmdshell);
	2186	herror=EjecutarScript(cmdshell,parametros,NULL,true);
	2187	if(herror){
	2188	UltimoErrorScript(herror,"ConsolaRemota()"); // Se ha producido algún error
	2189	}
	2190	else{
	2191	sprintf(cmdshell,"%s/remoteConsole",HIDRASCRIPTS);
	2192	herror=EjecutarScript(cmdshell,NULL,NULL,true);
	2193	if(herror){
	2194	UltimoErrorScript(herror,"ExecBash()"); // Se ha producido algún error
	2195	}
	2196	}
	2197	}
	2198	return(true);
	2199	}
	2200	//______________________________________________________________________________________________________
	2201	// Función: ExecBash
	2202	//
	2203	// Descripción:
	2204	// Ejecuta código bash
	2205	// Parámetros:
	2206	// - codigo: Código a ejecutar
	2207	// Devuelve:
	2208	// true si el proceso fue correcto o false en caso contrario
	2209	// ________________________________________________________________________________________________________
	2210	int ExecBash(char*codigo){
	2211	FILE* f;
	2212	long lSize;
	2213	int herror,res;
	2214
	2215	sprintf(filecmdshell,"%s/%s","/tmp","_hidrascript_");
	2216	f = fopen(filecmdshell,"wt"); // Abre fichero de script
	2217	if(f==NULL)
	2218	res=false; // Error de apertura del fichero de configuración
	2219	else{
	2220	lSize=strlen(codigo);
	2221	fwrite(codigo,1,lSize,f); // Escribe el código a ejecutar
	2222	fclose(f);
	2223	sprintf(cmdshell,"/bin/chmod"); // Da permiso de ejecución al fichero
	2224	sprintf(parametros,"%s %s %s","/bin/chmod","+x",filecmdshell);
	2225	herror=EjecutarScript(cmdshell,parametros,NULL,true);
	2226	if(herror){
	2227	UltimoErrorScript(herror,"ExecBash()"); // Se ha producido algún error
	2228	res=false;
	2229	}
	2230	else{
	2231	sprintf(cmdshell,"%s",filecmdshell); // Ejecución el fichero de script creado
	2232	//int herror=EjecutarScript(cmdshell,NULL,NULL,true);
	2233	int herror=system(cmdshell);
	2234	if(herror){
	2235	UltimoErrorScript(herror,"ExecBash()"); // Se ha producido algún error
	2236	res=false;
	2237	}
	2238	}
	2239	}
	2240	return(res);
	2241	}
	2242	//______________________________________________________________________________________________________
	2243	// Función: URLDecode
	2244	//
	2245	// Descripción:
	2246	// Decodifica una cadena codificada con UrlEncode
	2247	// Parámetros:
	2248	// - src: La cadena a decodificar
	2249	// Devuelve:
	2250	// La cadena decodificada
	2251	// ________________________________________________________________________________________________________
	2252	char* URLDecode(char *src)
	2253	{
	2254	const char *p = src;
	2255	char code[3] = {0};
	2256	unsigned long ascii = 0;
	2257	char *end = NULL;
	2258	char dest,cad;
	2259
	2260	dest=(char*)ReservaMemoria(strlen(src)); // Reserva buffer para la cadena
	2261	cad=dest;
	2262	while(*p){
	2263	if(*p == '%'){
	2264	memcpy(code, ++p, 2);
	2265	ascii = strtoul(code, &end, 16);
	2266	*dest++ = (char)ascii;
	2267	p += 2;
	2268	}
	2269	else
	2270	dest++ = p++;
	2271	}
	2272	return(cad);
	2273	}
	2274	//______________________________________________________________________________________________________
	2275	// Función: URLEncode
	2276	//
	2277	// Descripción:
	2278	// Codifica una cadena en UrlEncode
	2279	// Parámetros:
	2280	// - src: La cadena a decodificar
	2281	// Devuelve:
	2282	// La cadena decodificada
	2283	// ________________________________________________________________________________________________________
	2284	char* URLEncode(char *src)
	2285	{
	2286	char *dest;
	2287	int i,j=0,lon;
	2288
	2289	lon=strlen(src);
	2290	dest=(char)ReservaMemoria(lon2); // Reserva buffer para la cadena
	2291	for(i=0;i<lon;i++){
	2292	if(src[i]==0x20){ // Espacio
	2293	dest[j++] = '%';
	2294	dest[j++] = '2';
	2295	dest[j++] = '0';
	2296	}
	2297	else
	2298	dest[j++] = src[i];
	2299	}
	2300	return(dest);
	2301	}
	2302	//______________________________________________________________________________________________________
	2303	// Función: RespuestaEjecucionComando
	2304	//
	2305	// Descripción:
	2306	// Envia una respuesta a una ejecución de comando al servidor de Administración
	2307	// Parámetros:
	2308	// - trama: Trama recibida con las especificaciones del comando
	2309	// - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
	2310	// - res: Resultado de la ejecución (true si la ejecución es correcta y false en caso contrario)
	2311	// Devuelve:
	2312	// true si la respuesta se envía correctamente al servidor
	2313	// ________________________________________________________________________________________________________
	2314	int RespuestaEjecucionComando(TRAMA* trama, TRAMA *nwtrama, int res)
	2315	{
	2316	int idsuceso=0;
	2317	char *widsuceso=toma_parametro("ids",trama->parametros);
	2318	if(widsuceso) idsuceso=atoi(widsuceso);
	2319	int lon;
	2320	lon=strlen(nwtrama->parametros);
	2321	lon+=sprintf(nwtrama->parametros+lon,"ids=%d\r",idsuceso); // Identificador del suceso
	2322	char descrierror[250];
	2323	if (res){ // Resultado satisfactorio
	2324	lon+=sprintf(nwtrama->parametros+lon,"res=%s\r","1"); // Resultado de la ejecucin del comando
	2325	sprintf(descrierror,"%s "," ");
	2326	lon+=sprintf(nwtrama->parametros+lon,"der=%s\r",descrierror); // Dscripcin del error si lo ha habido
	2327	}
	2328	else{ // Algún error
	2329	lon+=sprintf(nwtrama->parametros+lon,"res=%s\r","2"); // Resultado de la ejecución del comando
	2330	sprintf(descrierror,"Error.-(%s) en modulo %s",e.msg,e.modulo);
	2331	lon+=sprintf(nwtrama->parametros+lon,"der=%s\r",descrierror); // Descripción del error si lo ha habido
	2332	}
	2333	if(AbreConexionTCP()){
	2334	if(!EnviaTramasHidra(sock,nwtrama)){
	2335	UltimoError(21,"RespuestaEjecucionComando()");
	2336	return(false);
	2337	}
	2338	if(!recibe_tramas(sock,trama)){
	2339	UltimoError(22,"RespuestaEjecucionComando()");
	2340	return(false);
	2341	}
	2342	CierraConexionTCP();
	2343	GestionTramas(trama); // Analiza la trama
	2344	}
	2345	else{
	2346	UltimoError(2,"RespuestaEjecucionComando()");
	2347	return(false);
	2348	}
	2349	return(true);
	2350	}
	2351	//***********************************************************************************************************************
	2352	// PROGRAMA PRINCIPAL
	2353	//***********************************************************************************************************************
	2354	int main(int argc, char *argv[])
	2355	{
	2356
	2357	//Archivos por defecto
	2358	strcpy(szPathFileCfg,"ogAdmClient.cfg");
	2359	strcpy(szPathFileLog,"ogAdmClient.log");
	2360
	2361	// Validación de argumentos y lectura del fichero de configuración
	2362	if(!ValidacionParametros(argc,argv))
	2363	exit(EXIT_FAILURE);
	2364	else{
	2365	if(!CrearArchivoLog(szPathFileLog))
	2366	exit(EXIT_FAILURE);
	2367	else
	2368	if(!LeeFileConfiguracion(szPathFileCfg)){ // Toma parámetros de configuración
	2369	UltimoError(13,"Main()");
	2370	exit(EXIT_FAILURE);
	2371	}
	2372	}
	2373	// Guarda datos básicos del cliente
	2374	strcpy(Propiedades.servidorhidra,Servidorhidra);
	2375	strcpy(Propiedades.puerto,Puerto);
	2376	strcpy(Propiedades.idordenador,"0");
	2377	if(!TomaIPlocal()){ // Error al recuperar la IP local
	2378	UltimoError(0,"Main()");
	2379	exit(EXIT_FAILURE);
	2380	}
	2381	MuestraMensaje(0,NULL);
	2382	sleep(2);
	2383	strcpy(Propiedades.IPlocal,IPlocal);
	2384	RegistraLog("Abriendo sesión en el servidor de Administración", false);
	2385	if(InclusionCliente()){ // El cliente ha abierto sesión correctamente
	2386	if(strcmp(Propiedades.idordenador,"0")==0){ // Ha habido algún problema al inciar sesión
	2387	UltimoError(0,"Main()");
	2388	exit(EXIT_FAILURE);
	2389	}
	2390	RegistraLog("Cliente iniciado", false);
	2391
	2392	if(!cuestionCache(Propiedades.cache)){ // Procesa la cache
	2393	UltimoError(0,"Main()");
	2394	exit(EXIT_FAILURE);
	2395	}
	2396
	2397	RegistraLog("Ejecución de archivo Autoexec", false);
	2398	if(!AutoexecClienteHidra()){ // Ejecución fichero autoexec
	2399	UltimoError(0,"Main()");
	2400	exit(EXIT_FAILURE);
	2401	}
	2402	RegistraLog("Procesa comandos pendientes", false);
	2403	ComandosPendientes(); // Bucle para procesar comandos pendientes
	2404	RegistraLog("Acciones pendientes procesadas", false);
	2405	MuestraMenu(URLMENU);
	2406	RegistraLog("Disponibilidad para comandos interactivos activada ...", false);
	2407	ProcesaComandos(); // Bucle para procesar comandos interactivos
	2408	RegistraLog("Disponibilidad para comandos interactivos desactivada...", false);
	2409	}
	2410	else{
	2411	UltimoError(0,"Main()");
	2412	exit(EXIT_FAILURE);
	2413	}
	2414	exit(0);
	2415	}
	2416
	2417
	2418
	2419

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: admin/Services/ogAdmClient/sources/ogAdmClient.c @ 5701de1

Download in other formats: