Context Navigation

ogAdmClient.c @ 73cfa0a

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

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

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

Context Navigation

source: admin/Services/ogAdmClient/sources/ogAdmClient.c @ 73cfa0a

Download in other formats: