Context Navigation

ogAdmClient.c @ 49c6891

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

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

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

Context Navigation

source: admin/Services/ogAdmClient/sources/ogAdmClient.c @ 49c6891

Download in other formats: