Context Navigation

ogAdmClient.c @ 73cfa0a

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 73cfa0a was c3e2eb6a, checked in by alonso <alonso@…>, 15 years ago
git-svn-id: https://opengnsys.es/svn/trunk@1024 a21b9725-9963-47de-94b9-378ad31fedc9
Property mode set to `100644`
File size: 85.5 KB

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

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

Context Navigation

source: admin/Services/ogAdmClient/sources/ogAdmClient.c @ 73cfa0a

Download in other formats: