Context Navigation

ogAdmClient.c @ 3fef8e1

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

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

Context Navigation

source: admin/Services/ogAdmClient/sources/ogAdmClient.c @ 3fef8e1

Download in other formats: