Context Navigation

ogAdmClient.c @ 538d9e0

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

Line
1	//****************************************************************************************************************************************************
2	// Aplicación OpenGNSys
3	// Autor: José Manuel Alonso.
4	// Licencia: Open Source
5	// Fichero: ogAdmClient.c
6	// Descripción:
7	// Este módulo de la aplicación OpenGNSys implementa las comunicaciones con el Cliente.
8	// ****************************************************************************************************************************************************
9	#include "ogAdmClient.h"
10	//______________________________________________________________________________________________________
11	// Función: Encripta
12	//
13	// Descripción:
14	// Encripta una cadena
15	// Parámetros:
16	// - cadena: Cadena a encriptar
17	// Devuelve:
18	// - La cadena encriptada
19	//______________________________________________________________________________________________________
20	char* Encriptar(char *cadena)
21	{
22	return(cadena);
23
24	int i,lon;
25	char clave;
26
27	clave = 12 & 0xFFU; // La clave elegida entre 0-255, en este caso 12
28	lon=strlen(cadena);
29	for(i=0;i<lon;i++)
30	cadena[i]=((char)cadena[i] ^ clave) & 0xFF;
31	return(cadena);
32	}
33	//______________________________________________________________________________________________________
34	// Función: Desencripta
35	//
36	// Descripción:
37	// Desencripta una cadena
38	// Parámetros:
39	// - cadena: Cadena a desencriptar
40	// Devuelve:
41	// La cadena desencriptada
42	//______________________________________________________________________________________________________
43	char* Desencriptar(char *cadena)
44	{
45	return(cadena);
46
47	int i,lon;
48	char clave;
49
50	clave = 12 & 0xFFU; // La clave elegida entre 0-255, en este caso 12
51	lon=strlen(cadena);
52	for(i=0;i<lon;i++)
53	cadena[i]=((char)cadena[i] ^ clave) & 0xFF;
54	return(cadena);
55
56	}
57	//______________________________________________________________________________________________________
58	// Función: ValidacionParametros
59	//
60	// Descripción:
61	// Valida que los parametros de ejecución del programa sean correctos
62	// Parámetros:
63	// - argc: Número de argumentos
64	// - argv: Puntero a cada argumento
65	// Devuelve:
66	// true si los argumentos pasados son correctos y false en caso contrario
67	// Especificaciones:
68	// La sintaxis de los argumentos es la siguiente
69	// -f Archivo de configuración del cliente
70	// -l Archivo de logs
71	// -d Nivel de debuger (Mensages que se escribirán en el archivo de logs)
72	//______________________________________________________________________________________________________
73	int ValidacionParametros(int argc,char*argv[])
74	{
75	int i;
76
77	for(i = 1; i < argc; i++){
78	if (argv[i][0] == '-'){
79	switch (tolower(argv[i][1])){
80	case 'f':
81	if (argv[i+1]!=NULL)
82	strcpy(szPathFileCfg, argv[i+1]);
83	else
84	return(false); // Error en el argumento archivo de configuración
85	break;
86	case 'l':
87	if (argv[i+1]!=NULL)
88	strcpy(szPathFileLog, argv[i+1]); // Error en el argumento archivo de log
89	else
90	return(false);
91	break;
92	case 'd':
93	if (argv[i+1]!=NULL){
94	ndebug=atoi(argv[i+1]);
95	if(ndebug<1 )
96	ndebug=1; // Por defecto el nivel de debug es 1
97	}
98	else
99	return(false); // Error en el argumento nivel de debug
100	break;
101	default:
102	return(false);
103	break;
104	}
105	}
106	}
107	return(true);
108	}
109	//______________________________________________________________________________________________________
110	// Función: CrearArchivoLog
111	//
112	// Descripción:
113	// Abre el archivo de log para añadir registros desde el principio y si no existe lo crea de nuevo
114	// Parámetros:
115	// - szPathFileLog: Nombre del archivo
116	// Devuelve:
117	// true si la acción ha sido correcta y false en caso contrario
118	//______________________________________________________________________________________________________
119	int CrearArchivoLog(char* szPathFileLog)
120	{
121	return(true);
122	FILE* FLog;
123	FLog=fopen(szPathFileLog,"wt"); // Abre de log para escritura al comienzo
124	if(FLog!=NULL){
125	fclose(FLog);
126	return(true);
127	}
128	return(false);
129	}
130	//______________________________________________________________________________________________________
131	// Función: LeeFileConfiguracion
132	//
133	// Descripción:
134	// Lee el fichero de configuración y toma el valor de los parámetros de configuración
135	// Parámetros:
136	// Ninguno
137	// Devuelve:
138	// true si todos los parámetros de configuración son correctos y false en caso contrario
139	//______________________________________________________________________________________________________
140	int LeeFileConfiguracion()
141	{
142	long lSize;
143	char * buffer,lineas[100],dualparametro[2];
144	char ch[2];
145	int i,numlin,resul;
146	FILE* 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(0,msglog);
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	//Pantallas
1679	MuestraMensaje(3,NULL);
1680
1681	sprintf(cmdshell,"%s/admRestoreImage",HIDRASCRIPTS);
1682	sprintf(parametros," %s %s %s %s %s","admRestoreImage","REPO",fileimg,disco,particion);
1683
1684	if(ndebug>3){
1685	sprintf(msglog,"Restaurando Imagen disco:%s, partición:%s, Repositorio:%s, Imagen:%s",disco,particion,Propiedades.iprepo,fileimg);
1686	Log(msglog);
1687	}
1688
1689	herror=EjecutarScript(cmdshell,parametros,NULL,true);
1690	if(herror) // Restauración correcta
1691	MuestraMensaje(12,NULL);
1692	else
1693	MuestraMensaje(11,NULL);
1694	MuestraMenu(URLMENU);
1695
1696	if(herror){
1697	UltimoErrorScript(herror,"RestaurandoImagen()"); // Se ha producido algún error
1698	return(false);
1699	}
1700	else
1701	return(true);
1702	}
1703	//______________________________________________________________________________________________________
1704	// Función: ParticionaryFormatear
1705	//
1706	// Descripción:
1707	// Modifica la tabla de particiones del sector de arranque master y formatea particiones
1708	// Parámetros:
1709	// - trama: Trama recibida con las especificaciones del comando
1710	// - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
1711	// Devuelve:
1712	// true si el proceso fue correcto o false en caso contrario
1713	//____________________________________________________________________________________________________
1714	int ParticionaryFormatear(TRAMAtrama,TRAMAnwtrama)
1715	{
1716	int res,i,parfor;
1717	char* parametroscfg;
1718	char ch[2],*parhdc[8];
1719	char *PrimaryPartitions=TomaParametro("ppa",trama->parametros);
1720	char *LogicalPartitions=TomaParametro("lpa",trama->parametros);
1721	char *HDCleanPartition=TomaParametro("hdc",trama->parametros);
1722
1723	char disco=(char)ReservaMemoria(2);
1724	sprintf(disco,"1"); // Siempre el disco 1
1725
1726
1727	Log("Creando o modificando tabla de particiones");
1728	//Pantallas
1729	MuestraMensaje(4,NULL);
1730	res=Particionar(disco,PrimaryPartitions,LogicalPartitions); // Creando las particiones
1731	if(res)
1732	MuestraMensaje(13,NULL);
1733	else
1734	MuestraMensaje(14,NULL);
1735
1736	if(res){
1737	strcpy(ch,";"); // Caracter delimitador
1738	parfor=SplitParametros(parhdc,HDCleanPartition,ch);
1739	for(i = 0; i<parfor; i++){ // Formateando particiones
1740	//Pantallas
1741	MuestraMensaje(5,NULL);
1742	res=Formatear(disco,parhdc[i]);
1743	if(res)
1744	MuestraMensaje(15,NULL);
1745	else
1746	MuestraMensaje(16,NULL);
1747	if(!res) break;
1748	}
1749	}
1750	MuestraMenu(URLMENU);
1751	Log("Finalizado el particionado y formateado de particiones");
1752	parametroscfg=LeeConfiguracion(disco); // Toma la nueva configuración
1753
1754	int lon;
1755	lon=sprintf(nwtrama->parametros,"nfn=RESPUESTA_ParticionaryFormatear\r");
1756	lon+=sprintf(nwtrama->parametros+lon,"cfg=%s\r",parametroscfg);
1757	RespuestaEjecucionComando(trama,nwtrama,res);
1758
1759	return(res);
1760	}
1761	//______________________________________________________________________________________________________
1762	// Función: Particionar
1763	//
1764	// Descripción:
1765	// Modifica la tabla de particiones del sector de arranque master pero SIN formatear ninguna partición
1766	// Parámetros:
1767	// - PrParticion: Cadena con la sintaxis de particionado de las particiones primarias
1768	// - LoParticion: Cadena con la sintaxis de particionado de las particiones secundarias
1769	// Devuelve:
1770	// true si el proceso fue correcto o false en caso contrario
1771	//______________________________________________________________________________________________________
1772	int Particionar(char* disco,char* PrParticion,char* LoParticion)
1773	{
1774	if (strlen(PrParticion)>0){
1775	if(Particionando(disco,PrParticion,"admCreatePrimaryPartitions")){ // Particiones Primarias
1776	if (strlen(LoParticion)>0)
1777	return(Particionando(disco,PrParticion,"admCreateLogicalPartitions")); // Particiones Logicas
1778	else
1779	return(true);
1780	}
1781	else
1782	return(false);
1783	}
1784	if (strlen(LoParticion)>0)
1785	return(Particionando(disco,PrParticion,"admCreateLogicalPartitions"));
1786	else
1787	return(false);
1788	}
1789	//______________________________________________________________________________________________________
1790	// Función: Particionando
1791	//
1792	// Descripción:
1793	// Modifica la tabla de particiones del sector de arranque master pero SIN formatear ninguna partición
1794	// Parámetros:
1795	// - disco: Disco en el que se modificará la tabla de particiones 1,2,3..
1796	// - SintaxParticion: Cadena con la sintaxis de particionado de las particiones primarias
1797	// - script: Nombre del script que se ejecutará
1798	// Devuelve:
1799	// true si el proceso fue correcto o false en caso contrario
1800	// Especificaciones:
1801	// Esta función es auxiliar de la anterior y es llamda por esta en dos ocasiones, para las particiones Primarias y Lógicas
1802	//______________________________________________________________________________________________________
1803	int Particionando(char* disco,char* stxParticion,char* script)
1804	{
1805	int herror;
1806
1807	sprintf(cmdshell,"%s/%s",HIDRASCRIPTS,script);
1808	sprintf(parametros," %s %s %s",script,disco,stxParticion);
1809
1810	sprintf(msglog,"Modificando tabla de particiones:%s disco:%s, cadena:%s",script,disco,stxParticion);
1811	if(ndebug>1){
1812	Log(msglog);
1813	}
1814	herror=EjecutarScript(cmdshell,parametros,NULL,true);
1815	if(herror){
1816	UltimoErrorScript(herror,"Particionar()"); // Se ha producido algún error
1817	return(false);
1818	}
1819	else
1820	return(true);
1821	}
1822	//______________________________________________________________________________________________________
1823	// Función: Formatear
1824	//
1825	// Descripción:
1826	// Formatea una partición
1827	// Parámetros:
1828	// - disco: Número del disco
1829	// - particion: Número de partición a formatear
1830	// Devuelve:
1831	// true si el proceso fue correcto o false en caso contrario
1832	//______________________________________________________________________________________________________
1833	int Formatear(char* disco,char* particion)
1834	{
1835	int herror;
1836
1837	sprintf(cmdshell,"%s/admFormatFs",HIDRASCRIPTS);
1838	sprintf(parametros," %s %s %s","FormatFs",disco,particion);
1839	herror=EjecutarScript(cmdshell,parametros,NULL,true);
1840	if(herror){
1841	UltimoErrorScript(herror,"Formatear()"); // Se ha producido algún error
1842	return(false);
1843	}
1844	return(true);
1845	}
1846	//______________________________________________________________________________________________________
1847	// Función: SetCachePartitionSize
1848	//
1849	// Descripción:
1850	// Dimensiona el tamaño de la caché
1851	// Parámetros:
1852	// - t : Tamaño a asignar de la caché
1853	// Devuelve:
1854	// true si el proceso fue correcto o false en caso contrario
1855	// ________________________________________________________________________________________________________
1856	int SetCachePartitionSize(int t)
1857	{
1858	return(true);
1859	}
1860	//___________________________________________________________________________________________________
1861	//
1862	//
1863	//______________________________________________________________________________________________________
1864	// Función: AutoClienteHidra
1865	//
1866	// Descripción:
1867	// Ejecuta un fichero autoexec preparado para el cliente
1868	// ________________________________________________________________________________________________________
1869	int AutoexecClienteHidra()
1870	{
1871	sprintf(fileini,"/autoexec/INI_%s",Propiedades.IPlocal); // Nombre del fichero autoexec
1872	if(ExisteFichero(fileini)){
1873	if(LoadTextFile(fileini)){ // Lee fichero autoexec
1874	GestionTramas(trama); // Analiza la trama
1875	}
1876	else{
1877	UltimoError(6,"AutoexecClienteHidra()");
1878	return(false);
1879	}
1880	}
1881	return(true);
1882	}
1883	//______________________________________________________________________________________________________
1884	// Función: LeeConfiguracion
1885	//
1886	// Descripción:
1887	// Recupera la configuración de particiones del ordenador
1888	// Parámetros:
1889	// disco: Disco a analizar 1,2,3..
1890	// Devuelve:
1891	// Una cadena con la configuración del cliente (ver manual)
1892	// ________________________________________________________________________________________________________
1893	char* LeeConfiguracion(char* disco)
1894	{
1895	int herror;
1896	char *cadenaparticiones;
1897	char *nomso;
1898
1899	cadenaparticiones=(char*)ReservaMemoria(LONGITUD_SCRIPTSALIDA);
1900	sprintf(cmdshell,"%s/admListPrimaryPartitions",HIDRASCRIPTS);
1901	sprintf(parametros," %s %s","admListPrimaryPartitions",disco);
1902	herror=EjecutarScript(cmdshell,parametros,cadenaparticiones,true);
1903	if(herror){
1904	UltimoErrorScript(herror,"LeeConfiguracion()"); // Se ha producido algún error
1905	return(NULL);
1906	}
1907	struct s_Particiones *tbcfg[MAXPARTICIONES];
1908	char duplasparticiones[MAXPARTICIONES],duplaparticion[2];
1909
1910	int iPar=SplitParametros(duplasparticiones,cadenaparticiones," "); // Caracter separatorio de los elementos de un item
1911	int i,j;
1912	for( i = 0; i<iPar; i++){
1913	SplitParametros(duplaparticion,duplasparticiones[i],":");
1914	tbcfg[i]=(struct s_Particiones*)ReservaMemoria(sizeof(struct s_Particiones)); // Toma espacio para tabla de configuraciones
1915	strcpy(tbcfg[i]->tipopart,duplaparticion[0]); // Tipo de partición
1916	strcpy(tbcfg[i]->tamapart,duplaparticion[1]); // Tamaño de partición
1917	sprintf(tbcfg[i]->numpart,"%d",i+1); // Número de partición
1918
1919	for(j=0;j<ntiposo;j++){
1920	if(strcmp(tiposos[j].tipopart,duplaparticion[0])==0 && strcmp(tiposos[j].tipopart,"LINUX-SWAP")!=0 && strcmp(tiposos[j].tipopart,"EMPTY")!=0){
1921	nomso=TomaNomSO(disco,i+1);
1922	if(nomso!=NULL){ // Averigua qué sistema operativo está instalado en la partición
1923	strcpy(tbcfg[i]->tiposo,tiposos[j].tiposo); // Nombre S.O.
1924	strcpy(tbcfg[i]->nombreso,nomso); // Nombre completo S.O.
1925	}
1926	else{
1927	strcpy(tbcfg[i]->tiposo,""); // Nombre S.O.
1928	strcpy(tbcfg[i]->nombreso,""); // Nombre completo S.O.
1929	}
1930	break;
1931	}
1932	}
1933	}
1934	char *cfg=ReservaMemoria(LONGITUD_CONFIGURACION);
1935	if(!cfg){
1936	UltimoError(1,"LeeConfiguracion()");
1937	return(NULL);
1938	}
1939	int lon=0;
1940	for( i = 0; i<iPar; i++){
1941	lon+=sprintf(cfg+lon,"@cfg\n");
1942	lon+=sprintf(cfg+lon,"tiposo=%s\n",tbcfg[i]->tiposo);
1943	lon+=sprintf(cfg+lon,"tipopart=%s\n",tbcfg[i]->tipopart);
1944	lon+=sprintf(cfg+lon,"tamapart=%s\n",tbcfg[i]->tamapart);
1945	lon+=sprintf(cfg+lon,"numpart=%s\n",tbcfg[i]->numpart);
1946	lon+=sprintf(cfg+lon,"nombreso=%s\t",tbcfg[i]->nombreso);
1947	}
1948	return(cfg);
1949	}
1950	//______________________________________________________________________________________________________
1951	// Función: TomaNomSO
1952	//
1953	// Descripción:
1954	// Recupera el nombre del sistema operativo instalado en una partición
1955	// Parámetros:
1956	// disco: Disco 1,2,3..
1957	// particion: Número de la partición
1958	// Devuelve:
1959	// Una cadena con el nombre del S.O.
1960	// ________________________________________________________________________________________________________
1961	char* TomaNomSO(char*disco,int particion)
1962	{
1963	int herror,lon;
1964	char *infosopar;
1965	char* sover[2];
1966	char ch[2];
1967
1968	infosopar=(char*)ReservaMemoria(LONGITUD_SCRIPTSALIDA); // Información del S.O. de la partición
1969
1970	sprintf(cmdshell,"%s/admGetOsVersion",HIDRASCRIPTS);
1971	sprintf(parametros," %s %s %d","admGetOsVersion",disco,particion);
1972	herror=EjecutarScript(cmdshell,parametros,infosopar,true);
1973	if(herror){
1974	UltimoErrorScript(herror,"TomaNomSO()"); // Se ha producido algún error
1975	return(NULL);
1976	}
1977	if(strlen(infosopar)==0) return(NULL); // NO Existe S.O. en la partición
1978	strcpy(ch,":");// caracter delimitador (dos puntos)
1979	lon=SplitParametros(sover,infosopar,ch);
1980	return(sover[1]);
1981	}
1982	//______________________________________________________________________________________________________
1983	// Función: MuestraMenu
1984	//
1985	// Descripción:
1986	// Muestra menú del cliente
1987	// Parámetros:
1988	// ips: Dirección IP del servidor web que implementa la consola de adminsitración
1989	// urp: Path o url de la página web que muestra el menu del cliente
1990	// iph: Dirección ip del cliente
1991	// Devuelve:
1992	// Nada
1993	// ________________________________________________________________________________________________________
1994	int MuestraMenu(char *urp)
1995	{
1996	int herror,nargs,resul;
1997
1998	if(ndebug>4){
1999	sprintf(msglog,"Url:%s",urp);
2000	Log(msglog);
2001	}
2002
2003	if(pidmenu>0)
2004	kill(pidmenu,SIGQUIT); // Se carga el proceso hijo anterior y se queda sólo el actual
2005
2006	//sprintf(cmdshell,"%s/admMenuBrowser",HIDRASCRIPTS);
2007	//sprintf(parametros,"%s %s","admMenuBrowser",urp);
2008
2009	sprintf(cmdshell,"/opt/opengnsys/bin/browser");
2010	sprintf(parametros,"%s %s %s","browser","-qws",urp);
2011
2012	nargs=SplitParametros(argumentos,parametros," "); // Crea matriz de los argumentos del scripts
2013	if((pidmenu=fork())==0){
2014	/* Proceso hijo que ejecuta el script */
2015	execv(cmdshell,argumentos);
2016	exit(resul);
2017	}
2018	else {
2019	if (pidmenu ==-1){
2020	UltimoErrorScript(herror,"MuestraMenu()"); // Se ha producido algún error
2021	return(false);
2022	}
2023	}
2024	sleep(5); // Espera 5 segundos con el mensaje en pantalla
2025	return(true);
2026	}
2027	//______________________________________________________________________________________________________
2028	// Función: MuestraMensaje
2029	//
2030	// Descripción:
2031	// Envia una página al browser con un mensaje determinado
2032	// Parámetros:
2033	// - idx: Indice de la cadena del mensaje
2034	// ________________________________________________________________________________________________________
2035	void MuestraMensaje(int idx,char*msg){
2036	if(msg)
2037	sprintf(urlpag,"%s?msg=%s",URLMSG,URLEncode(msg)); // Url de la página de mensajes
2038	else
2039	sprintf(urlpag,"%s?idx=%d",URLMSG,idx); // Url de la página de mensajes
2040	MuestraMenu(urlpag);
2041	}
2042	//______________________________________________________________________________________________________
2043	// Función: InventarioHardware
2044	//
2045	// Descripción:
2046	// Recupera la configuración de hardware del ordenador
2047	// Parámetros:
2048	// - trama: Trama recibida con las especificaciones del comando
2049	// - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
2050	// Devuelve:
2051	// true si el proceso fue correcto o false en caso contrario
2052	// Especificaciones:
2053	// Lo que se envía al servidor es una cadena con el formato de salida del script que ejecuta
2054	// está función. (Vease scripts hidraHardwareInfo)
2055	// ________________________________________________________________________________________________________
2056	int InventarioHardware(TRAMA trama,TRAMA nwtrama)
2057	{
2058	int herror,res;
2059	char *parametroshrd;
2060
2061	MuestraMensaje(6,NULL);
2062
2063	parametroshrd=(char*)ReservaMemoria(LONGITUD_SCRIPTSALIDA);
2064	sprintf(cmdshell,"%s/admListHardwareInfo",HIDRASCRIPTS);
2065
2066	herror=EjecutarScript(cmdshell,NULL,parametroshrd,true);
2067	sprintf(msglog,"EL ERRRRRRRRRRRR es %d",herror);
2068	if(herror)
2069	MuestraMensaje(0,msglog);
2070	else
2071	MuestraMensaje(17,NULL);
2072	MuestraMenu(URLMENU);
2073
2074	if(herror){
2075	UltimoErrorScript(herror,"InventarioHardware()"); // Se ha producido algún error
2076	}
2077	res=(herror==0); // Si se ha producido algún error el resultado de la ejecución de error
2078
2079	int lon;
2080	lon=sprintf(nwtrama->parametros,"nfn=RESPUESTA_TomaHardware\r");
2081	lon+=sprintf(nwtrama->parametros+lon,"hrd=%s\r",parametroshrd);
2082	RespuestaEjecucionComando(trama,nwtrama,res);
2083	return(res);
2084	}
2085	//______________________________________________________________________________________________________
2086	// Función: InventarioSoftware
2087	//
2088	// Descripción:
2089	// Recupera la configuración de software del ordenador
2090	// Parámetros:
2091	// - trama: Trama recibida con las especificaciones del comando
2092	// - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
2093	// Devuelve:
2094	// true si el proceso fue correcto o false en caso contrario
2095	// Especificaciones:
2096	// Lo que se envía al servidor es una cadena con el formato de salida del script que ejecuta
2097	// está función. (Vease scripts hidraSoftwareInfo)
2098	// ________________________________________________________________________________________________________
2099	int InventarioSoftware(TRAMA trama,TRAMA nwtrama)
2100	{
2101	int herror,res;
2102	char parametrossft,infopar;
2103	char *particion=TomaParametro("par",trama->parametros); // Toma partición
2104	//char *tipo=TomaParametro("tpl",trama->parametros); // Toma tipo de listado
2105
2106	char disco=(char)ReservaMemoria(2);
2107	sprintf(disco,"1"); // Siempre el disco 1
2108
2109	MuestraMensaje(7,NULL);
2110
2111	sprintf(cmdshell,"%s/admListSoftwareInfo",HIDRASCRIPTS);
2112	sprintf(parametros,"%s %s %s","admListSoftwareInfo",disco,particion);
2113
2114	parametrossft=(char*)ReservaMemoria(LONGITUD_SCRIPTSALIDA);
2115
2116	herror=EjecutarScript(cmdshell,parametros,parametrossft,true);
2117	if(herror)
2118	MuestraMensaje(20,NULL);
2119	else
2120	MuestraMensaje(19,NULL);
2121	MuestraMenu(URLMENU);
2122
2123	if(herror){
2124	UltimoErrorScript(herror,"InventarioSoftware()"); // Se ha producido algún error
2125	}
2126	res=(herror==0); // Si se ha producido algún error el resultado de la ejecución de error
2127	// Toma tipo de partición
2128	infopar=(char*)ReservaMemoria(16); //Tipo de partición
2129	if(res && infopar){
2130	sprintf(cmdshell,"%s/admGetFsType",HIDRASCRIPTS);
2131	sprintf(parametros," %s %s %s","getFsType",disco,particion);
2132	herror=EjecutarScript(cmdshell,parametros,infopar,true);
2133	if(herror){
2134	UltimoErrorScript(herror,"InventarioSoftware()"); // Se ha producido algún error
2135	}
2136	}
2137	int lon;
2138	lon=sprintf(nwtrama->parametros,"nfn=RESPUESTA_TomaSoftware\r");
2139	lon+=sprintf(nwtrama->parametros+lon,"sft=%s\r",parametrossft);
2140	lon+=sprintf(nwtrama->parametros+lon,"par=%s\r",particion);
2141	lon+=sprintf(nwtrama->parametros+lon,"tfs=%s\r",infopar);
2142	RespuestaEjecucionComando(trama,nwtrama,res);
2143	return(res);
2144	}
2145	//______________________________________________________________________________________________________
2146	// Función: TomaConfiguracion
2147	//
2148	// Descripción:
2149	// Toma la configuración de particiones de un ordenador
2150	// Parámetros:
2151	// - trama: Trama recibida con las especificaciones del comando
2152	// - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
2153	// Devuelve:
2154	// true si el proceso fue correcto o false en caso contrario
2155	// ________________________________________________________________________________________________________
2156	int TomaConfiguracion(TRAMA trama,TRAMA nwtrama)
2157	{
2158	char* parametroscfg;
2159
2160	char disco=(char)ReservaMemoria(2);
2161	sprintf(disco,"1"); // Siempre el disco 1
2162
2163	parametroscfg=LeeConfiguracion(disco);
2164
2165	int lon;
2166	lon=sprintf(nwtrama->parametros,"nfn=RESPUESTA_TomaConfiguracion\r");
2167	lon+=sprintf(nwtrama->parametros+lon,"cfg=%s\r",parametroscfg);
2168	RespuestaEjecucionComando(trama,nwtrama,true);
2169
2170	return(true);
2171	}
2172	//______________________________________________________________________________________________________
2173	// Función: ExecShell
2174	//
2175	// Descripción:
2176	// Ejecuta un script de la Shell
2177	// Parámetros:
2178	// - trama: Trama recibida con las especificaciones del comando
2179	// - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
2180	// Devuelve:
2181	// true si el proceso fue correcto o false en caso contrario
2182	// ________________________________________________________________________________________________________
2183	int ExecShell(TRAMA trama,TRAMA nwtrama)
2184	{
2185	int res;
2186
2187	char* wscript=TomaParametro("scp",trama->parametros); // Código del script
2188	char* codigo=URLDecode(wscript); // Decodifica el código recibido con formato URLCode
2189
2190	//Pantallas
2191	MuestraMensaje(8,NULL);
2192	res=ExecBash(codigo);
2193	if(res)
2194	MuestraMensaje(21,NULL);
2195	else
2196	MuestraMensaje(22,NULL);
2197	MuestraMenu(URLMENU);
2198
2199	if(!res){
2200	UltimoErrorScript(10,"ExecShell()"); // Se ha producido algún error
2201	}
2202
2203	char disco=(char)ReservaMemoria(2);
2204	sprintf(disco,"1"); // Siempre el disco 1
2205	char* parametroscfg=LeeConfiguracion(disco);
2206	int lon;
2207	lon=sprintf(nwtrama->parametros,"nfn=RESPUESTA_ExecShell\r");
2208	lon+=sprintf(nwtrama->parametros+lon,"cfg=%s\r",parametroscfg);
2209	RespuestaEjecucionComando(trama,nwtrama,res);
2210	return(true);
2211	}
2212	//______________________________________________________________________________________________________
2213	// Función: ExecBash
2214	//
2215	// Descripción:
2216	// Ejecuta código bash
2217	// Parámetros:
2218	// - codigo: Código a ejecutar
2219	// Devuelve:
2220	// true si el proceso fue correcto o false en caso contrario
2221	// ________________________________________________________________________________________________________
2222	int ExecBash(char*codigo){
2223	FILE* f;
2224	long lSize;
2225	int herror,res;
2226
2227	sprintf(filecmdshell,"%s/%s","/tmp","_hidrascript_");
2228	f = fopen(filecmdshell,"wt"); // Abre fichero de script
2229	if(f==NULL)
2230	res=false; // Error de apertura del fichero de configuración
2231	else{
2232	lSize=strlen(codigo);
2233	fwrite(codigo,1,lSize,f); // Escribe el código a ejecutar
2234	fclose(f);
2235	sprintf(cmdshell,"/bin/chmod"); // Da permiso de ejecución al fichero
2236	sprintf(parametros," %s %s %s","/bin/chmod","+x",filecmdshell);
2237	herror=EjecutarScript(cmdshell,parametros,NULL,true);
2238	if(herror){
2239	UltimoErrorScript(herror,"ExecBash()"); // Se ha producido algún error
2240	res=false;
2241	}
2242	else{
2243	sprintf(cmdshell,"%s",filecmdshell); // Ejecución el fichero de script creado
2244	//int herror=EjecutarScript(cmdshell,NULL,NULL,true);
2245	int herror=system(cmdshell);
2246	if(herror){
2247	UltimoErrorScript(herror,"ExecBash()"); // Se ha producido algún error
2248	res=false;
2249	}
2250	}
2251	}
2252	return(res);
2253	}
2254	//______________________________________________________________________________________________________
2255	// Función: URLDecode
2256	//
2257	// Descripción:
2258	// Decodifica una cadena codificada con UrlEncode
2259	// Parámetros:
2260	// - src: La cadena a decodificar
2261	// Devuelve:
2262	// La cadena decodificada
2263	// ________________________________________________________________________________________________________
2264	char* URLDecode(char *src)
2265	{
2266	const char *p = src;
2267	char code[3] = {0};
2268	unsigned long ascii = 0;
2269	char *end = NULL;
2270	char dest,cad;
2271
2272	dest=(char*)ReservaMemoria(strlen(src)); // Reserva buffer para la cadena
2273	cad=dest;
2274	while(*p){
2275	if(*p == '%'){
2276	memcpy(code, ++p, 2);
2277	ascii = strtoul(code, &end, 16);
2278	*dest++ = (char)ascii;
2279	p += 2;
2280	}
2281	else
2282	dest++ = p++;
2283	}
2284	return(cad);
2285	}
2286	//______________________________________________________________________________________________________
2287	// Función: URLEncode
2288	//
2289	// Descripción:
2290	// Codifica una cadena en UrlEncode
2291	// Parámetros:
2292	// - src: La cadena a decodificar
2293	// Devuelve:
2294	// La cadena decodificada
2295	// ________________________________________________________________________________________________________
2296	char* URLEncode(char *src)
2297	{
2298	char *dest;
2299	int i,j=0,lon;
2300
2301	lon=strlen(src);
2302	dest=(char)ReservaMemoria(lon2); // Reserva buffer para la cadena
2303	for(i=0;i<lon;i++){
2304	if(src[i]==0x20){ // Espacio
2305	dest[j++] = '%';
2306	dest[j++] = '2';
2307	dest[j++] = '0';
2308	}
2309	else
2310	dest[j++] = src[i];
2311	}
2312	return(dest);
2313	}
2314	//______________________________________________________________________________________________________
2315	// Función: RespuestaEjecucionComando
2316	//
2317	// Descripción:
2318	// Envia una respuesta a una ejecucion de comando al servidor de Administración
2319	// Parámetros:
2320	// - trama: Trama recibida con las especificaciones del comando
2321	// - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
2322	// - res: Resultado de la ejecución (true si la ejecución es correcta y false en caso contrario)
2323	// Devuelve:
2324	// true si la respuesta se envía correctamente al servidor
2325	// ________________________________________________________________________________________________________
2326	int RespuestaEjecucionComando(TRAMA* trama, TRAMA *nwtrama, int res)
2327	{
2328	int idsuceso=0;
2329	char *widsuceso=TomaParametro("ids",trama->parametros);
2330	if(widsuceso) idsuceso=atoi(widsuceso);
2331	int lon;
2332	lon=strlen(nwtrama->parametros);
2333	lon+=sprintf(nwtrama->parametros+lon,"ids=%d\r",idsuceso); // Identificador del suceso
2334	char descrierror[250];
2335	if (res){ // Resultado satisfactorio
2336	lon+=sprintf(nwtrama->parametros+lon,"res=%s\r","1"); // Resultado de la ejecucin del comando
2337	sprintf(descrierror,"%s "," ");
2338	lon+=sprintf(nwtrama->parametros+lon,"der=%s\r",descrierror); // Dscripcin del error si lo ha habido
2339	}
2340	else{ // Algún error
2341	lon+=sprintf(nwtrama->parametros+lon,"res=%s\r","2"); // Resultado de la ejecución del comando
2342	sprintf(descrierror,"Error.-(%s) en modulo %s",e.msg,e.modulo);
2343	lon+=sprintf(nwtrama->parametros+lon,"der=%s\r",descrierror); // Descripción del error si lo ha habido
2344	}
2345	if(AbreConexionTCP()){
2346	if(!EnviaTramasHidra(sock,nwtrama)){
2347	UltimoError(21,"RespuestaEjecucionComando()");
2348	return(false);
2349	}
2350	if(!RecibeTramasHidra(sock,trama)){
2351	UltimoError(22,"RespuestaEjecucionComando()");
2352	return(false);
2353	}
2354	CierraConexionTCP();
2355	GestionTramas(trama); // Analiza la trama
2356	}
2357	else{
2358	UltimoError(2,"RespuestaEjecucionComando()");
2359	return(false);
2360	}
2361	return(true);
2362	}
2363	//***********************************************************************************************************************
2364	// PROGRAMA PRINCIPAL
2365	//***********************************************************************************************************************
2366	int main(int argc, char *argv[])
2367	{
2368
2369	//Archivos por defecto
2370	strcpy(szPathFileCfg,"ogAdmClient.cfg");
2371	strcpy(szPathFileLog,"ogAdmClient.log");
2372
2373	// Validación de argumentos y lectura del fichero de configuración
2374	if(!ValidacionParametros(argc,argv))
2375	exit(EXIT_FAILURE);
2376	else{
2377	if(!CrearArchivoLog(szPathFileLog))
2378	exit(EXIT_FAILURE);
2379	else
2380	if(!LeeFileConfiguracion(szPathFileCfg)){ // Toma parámetros de configuracion
2381	UltimoError(13,"Main()");
2382	exit(EXIT_FAILURE);
2383	}
2384	}
2385	// Guarda datos básicos del cliente
2386	strcpy(Propiedades.servidorhidra,Servidorhidra);
2387	strcpy(Propiedades.puerto,Puerto);
2388	strcpy(Propiedades.idordenador,"0");
2389	if(!TomaIPlocal()){ // Error al recuperar la IP local
2390	UltimoError(0,"Main()");
2391	exit(EXIT_FAILURE);
2392	}
2393	MuestraMensaje(0,NULL);
2394	sleep(2);
2395	strcpy(Propiedades.IPlocal,IPlocal);
2396	Log("Abriendo sesión en el servidor de Administración");
2397	if(InclusionCliente()){ // El cliente ha abierto sesión correctamente
2398	if(strcmp(Propiedades.idordenador,"0")==0){ // Ha habido algún problema al inciar sesión
2399	UltimoError(0,"Main()");
2400	exit(EXIT_FAILURE);
2401	}
2402	Log("Cliente iniciado");
2403	Log("Ejecución de archivo Autoexec");
2404	if(!AutoexecClienteHidra()){ // Ejecución fichero autoexec
2405	UltimoError(0,"Main()");
2406	exit(EXIT_FAILURE);
2407	}
2408	Log("Procesa comandos pendientes");
2409	ComandosPendientes(); // Bucle para procesar comandos pendientes
2410	Log("Acciones pendientes procesadas");
2411	MuestraMenu(URLMENU);
2412	Log("Disponibilidad para comandos interactivos activada ...");
2413	ProcesaComandos(); // Bucle para procesar comando s interactivos
2414	Log("Disponibilidad para comandos interactivos desactivada...");
2415	}
2416	else{
2417	UltimoError(0,"Main()");
2418	exit(EXIT_FAILURE);
2419	}
2420	exit(0);
2421	}
2422
2423
2424
2425

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

Context Navigation

source: admin/Services/ogAdmClient/sources/ogAdmClient.c @ 538d9e0

Download in other formats: