Context Navigation

ogAdmClient.c @ 06be672

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

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

Context Navigation

source: admin/Services/ogAdmClient/sources/ogAdmClient.c @ 06be672

Download in other formats: