Context Navigation

ogAdmClient.c @ c5ce04c

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 c5ce04c was fa2ba4f2, checked in by alonso <alonso@…>, 16 years ago

primeros archivos de administración

git-svn-id: https://opengnsys.es/svn/trunk@575 a21b9725-9963-47de-94b9-378ad31fedc9

Property mode set to 100644

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

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

Context Navigation

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

Download in other formats: