Context Navigation

ogAdmClient.c @ ebbbf900

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

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

Context Navigation

source: admin/Services/ogAdmClient/sources/ogAdmClient.c @ ebbbf900

Download in other formats: