Context Navigation

ogAdmClient.c @ fd11e20

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

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

Context Navigation

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

Download in other formats: