Context Navigation

ogAdmClient.c @ 81b4351

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 81b4351 was 81b4351, checked in by alonso <alonso@…>, 15 years ago
git-svn-id: https://opengnsys.es/svn/trunk@1073 a21b9725-9963-47de-94b9-378ad31fedc9
Property mode set to `100644`
File size: 86.6 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	int lon;
931
932	while(TRUE){
933	lon=sprintf(trama->parametros,"nfn=DisponibilidadComandos\r");
934	lon+=sprintf(trama->parametros+lon,"swd=1\r"); // Disponible
935
936	if(AbreConexionTCP()){
937	if(!EnviaTramasHidra(sock,trama)){
938	UltimoError(21,"ProcesaComandos()"); // No se pudo enviar trama
939	return(false);
940	}
941	if(!recibe_tramas(sock,trama)){
942	UltimoError(22,"ProcesaComandos()"); // No se pudo recuperar trama
943	return(false);
944	}
945	CierraConexionTCP();
946	GestionTramas(trama); // Analiza procesa la trama
947	}
948	else{
949	UltimoError(2,"ProcesaComandos()");
950	return(false);
951	}
952	}
953	return(true);
954	}
955	//______________________________________________________________________________________________________
956	// Función: ProcesaComandos
957	//
958	// Descripción:
959	// Espera comando desde el Servidor de Administración para ejecutarlos
960	// Parámetros:
961	// Ninguno
962	// Devuelve:
963	// true si el archivo se ha eliminado correctamente o false en caso contrario
964	// ________________________________________________________________________________________________________
965	/*
966	int ProcesaComandos()
967
968	{
969	sprintf(filecmd,"/comandos/CMD_%s",Propiedades.IPlocal); // Nombre del fichero de comandos
970	if(ExisteFichero(filecmd)) // Borra fichero de comandos si previamente exista de anteriores procesos
971	RemoveFile(filecmd);
972	if(!DisponibilidadComandos(true)){ // Notifica al servidor de Adminsitración su disponibilidad para recibir comandos
973	UltimoError(0,"ProcesaComandos()");
974	return(false);
975	}
976	PRCCMD=true;
977	while(PRCCMD){ // Bucle de espera de comandos interactivos
978	if(ExisteFichero(filecmd)){ // Busca fichero de comandos
979	RegistraLog("Comando recibido desde el Servidor de Administración",false);
980	if(!LoadTextFile(filecmd)){ // Toma comando
981	UltimoError(1,"ProcesaComandos()");
982	return(false);
983	}
984	GestionTramas(trama); // Analiza la trama y ejecuta el comando
985	RegistraLog("Procesa comandos pendientes",false);
986	ComandosPendientes(); // Bucle para procesar comandos pendientes
987	RegistraLog("Disponibilidad para comandos interactivos activada ...",false);
988	if(!DisponibilidadComandos(true)){ // Notifica al servidor de Administración su disponibilidad para recibir comandos
989	UltimoError(0,"ProcesaComandos()");
990	return(false);
991	}
992	if(!RemoveFile(filecmd)){ // Lo elimina
993	UltimoError(0,"ProcesaComandos()");
994	return(false);
995	}
996	}
997	sleep(1); // Espera 1 segundo antes de volver a esperar comandos
998	}
999	return(true);
1000	}
1001	*/
1002
1003	//______________________________________________________________________________________________________
1004	// Función: DisponibilidadComandos
1005	//
1006	// Descripción:
1007	// Notifica al servidor su disponibilidad a recibir comandos ( Lgica negativa )
1008	// Parámetros:
1009	// - swdis : Indica disponibilidad si es true y NO disponibilidad en caso de ser false
1010	// Devuelve:
1011	// true si el proceso es correcto y false en caso contrario
1012	// ________________________________________________________________________________________________________
1013	/*
1014	int DisponibilidadComandos(int swdis)
1015	{
1016	int lon;
1017
1018	lon=sprintf(trama->parametros,"nfn=DisponibilidadComandos\r");
1019	if(!swdis)
1020	lon+=sprintf(trama->parametros+lon,"swd=0\r"); // No disponible
1021	else
1022	lon+=sprintf(trama->parametros+lon,"swd=1\r"); // Disponible
1023
1024	if(AbreConexionTCP()){
1025	if(!EnviaTramasHidra(sock,trama)){
1026	UltimoError(21,"DisponibilidadComandos()"); // No se pudo recuperar la configuración hardware
1027	return(false);
1028	}
1029	if(!recibe_tramas(sock,trama)){
1030	UltimoError(22,"DisponibilidadComandos()"); // No se pudo recuperar la configuración hardware
1031	return(false);
1032	}
1033	CierraConexionTCP();
1034	GestionTramas(trama); // Analiza la trama
1035	}
1036	else{
1037	UltimoError(2,"DisponibilidadComandos()");
1038	return(false);
1039	}
1040	return(true);
1041	}
1042	*/
1043	//______________________________________________________________________________________________________
1044	// Función: GestionTramas
1045	//
1046	// Descripción:
1047	// Gestiona las tramas recibidas por la red
1048	// Parámetros:
1049	// - trama : Una trama recibida
1050	// Devuelve:
1051	// true o false dependiendo del éxito en la ejecución del comandoo si se trata de una trama
1052	// del Servidor de Administración o bien del resultado de la petición de información al repositorio
1053	// ________________________________________________________________________________________________________
1054	int GestionTramas(TRAMA *trama)
1055	{
1056	TRAMA *nwtrama=NULL;
1057	int res;
1058	char *nombrefuncion;
1059
1060	INTROaFINCAD(trama->parametros);
1061	nombrefuncion=toma_parametro("nfn",trama->parametros);
1062	nwtrama=(TRAMA*)ReservaMemoria(LONGITUD_TRAMA); // Reserva buffer para la trama devuelta
1063	if(!nwtrama){
1064	UltimoError(1,"GestionTramas()");
1065	return(false);
1066	}
1067	if(ndebug>6){
1068	sprintf(msglog,"Gestión de tramas.-Función a ejecutar:%s",nombrefuncion);
1069	RegistraLog(msglog,false);
1070	}
1071	// Mensajes entre el cliente y el Servidor de Administración
1072	res=strcmp(nombrefuncion,"Apagar");
1073	if(res==0)
1074	return(Apagar(trama,nwtrama));
1075
1076	res=strcmp(nombrefuncion,"Arrancar");
1077	if(res==0)
1078	return(Arrancar(trama,nwtrama));
1079
1080	res=strcmp(nombrefuncion,"Reiniciar");
1081	if(res==0)
1082	return(Reiniciar(trama,nwtrama));
1083
1084	res=strcmp(nombrefuncion,"IniciarSesion");
1085	if(res==0)
1086	return(IniciarSesion(trama,nwtrama));
1087
1088	res=strcmp(nombrefuncion,"RESPUESTA_InclusionCliente");
1089	if(res==0)
1090	return(RESPUESTA_InclusionCliente(trama));
1091
1092	res=strcmp(nombrefuncion,"Actualizar");
1093	if(res==0)
1094	return(Actualizar());
1095
1096	res=strcmp(nombrefuncion,"ConsolaRemota");
1097	if(res==0)
1098	return(ConsolaRemota(trama,nwtrama));
1099
1100	res=strcmp(nombrefuncion,"NoComandosPtes");
1101	if(res==0)
1102	return(NoComandosPtes());
1103
1104	res=strcmp(nombrefuncion,"Cortesia");
1105	if(res==0)
1106	return(Cortesia());
1107
1108
1109	res=strcmp(nombrefuncion,"ExecShell");
1110	if(res==0)
1111	return(ExecShell(trama,nwtrama));
1112
1113	res=strcmp(nombrefuncion,"CrearPerfilSoftware");
1114	if(res==0)
1115	return(CrearPerfilSoftware(trama,nwtrama));
1116
1117	res=strcmp(nombrefuncion,"RestaurarImagen");
1118	if(res==0)
1119	return(RestaurarImagen(trama,nwtrama));
1120
1121	res=strcmp(nombrefuncion,"TomaConfiguracion");
1122	if(res==0)
1123	return(TomaConfiguracion(trama,nwtrama));
1124
1125	res=strcmp(nombrefuncion,"InventarioHardware");
1126	if(res==0)
1127	return(InventarioHardware(trama,nwtrama));
1128
1129	res=strcmp(nombrefuncion,"InventarioSoftware");
1130	if(res==0)
1131	return(InventarioSoftware(trama,nwtrama));
1132
1133	res=strcmp(nombrefuncion,"ParticionaryFormatear");
1134	if(res==0)
1135	return(ParticionaryFormatear(trama,nwtrama));
1136
1137	// Mensajes entre el cliente y el repositorio
1138	res=strcmp(nombrefuncion,"Respuesta_ExisteFichero");
1139	if(res==0){
1140	res=atoi(toma_parametro("res",trama->parametros));
1141	return(res);
1142	}
1143
1144	res=strcmp(nombrefuncion,"Respuesta_EliminaFichero");
1145	if(res==0){
1146	res=atoi(toma_parametro("res",trama->parametros));
1147	return(res);
1148	}
1149
1150	res=strcmp(nombrefuncion,"Respuesta_LeeFicheroTexto");
1151	if(res==0){
1152	res=atoi(toma_parametro("res",trama->parametros));
1153	return(res);
1154	}
1155	return(true);
1156	}
1157	//______________________________________________________________________________________________________
1158	// Función: Cortesia
1159	//
1160	// Descripción:
1161	// Respuesta estandar del Servidor de Administración
1162	// Parámetros:
1163	// Ninguno
1164	// Devuelve:
1165	// true siempre
1166	// Especificaciones:
1167	// Esta función se ejecuta de forma estandar para cerrar la conversación con el Servidor de Administración
1168	//______________________________________________________________________________________________________
1169	int Cortesia(){
1170	return(true);
1171	}
1172	//______________________________________________________________________________________________________
1173	// Función: NoComandosPtes
1174	//
1175	// Descripción:
1176	// Conmuta el switch de los comandos pendientes y lo pone a false
1177	// Parámetros:
1178	// Ninguno
1179	// Devuelve:
1180	// true siempre
1181	// Especificaciones:
1182	// Cuando se ejecuta esta función se sale del bucle que recupera los comandos pendientes en el servidor y
1183	// el cliente pasa a a estar disponible para recibir comandos desde el éste.
1184	//______________________________________________________________________________________________________
1185	int NoComandosPtes(){
1186	CMDPTES=false; // Corta el bucle de comandos pendientes
1187	return(true);
1188	}
1189	//______________________________________________________________________________________________________
1190	// Función: TomaIPlocal
1191	//
1192	// Descripción:
1193	// Recupera la IP local
1194	// Parámetros:
1195	// Ninguno
1196	// Devuelve:
1197	// Una cadena con el valor de la IP en formato xxx.xxx.xxx.xxx
1198	// Especificaciones:
1199	// En caso de no encontrar la IP o generarse algún error se devuelve la dirección 0.0.0.0
1200	//______________________________________________________________________________________________________
1201	int TomaIPlocal()
1202	{
1203	int herror;
1204
1205	sprintf(cmdshell,"%s/admGetIpAddress",HIDRASCRIPTS);
1206	herror=EjecutarScript (cmdshell,NULL,IPlocal,true);
1207	RegistraLog(msglog,false);
1208	if(herror){
1209	UltimoErrorScript(herror,"TomaIPlocal()"); // Se ha producido algún error
1210	return(false);
1211	}
1212	return(true);
1213	}
1214	//______________________________________________________________________________________________________
1215	// Función: cuestionCache
1216	//
1217	// Descripción:
1218	// Procesa la cache en caso de existir.
1219	// Parámetros:
1220	// tamcache : Tamaño de la cache
1221	// Devuelve:
1222	// true o false dependiendo de si se ha ejecutado correctamente el script de configuración
1223	//
1224	//
1225	//______________________________________________________________________________________________________
1226	int cuestionCache(char* tamcache)
1227	{
1228	int herror;
1229
1230	if(ndebug>3){
1231	sprintf(msglog,"Tamaño de la cache: %s",tamcache);
1232	RegistraLog(msglog,false);
1233	}
1234
1235	sprintf(cmdshell,"%s/initCache",HIDRASCRIPTS);
1236	sprintf(parametros,"%s %s","initCache",tamcache);
1237
1238
1239	herror=EjecutarScript (cmdshell,parametros,NULL,true);
1240	if(herror){
1241	UltimoErrorScript(herror,"cuestionCache()"); // Se ha producido algún error
1242	return(false);
1243	}
1244	if(tamcache>0)
1245	CACHEEXISTS=true;
1246	else
1247	CACHEEXISTS=false;
1248
1249	return(true);
1250	}
1251	//______________________________________________________________________________________________________
1252	// Función: InclusionCliente
1253	// Descripción:
1254	// Abre una sesión en el servidor de administración y registra al cliente en el sistema
1255	// Parámetros:
1256	// Ninguno
1257	// Devuelve:
1258	// true si el registro ha tenido éxito o false en caso contrario
1259	//______________________________________________________________________________________________________
1260	int InclusionCliente()
1261	{
1262	int lon;
1263	char *parametroscfg;
1264
1265	parametroscfg=(char*)ReservaMemoria(256);
1266	if(!parametroscfg){
1267	UltimoError(1,"InclusionCliente()"); // No se pudo reservar memoria
1268	return(false);
1269	}
1270
1271	char disco=(char)ReservaMemoria(2);
1272	sprintf(disco,"1"); // Siempre el disco 1
1273	parametroscfg=LeeConfiguracion(disco); // Toma configuración
1274
1275	if(ndebug>3){
1276	sprintf(msglog,"CONFIGURACION=%s",parametroscfg);
1277	RegistraLog(msglog,false);
1278	}
1279
1280	if(!parametroscfg){
1281	UltimoError(18,"InclusionCliente()"); // No se pudo recuperar la configuración hardware
1282	return(false);
1283	}
1284	lon=sprintf(trama->parametros,"nfn=InclusionCliente\r"); // Nombre de la función a ejecutar en el servidor de Adminsitración
1285	lon+=sprintf(trama->parametros+lon,"cfg=%s\r",parametroscfg); // Configuración de los Sistemas Operativos del cliente
1286	if(AbreConexionTCP()){
1287	RegistraLog("Enviando peticion de inclusion al Servidor de Administración",false);
1288	if(!EnviaTramasHidra(sock,trama)){
1289	UltimoError(21,"InclusionCliente()"); // No se pudo recuperar la configuración hardware
1290	return(false);
1291	}
1292	RegistraLog("Recibiendo respuesta del Servidor de Administración",false);
1293	if(!recibe_tramas(sock,trama)){
1294	UltimoError(22,"InclusionCliente()"); // No se pudo recuperar la configuración hardware
1295	return(false);
1296	}
1297	CierraConexionTCP();
1298	if(!GestionTramas(trama)){ // Analiza la trama
1299	UltimoError(0,"InclusionCliente()");
1300	return(false);
1301	}
1302	return(true);
1303	}
1304	else{
1305	UltimoError(2,"InclusionCliente()"); // No se pudo conectar con el servidor de administración
1306	return(false);
1307	}
1308	return(true);
1309	}
1310	//______________________________________________________________________________________________________
1311	// Función: RESPUESTA_InclusionCliente
1312	//
1313	// Descripción:
1314	// Respuesta del servidor de administración a la petición de inicio enviando los datos identificativos del cliente y otras configuraciones
1315	// Parámetros:
1316	// trama: Trama recibida por el cliente desde el Servidor de Administración
1317	// Devuelve:
1318	// true si el registro ha tenido éxito o false en caso contrario
1319	//______________________________________________________________________________________________________
1320	int RESPUESTA_InclusionCliente(TRAMA *trama)
1321	{
1322	strcpy(Propiedades.idordenador,toma_parametro("ido",trama->parametros)); // Identificador del ordenador
1323	strcpy(Propiedades.nombreordenador,toma_parametro("npc",trama->parametros)); // Nombre del ordenador
1324	strcpy(Propiedades.idaula,toma_parametro("ida",trama->parametros)); // Identificador del aula a la que pertenece
1325	strcpy(Propiedades.idperfilhard,toma_parametro("ifh",trama->parametros)); // Identificador del perfil hardware del ordenador
1326	strcpy(Propiedades.servidorhidra,toma_parametro("hrd",trama->parametros)); // Dirección IP del servidor de Administración
1327	strcpy(Propiedades.puerto,toma_parametro("prt",trama->parametros)); // Puerto de comunicación con el servidor de Administración
1328	strcpy(Propiedades.iprepo,toma_parametro("ipr",trama->parametros)); // Dirección IP del repositorio
1329	strcpy(Propiedades.puertorepo,toma_parametro("rep",trama->parametros)); // Puerto de comunicación con el repositorio
1330	strcpy(Propiedades.cache,toma_parametro("che",trama->parametros)); // Tamaño de la cache
1331
1332	strcpy(Propiedades.ipmulticast,toma_parametro("ipm",trama->parametros)); // Dirección IP multicast
1333	strcpy(Propiedades.pormulticast,toma_parametro("pom",trama->parametros)); // Puerto multicast
1334	strcpy(Propiedades.modmulticast,toma_parametro("mom",trama->parametros)); // Modo de transmisión multicast
1335	strcpy(Propiedades.velmulticast,toma_parametro("vlm",trama->parametros)); // Velocidad de transmisión multicast
1336
1337	// Guarda items del menú
1338	char* cabmenu=toma_parametro("cmn",trama->parametros);
1339	if (cabmenu){
1340	swmnu=true;
1341	char *auxCab[15];
1342	split_parametros(auxCab,cabmenu,"&"); // Caracter separador de los elementos de un item
1343	strcpy(CabMnu.titulo,auxCab[0]); // Tìtulo del menú
1344	strcpy(CabMnu.coorx,auxCab[1]); // Coordenada x del menú público
1345	strcpy(CabMnu.coory,auxCab[2]); // Coordenada y del menú público
1346	strcpy(CabMnu.modalidad,auxCab[3]); // Modalidad de columnas del menú público
1347	strcpy(CabMnu.scoorx,auxCab[4]); // Coordenada x del menú privado
1348	strcpy(CabMnu.scoory,auxCab[5]); // Coordenada y del menú privado
1349	strcpy(CabMnu.smodalidad,auxCab[6]); // Modalidad de columnas del menú privado
1350	strcpy(CabMnu.resolucion,auxCab[7]); // Resolución de pantalla
1351	}
1352	/char menu=toma_parametro("mnu",trama->parametros); // Menú estandar
1353
1354	char* auxMenu[MAXITEMS],auxItem[10];
1355	int iMnu=split_parametros(auxMenu,menu,"?"); // Caracter separador de los item
1356	int i,nitem;
1357
1358	for( i = 0; i<iMnu; i++){
1359	struct s_Item Item;
1360	nitem=split_parametros(auxItem,auxMenu[i],"&"); // Caracter separador de los elementos de un item
1361	strcpy(Item.idaccionmenu,auxItem[0]); // Identificador de la acción
1362	strcpy(Item.urlimg,auxItem[1]); // Url de la imagen del item
1363	strcpy(Item.literal,auxItem[2]); // Literal del item
1364	strcpy(Item.tipoitem,auxItem[3]); // Tipo de item ( Público o privado )
1365	strcpy(Item.tipoaccion,auxItem[4]); // Tipo de acción ( Procedimiento,Tarea oTrabajo )
1366	tbMenu[i]=Item;
1367	}
1368	contitems=i; // Número de items totales de los dos menús
1369	*/
1370	return(true);
1371	}
1372	//______________________________________________________________________________________________________
1373	// Función: ComandosPendientes
1374	//
1375	// Parámetros:
1376	// Ninguno
1377	// Descripción:
1378	// Búsqueda de acciones pendientes en el servidor de administración
1379	//______________________________________________________________________________________________________
1380	int ComandosPendientes()
1381	{
1382	CMDPTES=true;
1383	while(CMDPTES){
1384	sprintf(trama->parametros,"nfn=ComandosPendientes\r"); // Nombre de la función a ejecutar en el servidor de administración
1385	if(AbreConexionTCP()){
1386	if(!EnviaTramasHidra(sock,trama)){
1387	UltimoError(21,"ComandosPendientes()"); // No se pudo recuperar la configuración hardware
1388	return(false);
1389	}
1390	if(!recibe_tramas(sock,trama)){
1391	UltimoError(22,"ComandosPendientes()"); // No se pudo recuperar la configuración hardware
1392	return(false);
1393	}
1394	CierraConexionTCP();
1395	GestionTramas(trama); // Analiza la trama
1396	}
1397	else{
1398	UltimoError(2,"ComandosPendientes()"); // No se pudo conectar con el servidor de Administración
1399	return(false);
1400	}
1401	}
1402	CMDPTES=false;
1403	return(true);
1404	}
1405	//_____________________________________________________________________________________________________
1406	// Función: Arrancar
1407	//
1408	// Descripción:
1409	// Contesta ante un comando de arrancar
1410	// Parámetros:
1411	// - trama: Trama recibida con las especificaciones del comando
1412	// - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
1413	// Devuelve:
1414	// true siempre
1415	//_____________________________________________________________________________________________________
1416	int Arrancar(TRAMA trama,TRAMA nwtrama)
1417	{
1418	sprintf(nwtrama->parametros,"nfn=RESPUESTA_Arrancar\r");
1419	return(RespuestaEjecucionComando(trama,nwtrama,true));
1420	}
1421	//_____________________________________________________________________________________________________
1422	// Función: Apagar
1423	//
1424	// Descripción:
1425	// Apaga el cliente
1426	// Parámetros:
1427	// - trama: Trama recibida con las especificaciones del comando
1428	// - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
1429	// Devuelve:
1430	// true si el proceso fue correcto o false en caso contrario
1431	//_____________________________________________________________________________________________________
1432	int Apagar(TRAMA trama,TRAMA nwtrama)
1433	{
1434	int res;
1435
1436	sprintf(nwtrama->parametros,"nfn=RESPUESTA_Apagar\r");
1437	res=RespuestaEjecucionComando(trama,nwtrama,true);
1438	sprintf(cmdshell,"poweroff");
1439	res=ExecBash(cmdshell);
1440	if(!res){
1441	UltimoErrorScript(10,"Reiniciar()"); // Se ha producido algún error
1442	}
1443	return(res);
1444	}
1445	//______________________________________________________________________________________________________
1446	// Función: Reiniciar
1447	//
1448	// Descripción:
1449	// Reinicia el cliente
1450	// Parámetros:
1451	// - trama: Trama recibida con las especificaciones del comando
1452	// - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
1453	// Devuelve:
1454	// true si el proceso fue correcto o false en caso contrario
1455	//______________________________________________________________________________________________________
1456	int Reiniciar(TRAMA trama,TRAMA nwtrama)
1457	{
1458	int res;
1459
1460	sprintf(nwtrama->parametros,"nfn=RESPUESTA_Reiniciar\r");
1461	res=RespuestaEjecucionComando(trama,nwtrama,true);
1462	sprintf(cmdshell,"reboot");
1463	res=ExecBash(cmdshell);
1464	if(!res){
1465	UltimoErrorScript(10,"Reiniciar()"); // Se ha producido algún error
1466	}
1467	return(res);
1468	}
1469	//______________________________________________________________________________________________________
1470	// Función: IniciarSesion
1471	//
1472	// Descripción:
1473	// Inicia Sesión en algún sistema operativo instalado en la máquina
1474	// Parámetros:
1475	// - trama: Trama recibida con las especificaciones del comando
1476	// - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
1477	// Devuelve:
1478	// true si el proceso fue correcto o false en caso contrario
1479	// *** En ese proceso se devuelve correcto aún sabiendo que no se se sabe si va a funcionar
1480	// pero esto evita que si se ha lanzado con seguimiento, la tarea no quede sin norificar.
1481	//______________________________________________________________________________________________________
1482	int IniciarSesion(TRAMA trama,TRAMA nwtrama)
1483	{
1484	int res;
1485	char *particion=toma_parametro("par",trama->parametros);
1486	char disco=(char)ReservaMemoria(2);
1487	sprintf(disco,"1"); // Siempre el disco 1
1488
1489	sprintf(nwtrama->parametros,"nfn=RESPUESTA_IniciarSesion\r");
1490	res=RespuestaEjecucionComando(trama,nwtrama,true);
1491	sprintf(cmdshell,"%s/admBootOs %s %s",HIDRASCRIPTS,disco,particion);
1492	res=ExecBash(cmdshell);
1493	if(!res){
1494	UltimoErrorScript(10,"IniciarSesion()"); // Se ha producido algún error
1495	}
1496	return(res);
1497	}
1498	//______________________________________________________________________________________________________
1499	// Función: Actualizar
1500	//
1501	// Descripción:
1502	// Actualiza los datos de un ordenador como si volviera a solicitar la entrada en el sistema al servidor de administración
1503	// Parámetros:
1504	// Ninguno
1505	// Devuelve:
1506	// true si el proceso fue correcto o false en caso contrario
1507	//______________________________________________________________________________________________________
1508	int Actualizar()
1509	{
1510	int res;
1511
1512	MuestraMensaje(1,NULL);
1513	res=InclusionCliente();
1514	//cuestionCache(Propiedades.cache);
1515	MuestraMenu(URLMENU);
1516	//kill(pidmenu,SIGQUIT);
1517	return(res);
1518	}
1519	//______________________________________________________________________________________________________
1520	// Función: CrearPerfilSoftware
1521	//
1522	// Descripción:
1523	// Genera una imagen de una partición
1524	// Parámetros:
1525	// - trama: Trama recibida con las especificaciones del comando
1526	// - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
1527	// Devuelve:
1528	// true si el proceso fue correcto o false en caso contrario
1529	//_____________________________________________________________________________________________________
1530	int CrearPerfilSoftware(TRAMAtrama,TRAMAnwtrama)
1531	{
1532	int res=0;
1533	char *wparticion=toma_parametro("par",trama->parametros); // Partición de donde se crear el perfil
1534	char *widperfilsoft=toma_parametro("ifs",trama->parametros); // Perfil software a crear
1535	char *widperfilhard=toma_parametro("ifh",trama->parametros); // Perfil hardware del ordenador
1536	char *wnemonico=toma_parametro("nem",trama->parametros); // Nemónico del S.O. de la partición
1537
1538	char disco=(char)ReservaMemoria(2);
1539	sprintf(disco,"1"); // Siempre el disco 1
1540
1541	char pathperfil[250];
1542	sprintf(pathperfil,"%s/%s",HIDRACHEIMAGENES,wnemonico); // Path del perfil creado
1543
1544	char fileperfil[64];
1545	sprintf(fileperfil,"PS%s_PH%s",widperfilsoft,widperfilhard); // Nombre de la imagen ( del perfil creado)
1546
1547	char filemasterboot[64];
1548	sprintf(filemasterboot,"PS%s_PH%s.msb",widperfilsoft,widperfilhard); // Idem para el sector de arranque MBR
1549	res=CrearPerfil(disco,fileperfil,pathperfil,wparticion,Propiedades.iprepo);
1550	RegistraLog("Finalizada la creacion del perfil software",false);
1551	int lon;
1552	lon=sprintf(nwtrama->parametros,"nfn=RESPUESTA_CrearPerfilSoftware\r");
1553	lon+=sprintf(nwtrama->parametros+lon,"ifs=%s\r",widperfilsoft);
1554	lon+=sprintf(nwtrama->parametros+lon,"ifh=%s\r",widperfilhard);
1555	RespuestaEjecucionComando(trama,nwtrama,res);
1556	return(res);
1557	}
1558	//______________________________________________________________________________________________________
1559	// Función: CrearPerfil
1560	//
1561	// Descripción:
1562	// Crea una imagen de una partición
1563	// Parámetros:
1564	// -disco Disco a clonar 1,2,3..
1565	// -fileimg Nombre de la imagen
1566	// -pathimg Ruta de la imagen
1567	// -particion Partición a clonar
1568	// -iprepo Dirección IP del repositorio ( Si es la IP local el repositorio será la caché)
1569	// Devuelve:
1570	// true si el proceso fue correcto o false en caso contrario
1571	//______________________________________________________________________________________________________
1572	int CrearPerfil(char* disco,char* fileimg,char* pathimg,char* particion,char*iprepo)
1573	{
1574	int herror;
1575
1576	MuestraMensaje(2,NULL);
1577
1578	sprintf(cmdshell,"%s/admCreateImage",HIDRASCRIPTS);
1579	sprintf(parametros,"%s %s %s %s %s","createImage",disco,particion,"REPO",fileimg);
1580
1581	if(ndebug>3){
1582	sprintf(msglog,"Creando Imagen disco:%s, partición:%s, Repositorio:%s, Imagen:%s, Ruta:%s",disco,particion,Propiedades.iprepo,fileimg,"");
1583	RegistraLog(msglog, false);
1584	}
1585
1586	herror=EjecutarScript(cmdshell,parametros,NULL,true);
1587	if(herror)
1588	MuestraMensaje(10,NULL);
1589	else
1590	MuestraMensaje(9,NULL);
1591	MuestraMenu(URLMENU);
1592
1593	if(herror){
1594	UltimoErrorScript(herror,"CrearPerfil()"); // Se ha producido algún error
1595	return(false);
1596	}
1597	else
1598	return(true);
1599	}
1600	//______________________________________________________________________________________________________
1601	// Función: Nemonico
1602	//
1603	// Descripción:
1604	// Devuelve el código de un nemonico de S.O.
1605	// Parámetros:
1606	// -nem Nemonico del S.O.
1607	// Devuelve:
1608	// El código del nemónico
1609	//______________________________________________________________________________________________________
1610	int Nemonico(char* nem)
1611	{
1612	if(strcmp(nem,"MsDos")==0)
1613	return(MsDos);
1614	if(strcmp(nem,"Win98")==0)
1615	return(Win98);
1616	if(strcmp(nem,"Win2K")==0)
1617	return(Win2K);
1618	if(strcmp(nem,"WinXP")==0)
1619	return( WinXP);
1620	if(strcmp(nem,"Linux")==0)
1621	return(Linux);
1622	return(0);
1623	}
1624	//______________________________________________________________________________________________________
1625	// Función: RestaurarImagen
1626	//
1627	// Descripción:
1628	// Restaura una imagen en una partición
1629	// Parámetros:
1630	// - trama: Trama recibida con las especificaciones del comando
1631	// - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
1632	// Devuelve:
1633	// true si el proceso fue correcto o false en caso contrario
1634	//______________________________________________________________________________________________________
1635	int RestaurarImagen(TRAMAtrama,TRAMAnwtrama)
1636	{
1637	int res=0;
1638	int idxpath;
1639
1640	char disco=(char)ReservaMemoria(2);
1641	sprintf(disco,"1"); // Siempre el disco 1
1642
1643	char *wparticion=toma_parametro("par",trama->parametros); // partición de donde se crear el perfil
1644	char *widimagen=toma_parametro("idi",trama->parametros); // Identificador de la imagen
1645	char *widperfilsoft=toma_parametro("ifs",trama->parametros); // Perfil software
1646	char *widperfilhard=toma_parametro("ifh",trama->parametros); // Perfil hardware
1647	char *wpathimagen=toma_parametro("pth",trama->parametros); // Indica si la imagen se descargar de la caché o del repositorio
1648	char *wprotclona=toma_parametro("mcl",trama->parametros); // Protocolo de clonacion
1649	char *wnipes=toma_parametro("nip",trama->parametros); // Numero de clientes de la sesión multicast
1650	char *wide=toma_parametro("ide",trama->parametros); // Identificador sesión multicast
1651
1652	if(wpathimagen=='\0') wpathimagen="1"; // Por defecto de caché
1653	idxpath=atoi(wpathimagen);
1654	if(!CACHEEXISTS) idxpath=2; // Sin no existe cache siempre desde el servidor
1655
1656	char fileperfil[64];
1657	sprintf(fileperfil,"PS%s_PH%s",widperfilsoft,widperfilhard); // Nombre del fichero del perfil creado
1658	res=RestaurandoImagen(disco,fileperfil,wparticion,tbPathImg[idxpath],wprotclona,wnipes,wide);
1659
1660	// Toma la nueva configuración
1661	char *parametroscfg=LeeConfiguracion(disco);
1662	RegistraLog("Finalizada la restauracion de imagen", false);
1663
1664	int lon;
1665	lon=sprintf(nwtrama->parametros,"nfn=RESPUESTA_RestaurarImagen\r");
1666	lon+=sprintf(nwtrama->parametros+lon,"cfg=%s\r",parametroscfg);
1667	lon+=sprintf(nwtrama->parametros+lon,"idi=%s\r",widimagen);
1668	lon+=sprintf(nwtrama->parametros+lon,"par=%s\r",wparticion);
1669	lon+=sprintf(nwtrama->parametros+lon,"ifs=%s\r",widperfilsoft);
1670	RespuestaEjecucionComando(trama,nwtrama,res);
1671	return(res);
1672	}
1673	//______________________________________________________________________________________________________
1674	// Función: RestaurandoImagen
1675	//
1676	// Descripción:
1677	// Restaura na imagen en una partición
1678	// Parámetros:
1679	// -disco Disco a clonar 1,2,3..
1680	// -fileimg Nombre de la imagen
1681	// -particion Partición a clonar
1682	// -pathImg Ruta de la imagen
1683	// -protclona Protocolo de clonación para la imagen
1684	// -nipes Número de ordenadores
1685	// -ide Identificador de la sesión multicast (Es la hora en segundos del momento del envío del comando)
1686	// Devuelve:
1687	// true si el proceso fue correcto o false en caso contrario
1688	//____________________________________________________________________________________________________
1689	int RestaurandoImagen(char* disco,char fileimg,char particion,char pathImg,char protclona,char nipes,char ide)
1690	{
1691	int herror;
1692
1693	MuestraMensaje(3,NULL);
1694
1695	sprintf(cmdshell,"%s/admRestoreImage",HIDRASCRIPTS);
1696	sprintf(parametros,"%s %s %s %s %s %s %s","admRestoreImage",pathImg,fileimg,disco,particion,protclona,Propiedades.pormulticast);
1697
1698	herror=EjecutarScript(cmdshell,parametros,NULL,true);
1699	if(herror) // Restauración correcta
1700	MuestraMensaje(12,NULL);
1701	else
1702	MuestraMensaje(11,NULL);
1703	MuestraMenu(URLMENU);
1704
1705	if(herror){
1706	UltimoErrorScript(herror,"RestaurandoImagen()"); // Se ha producido algún error
1707	return(false);
1708	}
1709	else{
1710	if(strcmp(protclona,"MULTICAST")==0){
1711	if(!sesionMulticast(fileimg,nipes,ide))
1712	RegistraLog("***Error en el proceso de preparación de transferencia multicast", false);
1713	}
1714	return(true);
1715	}
1716	}
1717	//______________________________________________________________________________________________________
1718	// Función: ParticionaryFormatear
1719	//
1720	// Descripción:
1721	// Modifica la tabla de particiones del sector de arranque master y formatea particiones
1722	// Parámetros:
1723	// - trama: Trama recibida con las especificaciones del comando
1724	// - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
1725	// Devuelve:
1726	// true si el proceso fue correcto o false en caso contrario
1727	//____________________________________________________________________________________________________
1728	int ParticionaryFormatear(TRAMAtrama,TRAMAnwtrama)
1729	{
1730	int res,i,parfor;
1731	char* parametroscfg;
1732	char ch[2],*parhdc[8];
1733	char *PrimaryPartitions=toma_parametro("ppa",trama->parametros);
1734	char *LogicalPartitions=toma_parametro("lpa",trama->parametros);
1735	char *HDCleanPartition=toma_parametro("hdc",trama->parametros);
1736
1737	char disco=(char)ReservaMemoria(2);
1738	sprintf(disco,"1"); // Siempre el disco 1
1739
1740
1741	RegistraLog("Creando o modificando tabla de particiones", false);
1742	//Pantallas
1743	MuestraMensaje(4,NULL);
1744	res=Particionar(disco,PrimaryPartitions,LogicalPartitions); // Creando las particiones
1745	if(res)
1746	MuestraMensaje(13,NULL);
1747	else
1748	MuestraMensaje(14,NULL);
1749
1750	if(res){
1751	strcpy(ch,";"); // Caracter delimitador
1752	parfor=split_parametros(parhdc,HDCleanPartition,ch);
1753	for(i = 0; i<parfor; i++){ // Formateando particiones
1754	//Pantallas
1755	MuestraMensaje(5,NULL);
1756	res=Formatear(disco,parhdc[i]);
1757	if(res)
1758	MuestraMensaje(15,NULL);
1759	else
1760	MuestraMensaje(16,NULL);
1761	if(!res) break;
1762	}
1763	}
1764	MuestraMenu(URLMENU);
1765	RegistraLog("Finalizado el particionado y formateado de particiones", false);
1766	parametroscfg=LeeConfiguracion(disco); // Toma la nueva configuración
1767
1768	int lon;
1769	lon=sprintf(nwtrama->parametros,"nfn=RESPUESTA_ParticionaryFormatear\r");
1770	lon+=sprintf(nwtrama->parametros+lon,"cfg=%s\r",parametroscfg);
1771	RespuestaEjecucionComando(trama,nwtrama,res);
1772
1773	return(res);
1774	}
1775	//______________________________________________________________________________________________________
1776	// Función: Particionar
1777	//
1778	// Descripción:
1779	// Modifica la tabla de particiones del sector de arranque master pero SIN formatear ninguna partición
1780	// Parámetros:
1781	// - disco: Número del disco
1782	// - PrParticion: Cadena con la sintaxis de particionado de las particiones primarias
1783	// - LoParticion: Cadena con la sintaxis de particionado de las particiones secundarias
1784	// Devuelve:
1785	// true si el proceso fue correcto o false en caso contrario
1786	//______________________________________________________________________________________________________
1787	int Particionar(char* disco,char* PrParticion,char* LoParticion)
1788	{
1789	if (strlen(PrParticion)>0){
1790	if(Particionando(disco,PrParticion,"admCreatePrimaryPartitions")){ // Particiones Primarias
1791	if (strlen(LoParticion)>0)
1792	return(Particionando(disco,PrParticion,"admCreateLogicalPartitions")); // Particiones Logicas
1793	else
1794	return(true);
1795	}
1796	else
1797	return(false);
1798	}
1799	if (strlen(LoParticion)>0)
1800	return(Particionando(disco,PrParticion,"admCreateLogicalPartitions"));
1801	else
1802	return(false);
1803	}
1804	//______________________________________________________________________________________________________
1805	// Función: Particionando
1806	//
1807	// Descripción:
1808	// Modifica la tabla de particiones del sector de arranque master pero SIN formatear ninguna partición
1809	// Parámetros:
1810	// - disco: Disco en el que se modificará la tabla de particiones 1,2,3..
1811	// - StxParticion: Cadena con la sintaxis de particionado de las particiones primarias
1812	// - script: Nombre del script que se ejecutará
1813	// Devuelve:
1814	// true si el proceso fue correcto o false en caso contrario
1815	// Especificaciones:
1816	// Esta función es auxiliar de la anterior y es llamda por esta en dos ocasiones, para las particiones Primarias y Lógicas
1817	//______________________________________________________________________________________________________
1818	int Particionando(char* disco,char* stxParticion,char* script)
1819	{
1820	int herror;
1821
1822	sprintf(cmdshell,"%s/%s",HIDRASCRIPTS,script);
1823	sprintf(parametros,"%s %s %s",script,disco,stxParticion);
1824
1825	sprintf(msglog,"Modificando tabla de particiones:%s disco:%s, cadena:%s",script,disco,stxParticion);
1826	if(ndebug>1){
1827	RegistraLog(msglog, false);
1828	}
1829	herror=EjecutarScript(cmdshell,parametros,NULL,true);
1830	if(herror){
1831	UltimoErrorScript(herror,"Particionar()"); // Se ha producido algún error
1832	return(false);
1833	}
1834	else
1835	return(true);
1836	}
1837	//______________________________________________________________________________________________________
1838	// Función: Formatear
1839	//
1840	// Descripción:
1841	// Formatea una partición
1842	// Parámetros:
1843	// - disco: Número del disco
1844	// - particion: Número de partición a formatear
1845	// Devuelve:
1846	// true si el proceso fue correcto o false en caso contrario
1847	//______________________________________________________________________________________________________
1848	int Formatear(char* disco,char* particion)
1849	{
1850	int herror;
1851
1852	sprintf(cmdshell,"%s/admFormatFs",HIDRASCRIPTS);
1853	sprintf(parametros,"%s %s %s","FormatFs",disco,particion);
1854	herror=EjecutarScript(cmdshell,parametros,NULL,true);
1855	if(herror){
1856	UltimoErrorScript(herror,"Formatear()"); // Se ha producido algún error
1857	return(false);
1858	}
1859	return(true);
1860	}
1861	//______________________________________________________________________________________________________
1862	// Función: SetCachePartitionSize
1863	//
1864	// Descripción:
1865	// Dimensiona el tamaño de la caché
1866	// Parámetros:
1867	// - t : Tamaño a asignar de la caché
1868	// Devuelve:
1869	// true si el proceso fue correcto o false en caso contrario
1870	// ________________________________________________________________________________________________________
1871	int SetCachePartitionSize(int t)
1872	{
1873	return(true);
1874	}
1875	//___________________________________________________________________________________________________
1876	//
1877	//
1878	//______________________________________________________________________________________________________
1879	// Función: AutoexecClienteHidra
1880	//
1881	// Parámetros:
1882	// Ninguno
1883	// Descripción:
1884	// Ejecuta un fichero autoexec preparado para el cliente
1885	// ________________________________________________________________________________________________________
1886	int AutoexecClienteHidra()
1887	{
1888	sprintf(fileini,"/autoexec/INI_%s",Propiedades.IPlocal); // Nombre del fichero autoexec
1889	if(ExisteFichero(fileini)){
1890	if(LoadTextFile(fileini)){ // Lee fichero autoexec
1891	GestionTramas(trama); // Analiza la trama
1892	}
1893	else{
1894	UltimoError(6,"AutoexecClienteHidra()");
1895	return(false);
1896	}
1897	}
1898	return(true);
1899	}
1900	//______________________________________________________________________________________________________
1901	// Función: LeeConfiguracion
1902	//
1903	// Descripción:
1904	// Recupera la configuración de particiones del ordenador
1905	// Parámetros:
1906	// disco: Disco a analizar 1,2,3..
1907	// Devuelve:
1908	// Una cadena con la configuración del cliente (ver manual)
1909	// ________________________________________________________________________________________________________
1910	char* LeeConfiguracion(char* disco)
1911	{
1912	int herror;
1913	char *cadenaparticiones;
1914	char *nomso;
1915
1916	cadenaparticiones=(char*)ReservaMemoria(LONGITUD_SCRIPTSALIDA);
1917	sprintf(cmdshell,"%s/admListPrimaryPartitions",HIDRASCRIPTS);
1918	sprintf(parametros,"%s %s","admListPrimaryPartitions",disco);
1919	herror=EjecutarScript(cmdshell,parametros,cadenaparticiones,true);
1920	if(herror){
1921	UltimoErrorScript(herror,"LeeConfiguracion()"); // Se ha producido algún error
1922	return(NULL);
1923	}
1924	struct s_Particiones *tbcfg[MAXPARTICIONES];
1925	char duplasparticiones[MAXPARTICIONES],duplaparticion[2];
1926
1927	int iPar=split_parametros(duplasparticiones,cadenaparticiones," "); // Caracter separatorio de los elementos de un item
1928
1929	if(ndebug>4){
1930	sprintf(msglog,"Número de particiones detectadas %d",iPar);
1931	RegistraLog(msglog,false);
1932	}
1933	int i,j;
1934	for( i = 0; i<iPar; i++){
1935	split_parametros(duplaparticion,duplasparticiones[i],":");
1936	tbcfg[i]=(struct s_Particiones*)ReservaMemoria(sizeof(struct s_Particiones)); // Toma espacio para tabla de configuraciones
1937	strcpy(tbcfg[i]->tipopart,duplaparticion[0]); // Tipo de partición
1938	strcpy(tbcfg[i]->tamapart,duplaparticion[1]); // Tamaño de partición
1939	sprintf(tbcfg[i]->numpart,"%d",i+1); // Número de partición
1940
1941	for(j=0;j<ntiposo;j++){
1942	if(strcmp(tiposos[j].tipopart,duplaparticion[0])==0 && strcmp(tiposos[j].tipopart,"LINUX-SWAP")!=0 && strcmp(tiposos[j].tipopart,"EMPTY")!=0){
1943	nomso=TomaNomSO(disco,i+1);
1944	if(nomso!=NULL){ // Averigua qué sistema operativo está instalado en la partición
1945	strcpy(tbcfg[i]->tiposo,tiposos[j].tiposo); // Nombre S.O.
1946	strcpy(tbcfg[i]->nombreso,nomso); // Nombre completo S.O.
1947	}
1948	else{
1949	strcpy(tbcfg[i]->tiposo,""); // Nombre S.O.
1950	strcpy(tbcfg[i]->nombreso,""); // Nombre completo S.O.
1951	}
1952	break;
1953	}
1954	}
1955	}
1956	char *cfg=ReservaMemoria(LONGITUD_CONFIGURACION);
1957	if(!cfg){
1958	UltimoError(1,"LeeConfiguracion()");
1959	return(NULL);
1960	}
1961	int lon=0;
1962	for( i = 0; i<iPar; i++){
1963	lon+=sprintf(cfg+lon,"@cfg\n");
1964	lon+=sprintf(cfg+lon,"tiposo=%s\n",tbcfg[i]->tiposo);
1965	lon+=sprintf(cfg+lon,"tipopart=%s\n",tbcfg[i]->tipopart);
1966	lon+=sprintf(cfg+lon,"tamapart=%s\n",tbcfg[i]->tamapart);
1967	lon+=sprintf(cfg+lon,"numpart=%s\n",tbcfg[i]->numpart);
1968	lon+=sprintf(cfg+lon,"nombreso=%s\t",tbcfg[i]->nombreso);
1969	}
1970	return(cfg);
1971	}
1972	//______________________________________________________________________________________________________
1973	// Función: TomaNomSO
1974	//
1975	// Descripción:
1976	// Recupera el nombre del sistema operativo instalado en una partición
1977	// Parámetros:
1978	// disco: Disco 1,2,3..
1979	// particion: Número de la partición
1980	// Devuelve:
1981	// Una cadena con el nombre del S.O.
1982	// ________________________________________________________________________________________________________
1983	char* TomaNomSO(char*disco,int particion)
1984	{
1985	int herror,lon;
1986	char *infosopar;
1987	char* sover[2];
1988	char ch[2];
1989
1990	infosopar=(char*)ReservaMemoria(LONGITUD_SCRIPTSALIDA); // Información del S.O. de la partición
1991
1992	sprintf(cmdshell,"%s/admGetOsVersion",HIDRASCRIPTS);
1993	sprintf(parametros,"%s %s %d","admGetOsVersion",disco,particion);
1994	herror=EjecutarScript(cmdshell,parametros,infosopar,true);
1995	if(herror){
1996	UltimoErrorScript(herror,"TomaNomSO()"); // Se ha producido algún error
1997	return(NULL);
1998	}
1999	if(strlen(infosopar)==0) return(NULL); // NO Existe S.O. en la partición
2000	strcpy(ch,":");// caracter delimitador (dos puntos)
2001	lon=split_parametros(sover,infosopar,ch);
2002	return(sover[1]);
2003	}
2004	//______________________________________________________________________________________________________
2005	// Función: MuestraMenu
2006	//
2007	// Descripción:
2008	// Muestra menú del cliente
2009	// Parámetros:
2010	//
2011	// urp: Path o url de la página web que muestra el menu del cliente
2012	//
2013	// Devuelve:
2014	// True si muestra el menú
2015	// ________________________________________________________________________________________________________
2016	int MuestraMenu(char *urp)
2017	{
2018	int nargs,resul;
2019
2020	if(ndebug>4){
2021	sprintf(msglog,"Url:%s",urp);
2022	RegistraLog(msglog, false);
2023	}
2024
2025	if(pidmenu>0)
2026	kill(pidmenu,SIGQUIT); // Se carga el proceso hijo anterior y se queda sólo el actual
2027
2028	//sprintf(cmdshell,"%s/admMenuBrowser",HIDRASCRIPTS);
2029	//sprintf(parametros,"%s %s","admMenuBrowser",urp);
2030
2031	sprintf(cmdshell,"/opt/opengnsys/bin/browser");
2032	sprintf(parametros,"%s %s %s","browser","-qws",urp);
2033
2034	nargs=split_parametros(argumentos,parametros," "); // Crea matriz de los argumentos del scripts
2035	if((pidmenu=fork())==0){
2036	/* Proceso hijo que ejecuta el script */
2037	resul=execv(cmdshell,argumentos);
2038	exit(resul);
2039	}
2040	else {
2041	if (pidmenu ==-1){
2042	UltimoErrorScript(23,"MuestraMenu()"); // Se ha producido algún error
2043	return(false);
2044	}
2045	}
2046	return(true);
2047	}
2048	//______________________________________________________________________________________________________
2049	// Función: MuestraMensaje
2050	//
2051	// Descripción:
2052	// Envia una página al browser con un mensaje determinado
2053	// Parámetros:
2054	// - idx: Indice de la cadena del mensaje
2055	// - msg: Mensaje
2056	// ________________________________________________________________________________________________________
2057	void MuestraMensaje(int idx,char*msg){
2058	if(msg)
2059	sprintf(urlpag,"%s?msg=%s",URLMSG,URLEncode(msg)); // Url de la página de mensajes
2060	else
2061	sprintf(urlpag,"%s?idx=%d",URLMSG,idx); // Url de la página de mensajes
2062	MuestraMenu(urlpag);
2063	}
2064	//______________________________________________________________________________________________________
2065	// Función: InventarioHardware
2066	//
2067	// Descripción:
2068	// Recupera la configuración de hardware del ordenador
2069	// Parámetros:
2070	// - trama: Trama recibida con las especificaciones del comando
2071	// - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
2072	// Devuelve:
2073	// true si el proceso fue correcto o false en caso contrario
2074	// Especificaciones:
2075	// Lo que se envía al servidor es una cadena con el formato de salida del script que ejecuta
2076	// está función. (Vease scripts hidraHardwareInfo)
2077	// ________________________________________________________________________________________________________
2078	int InventarioHardware(TRAMA trama,TRAMA nwtrama)
2079	{
2080	int herror,res;
2081	char *parametroshrd;
2082
2083	MuestraMensaje(6,NULL);
2084
2085	parametroshrd=(char*)ReservaMemoria(LONGITUD_SCRIPTSALIDA);
2086	sprintf(cmdshell,"%s/admListHardwareInfo",HIDRASCRIPTS);
2087
2088	herror=EjecutarScript(cmdshell,NULL,parametroshrd,true);
2089
2090	if(herror)
2091	MuestraMensaje(0,msglog);
2092	else
2093	MuestraMensaje(17,NULL);
2094	MuestraMenu(URLMENU);
2095
2096	if(herror){
2097	UltimoErrorScript(herror,"InventarioHardware()"); // Se ha producido algún error
2098	}
2099	res=(herror==0); // Si se ha producido algún error el resultado de la ejecución de error
2100
2101	int lon;
2102	lon=sprintf(nwtrama->parametros,"nfn=RESPUESTA_TomaHardware\r");
2103	lon+=sprintf(nwtrama->parametros+lon,"hrd=%s\r",parametroshrd);
2104	lon+=sprintf(nwtrama->parametros+lon,"ipr=%s\r",Propiedades.iprepo);
2105	lon+=sprintf(nwtrama->parametros+lon,"rep=%s\r",Propiedades.puertorepo);
2106
2107	RespuestaEjecucionComando(trama,nwtrama,res);
2108	return(res);
2109	}
2110	//______________________________________________________________________________________________________
2111	// Función: InventarioSoftware
2112	//
2113	// Descripción:
2114	// Recupera la configuración de software del ordenador
2115	// Parámetros:
2116	// - trama: Trama recibida con las especificaciones del comando
2117	// - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
2118	// Devuelve:
2119	// true si el proceso fue correcto o false en caso contrario
2120	// Especificaciones:
2121	// Lo que se envía al servidor es una cadena con el formato de salida del script que ejecuta
2122	// está función. (Vease scripts hidraSoftwareInfo)
2123	// ________________________________________________________________________________________________________
2124	int InventarioSoftware(TRAMA trama,TRAMA nwtrama)
2125	{
2126	int herror,res;
2127	char parametrossft,infopar;
2128	char *particion=toma_parametro("par",trama->parametros); // Toma partición
2129	//char *tipo=toma_parametro("tpl",trama->parametros); // Toma tipo de listado
2130
2131	char disco=(char)ReservaMemoria(2);
2132	sprintf(disco,"1"); // Siempre el disco 1
2133
2134	MuestraMensaje(7,NULL);
2135
2136	sprintf(cmdshell,"%s/admListSoftwareInfo",HIDRASCRIPTS);
2137	sprintf(parametros,"%s %s %s","admListSoftwareInfo",disco,particion);
2138
2139	parametrossft=(char*)ReservaMemoria(LONGITUD_SCRIPTSALIDA);
2140
2141	herror=EjecutarScript(cmdshell,parametros,parametrossft,true);
2142	if(herror)
2143	MuestraMensaje(20,NULL);
2144	else
2145	MuestraMensaje(19,NULL);
2146	MuestraMenu(URLMENU);
2147
2148	if(herror){
2149	UltimoErrorScript(herror,"InventarioSoftware()"); // Se ha producido algún error
2150	}
2151	res=(herror==0); // Si se ha producido algún error el resultado de la ejecución de error
2152	// Toma tipo de partición
2153	infopar=(char*)ReservaMemoria(16); //Tipo de partición
2154	if(res && infopar){
2155	sprintf(cmdshell,"%s/admGetFsType",HIDRASCRIPTS);
2156	sprintf(parametros,"%s %s %s","getFsType",disco,particion);
2157	herror=EjecutarScript(cmdshell,parametros,infopar,true);
2158	if(herror){
2159	UltimoErrorScript(herror,"InventarioSoftware()"); // Se ha producido algún error
2160	}
2161	}
2162	int lon;
2163	lon=sprintf(nwtrama->parametros,"nfn=RESPUESTA_TomaSoftware\r");
2164	lon+=sprintf(nwtrama->parametros+lon,"sft=%s\r",parametrossft);
2165	lon+=sprintf(nwtrama->parametros+lon,"par=%s\r",particion);
2166	lon+=sprintf(nwtrama->parametros+lon,"tfs=%s\r",infopar);
2167	lon+=sprintf(nwtrama->parametros+lon,"ipr=%s\r",Propiedades.iprepo);
2168	lon+=sprintf(nwtrama->parametros+lon,"rep=%s\r",Propiedades.puertorepo);
2169
2170	RespuestaEjecucionComando(trama,nwtrama,res);
2171	return(res);
2172	}
2173	//______________________________________________________________________________________________________
2174	// Función: TomaConfiguracion
2175	//
2176	// Descripción:
2177	// Toma la configuración de particiones de un ordenador
2178	// Parámetros:
2179	// - trama: Trama recibida con las especificaciones del comando
2180	// - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
2181	// Devuelve:
2182	// true si el proceso fue correcto o false en caso contrario
2183	// ________________________________________________________________________________________________________
2184	int TomaConfiguracion(TRAMA trama,TRAMA nwtrama)
2185	{
2186	char* parametroscfg;
2187
2188	char disco=(char)ReservaMemoria(2);
2189	sprintf(disco,"1"); // Siempre el disco 1
2190
2191	parametroscfg=LeeConfiguracion(disco);
2192
2193	int lon;
2194	lon=sprintf(nwtrama->parametros,"nfn=RESPUESTA_TomaConfiguracion\r");
2195	lon+=sprintf(nwtrama->parametros+lon,"cfg=%s\r",parametroscfg);
2196	RespuestaEjecucionComando(trama,nwtrama,true);
2197
2198	return(true);
2199	}
2200	//______________________________________________________________________________________________________
2201	// Función: ExecShell
2202	//
2203	// Descripción:
2204	// Ejecuta un script de la Shell
2205	// Parámetros:
2206	// - trama: Trama recibida con las especificaciones del comando
2207	// - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
2208	// Devuelve:
2209	// true si el proceso fue correcto o false en caso contrario
2210	// ________________________________________________________________________________________________________
2211	int ExecShell(TRAMA trama,TRAMA nwtrama)
2212	{
2213	int res;
2214
2215	char* wscript=toma_parametro("scp",trama->parametros); // Código del script
2216	char* codigo=URLDecode(wscript); // Decodifica el código recibido con formato URLCode
2217
2218	//Pantallas
2219	MuestraMensaje(8,NULL);
2220	res=ExecBash(codigo);
2221	if(res)
2222	MuestraMensaje(21,NULL);
2223	else
2224	MuestraMensaje(22,NULL);
2225	MuestraMenu(URLMENU);
2226
2227	if(!res){
2228	UltimoErrorScript(10,"ExecShell()"); // Se ha producido algún error
2229	}
2230
2231	char disco=(char)ReservaMemoria(2);
2232	sprintf(disco,"1"); // Siempre el disco 1
2233	char* parametroscfg=LeeConfiguracion(disco);
2234	int lon;
2235	lon=sprintf(nwtrama->parametros,"nfn=RESPUESTA_ExecShell\r");
2236	lon+=sprintf(nwtrama->parametros+lon,"cfg=%s\r",parametroscfg);
2237	RespuestaEjecucionComando(trama,nwtrama,res);
2238	return(true);
2239	}
2240	//______________________________________________________________________________________________________
2241	// Función: ConsolaRemota
2242	//
2243	// Descripción:
2244	// Ejecuta un comando de la Shell y envia el eco al servidor (Consola remota)
2245	// Parámetros:
2246	// - trama: Trama recibida con las especificaciones del comando
2247	// - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
2248	// Devuelve:
2249	// true siempre
2250	// ________________________________________________________________________________________________________
2251	int ConsolaRemota(TRAMA trama,TRAMA nwtrama)
2252	{
2253	FILE* f;
2254	long lSize;
2255	int herror;
2256
2257	char* comando=toma_parametro("cmd",trama->parametros); // Código del comando
2258	sprintf(filecmdshell,"%s/%s","/tmp","_hidrascript_");
2259	f = fopen(filecmdshell,"wt"); // Abre fichero de script
2260	if(f==NULL)
2261	RegistraLog("*** No se puede crear fichero temporal para ejecutar la consola remota", false);
2262	else{
2263	lSize=strlen(comando);
2264	fwrite(comando,1,lSize,f); // Escribe el código a ejecutar
2265	fclose(f);
2266	sprintf(cmdshell,"/bin/chmod"); // Da permiso de ejecución al fichero
2267	sprintf(parametros,"%s %s %s","/bin/chmod","+x",filecmdshell);
2268	herror=EjecutarScript(cmdshell,parametros,NULL,true);
2269	if(herror){
2270	UltimoErrorScript(herror,"ConsolaRemota()"); // Se ha producido algún error
2271	}
2272	else{
2273	sprintf(cmdshell,"%s/remoteConsole",HIDRASCRIPTS);
2274	herror=EjecutarScript(cmdshell,NULL,NULL,true);
2275	if(herror){
2276	UltimoErrorScript(herror,"ExecBash()"); // Se ha producido algún error
2277	}
2278	}
2279	}
2280	return(true);
2281	}
2282	//______________________________________________________________________________________________________
2283	// Función: ExecBash
2284	//
2285	// Descripción:
2286	// Ejecuta código bash
2287	// Parámetros:
2288	// - codigo: Código a ejecutar
2289	// Devuelve:
2290	// true si el proceso fue correcto o false en caso contrario
2291	// ________________________________________________________________________________________________________
2292	int ExecBash(char*codigo){
2293	FILE* f;
2294	long lSize;
2295	int herror,res;
2296
2297	sprintf(filecmdshell,"%s/%s","/tmp","_hidrascript_");
2298	f = fopen(filecmdshell,"wt"); // Abre fichero de script
2299	if(f==NULL)
2300	res=false; // Error de apertura del fichero de configuración
2301	else{
2302	lSize=strlen(codigo);
2303	fwrite(codigo,1,lSize,f); // Escribe el código a ejecutar
2304	fclose(f);
2305	sprintf(cmdshell,"/bin/chmod"); // Da permiso de ejecución al fichero
2306	sprintf(parametros,"%s %s %s","/bin/chmod","+x",filecmdshell);
2307	herror=EjecutarScript(cmdshell,parametros,NULL,true);
2308	if(herror){
2309	UltimoErrorScript(herror,"ExecBash()"); // Se ha producido algún error
2310	res=false;
2311	}
2312	else{
2313	sprintf(cmdshell,"%s",filecmdshell); // Ejecución el fichero de script creado
2314	//int herror=EjecutarScript(cmdshell,NULL,NULL,true);
2315	int herror=system(cmdshell);
2316	if(herror){
2317	UltimoErrorScript(herror,"ExecBash()"); // Se ha producido algún error
2318	res=false;
2319	}
2320	}
2321	}
2322	return(res);
2323	}
2324	//______________________________________________________________________________________________________
2325	// Función: URLDecode
2326	//
2327	// Descripción:
2328	// Decodifica una cadena codificada con UrlEncode
2329	// Parámetros:
2330	// - src: La cadena a decodificar
2331	// Devuelve:
2332	// La cadena decodificada
2333	// ________________________________________________________________________________________________________
2334	char* URLDecode(char *src)
2335	{
2336	const char *p = src;
2337	char code[3] = {0};
2338	unsigned long ascii = 0;
2339	char *end = NULL;
2340	char dest,cad;
2341
2342	dest=(char*)ReservaMemoria(strlen(src)); // Reserva buffer para la cadena
2343	cad=dest;
2344	while(*p){
2345	if(*p == '%'){
2346	memcpy(code, ++p, 2);
2347	ascii = strtoul(code, &end, 16);
2348	*dest++ = (char)ascii;
2349	p += 2;
2350	}
2351	else
2352	dest++ = p++;
2353	}
2354	return(cad);
2355	}
2356	//______________________________________________________________________________________________________
2357	// Función: URLEncode
2358	//
2359	// Descripción:
2360	// Codifica una cadena en UrlEncode
2361	// Parámetros:
2362	// - src: La cadena a decodificar
2363	// Devuelve:
2364	// La cadena decodificada
2365	// ________________________________________________________________________________________________________
2366	char* URLEncode(char *src)
2367	{
2368	char *dest;
2369	int i,j=0,lon;
2370
2371	lon=strlen(src);
2372	dest=(char)ReservaMemoria(lon2); // Reserva buffer para la cadena
2373	for(i=0;i<lon;i++){
2374	if(src[i]==0x20){ // Espacio
2375	dest[j++] = '%';
2376	dest[j++] = '2';
2377	dest[j++] = '0';
2378	}
2379	else
2380	dest[j++] = src[i];
2381	}
2382	return(dest);
2383	}
2384	//______________________________________________________________________________________________________
2385	// Función: RespuestaEjecucionComando
2386	//
2387	// Descripción:
2388	// Envia una respuesta a una ejecución de comando al servidor de Administración
2389	// Parámetros:
2390	// - trama: Trama recibida con las especificaciones del comando
2391	// - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
2392	// - res: Resultado de la ejecución (true si la ejecución es correcta y false en caso contrario)
2393	// Devuelve:
2394	// true si la respuesta se envía correctamente al servidor
2395	// ________________________________________________________________________________________________________
2396	int RespuestaEjecucionComando(TRAMA* trama, TRAMA *nwtrama, int res)
2397	{
2398	int idsuceso=0;
2399	char *widsuceso=toma_parametro("ids",trama->parametros);
2400	if(widsuceso) idsuceso=atoi(widsuceso);
2401	int lon;
2402	lon=strlen(nwtrama->parametros);
2403	lon+=sprintf(nwtrama->parametros+lon,"ids=%d\r",idsuceso); // Identificador del suceso
2404	char descrierror[250];
2405	if (res){ // Resultado satisfactorio
2406	lon+=sprintf(nwtrama->parametros+lon,"res=%s\r","1"); // Resultado de la ejecucin del comando
2407	sprintf(descrierror,"%s "," ");
2408	lon+=sprintf(nwtrama->parametros+lon,"der=%s\r",descrierror); // Dscripcin del error si lo ha habido
2409	}
2410	else{ // Algún error
2411	lon+=sprintf(nwtrama->parametros+lon,"res=%s\r","2"); // Resultado de la ejecución del comando
2412	sprintf(descrierror,"Error.-(%s) en modulo %s",e.msg,e.modulo);
2413	lon+=sprintf(nwtrama->parametros+lon,"der=%s\r",descrierror); // Descripción del error si lo ha habido
2414	}
2415	if(AbreConexionTCP()){
2416	if(!EnviaTramasHidra(sock,nwtrama)){
2417	UltimoError(21,"RespuestaEjecucionComando()");
2418	return(false);
2419	}
2420	if(!recibe_tramas(sock,trama)){
2421	UltimoError(22,"RespuestaEjecucionComando()");
2422	return(false);
2423	}
2424	CierraConexionTCP();
2425	GestionTramas(trama); // Analiza la trama
2426	}
2427	else{
2428	UltimoError(2,"RespuestaEjecucionComando()");
2429	return(false);
2430	}
2431	return(true);
2432	}
2433	//***********************************************************************************************************************
2434	// PROGRAMA PRINCIPAL
2435	//***********************************************************************************************************************
2436	int main(int argc, char *argv[])
2437	{
2438
2439	//Archivos por defecto
2440	strcpy(szPathFileCfg,"ogAdmClient.cfg");
2441	strcpy(szPathFileLog,"ogAdmClient.log");
2442
2443	// Validación de argumentos y lectura del fichero de configuración
2444	if(ndebug>5)
2445	RegistraLog("ValidacionParametros", false);
2446
2447	if(!ValidacionParametros(argc,argv))
2448	exit(EXIT_FAILURE);
2449	else{
2450	if(ndebug>5)
2451	RegistraLog("CrearArchivoLog", false);
2452	if(!CrearArchivoLog(szPathFileLog))
2453	exit(EXIT_FAILURE);
2454	else{
2455	if(ndebug>5)
2456	RegistraLog("LeeFileConfiguracion", false);
2457	if(!LeeFileConfiguracion(szPathFileCfg)){ // Toma parámetros de configuración
2458	UltimoError(13,"Main()");
2459	exit(EXIT_FAILURE);
2460	}
2461	}
2462	}
2463	if(ndebug>5)
2464	RegistraLog("Guarda datos básicos del cliente", false);
2465
2466	strcpy(Propiedades.servidorhidra,Servidorhidra);
2467	strcpy(Propiedades.puerto,Puerto);
2468	strcpy(Propiedades.idordenador,"0");
2469	if(!TomaIPlocal()){ // Error al recuperar la IP local
2470	UltimoError(0,"Main()");
2471	exit(EXIT_FAILURE);
2472	}
2473	MuestraMensaje(0,NULL);
2474	sleep(2);
2475	strcpy(Propiedades.IPlocal,IPlocal);
2476	RegistraLog("Abriendo sesión en el servidor de Administración", false);
2477	if(InclusionCliente()){ // El cliente ha abierto sesión correctamente
2478	if(strcmp(Propiedades.idordenador,"0")==0){ // Ha habido algún problema al inciar sesión
2479	UltimoError(0,"Main()");
2480	exit(EXIT_FAILURE);
2481	}
2482	RegistraLog("Cliente iniciado", false);
2483
2484	if(!cuestionCache(Propiedades.cache)){ // Procesa la cache
2485	UltimoError(0,"Main()");
2486	exit(EXIT_FAILURE);
2487	}
2488
2489	RegistraLog("Ejecución de archivo Autoexec", false);
2490	if(!AutoexecClienteHidra()){ // Ejecución fichero autoexec
2491	UltimoError(0,"Main()");
2492	exit(EXIT_FAILURE);
2493	}
2494	RegistraLog("Procesa comandos pendientes", false);
2495	ComandosPendientes(); // Bucle para procesar comandos pendientes
2496	RegistraLog("Acciones pendientes procesadas", false);
2497	MuestraMenu(URLMENU);
2498	RegistraLog("Disponibilidad para comandos interactivos activada ...", false);
2499	ProcesaComandos(); // Bucle para procesar comandos interactivos
2500	RegistraLog("Disponibilidad para comandos interactivos desactivada...", false);
2501	}
2502	else{
2503	UltimoError(0,"Main()");
2504	exit(EXIT_FAILURE);
2505	}
2506	exit(0);
2507	}
2508
2509
2510
2511

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

Context Navigation

source: admin/Services/ogAdmClient/sources/ogAdmClient.c @ 81b4351

Download in other formats: