Context Navigation

ogAdmClient.c @ 74c04a0

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

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

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

Context Navigation

source: admin/Services/ogAdmClient/sources/ogAdmClient.c @ 74c04a0

Download in other formats: