Context Navigation

ogAdmClient.c @ d1abd62

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 d1abd62 was d1abd62, checked in by alonso <alonso@…>, 15 years ago
git-svn-id: https://opengnsys.es/svn/trunk@618 a21b9725-9963-47de-94b9-378ad31fedc9
Property mode set to `100644`
File size: 81.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;
	1478
[b0bb14f]	1479	kill(pidmenu,SIGQUIT);
	1480	MuestraMensaje(1);
[a6b881e]	1481	res=InclusionCliente();
[b0bb14f]	1482	MuestraMenu(URLMENU);
[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;
[b0bb14f]	1541	sprintf(cmdshell,"%s/admCreateImage",HIDRASCRIPTS);
[044cd96]	1542	sprintf(parametros,"%s %s %s %s %s","createImage",disco,particion,"REPO",fileimg);
[c77c7d2]	1543
	1544	if(ndebug>3){
[1b66a79]	1545	sprintf(msglog,"Creando Perfil Software disco:%s, partición:%s, Repositorio:%s, Imagen:%s, Ruta:%s",disco,particion,Propiedades.iprepo,fileimg,"");
[c77c7d2]	1546	Log(msglog);
	1547	}
	1548
	1549	herror=EjecutarScript(cmdshell,parametros,NULL,true);
	1550	if(herror){
[a6b881e]	1551	UltimoErrorScript(herror,"CrearPerfil()"); // Se ha producido algún error
[c77c7d2]	1552	return(false);
	1553	}
	1554	else
	1555	return(true);
	1556	}
	1557	//______________________________________________________________________________________________________
	1558	// Función: Nemonico
	1559	//
	1560	// Descripción:
	1561	// Devuelve el código de un nemonico de S.O.
	1562	// Parámetros:
	1563	// -nem Nemonico del S.O.
	1564	// Devuelve:
	1565	// El código del nemónico
	1566	//______________________________________________________________________________________________________
	1567	int Nemonico(char* nem)
	1568	{
	1569	if(strcmp(nem,"MsDos")==0)
	1570	return(MsDos);
	1571	if(strcmp(nem,"Win98")==0)
	1572	return(Win98);
	1573	if(strcmp(nem,"Win2K")==0)
	1574	return(Win2K);
	1575	if(strcmp(nem,"WinXP")==0)
	1576	return( WinXP);
	1577	if(strcmp(nem,"Linux")==0)
	1578	return(Linux);
	1579	return(0);
	1580	}
	1581	//______________________________________________________________________________________________________
	1582	// Función: RestaurarImagen
	1583	//
	1584	// Descripción:
	1585	// Restaura una imagen en una partición
	1586	// Parámetros:
	1587	// - trama: Trama recibida con las especificaciones del comando
	1588	// - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
	1589	// Devuelve:
	1590	// true si el proceso fue correcto o false en caso contrario
	1591	//______________________________________________________________________________________________________
	1592	int RestaurarImagen(TRAMAtrama,TRAMAnwtrama)
	1593	{
	1594	int res=0;
	1595	char *wparticion=TomaParametro("par",trama->parametros); // partición de donde se crear el perfil
	1596	char *widimagen=TomaParametro("idi",trama->parametros); // Identificador de la imagen
	1597	char *widperfilsoft=TomaParametro("ifs",trama->parametros); // Perfil software a crear
	1598	char *widperfilhard=TomaParametro("ifh",trama->parametros); // Perfil hardware del ordenador
	1599	//char *widcentro=TomaParametro("idc",trama->parametros); // Identificador del Centro
	1600	//char *wtipopar=TomaParametro("tpa",trama->parametros); // Tipo de partición
	1601	char *wnemonico=TomaParametro("nem",trama->parametros); // Nemonico del S.O. contenido en la partición
	1602	//char *wswrestauraimg=TomaParametro("swr",trama->parametros); // Indica si la imagen a restaurar contiene un S.O. distinto al actual
[a6b881e]	1603	//char *widsoftincremental=TomaParametro("icr",trama->parametros); // Cadena con los identificadores de lsoftware incremental
[c77c7d2]	1604	char *wpathimagen=TomaParametro("pth",trama->parametros); // Indica si la imagen se descargar de la caché(cache) o del servidor(net)
	1605	if(wpathimagen=='\0') wpathimagen="1"; // Por defecto de caché
	1606
	1607	char disco=(char)ReservaMemoria(2);
	1608	sprintf(disco,"1"); // Siempre el disco 1
	1609
	1610	char compres=(char)ReservaMemoria(10);
	1611	sprintf(compres,"gzip"); // Método de compresión
	1612
	1613	char mettran=(char)ReservaMemoria(10);
[a6b881e]	1614	sprintf(mettran,"unicast"); // Método de transferencia por defecto
[c77c7d2]	1615
	1616	int idxpath=atoi(wpathimagen);
	1617	if(!CACHEEXISTS) idxpath=2; // Sin no existe cache siempre desde el servidor
	1618	//if(wswrestauraimg=="O")
	1619	// res=reparticiona((int)wparticion,wtipopar); // Reparticiona si la imagen va a una partición distinta a la original
	1620	if(res==0){
	1621	char pathperfil[250];
	1622	if(idxpath==2){
	1623	sprintf(pathperfil,"%s/%s",HIDRASRVIMAGENES,wnemonico);
	1624	}
	1625	else{
	1626	if(idxpath==1){
	1627	sprintf(pathperfil,"%s/%s",HIDRACHEIMAGENES,wnemonico);
	1628	}
	1629	}
	1630	char fileperfil[64];
	1631	sprintf(fileperfil,"PS%s_PH%s",widperfilsoft,widperfilhard); // Nombre del fichero del perfil creado
	1632	char filemasterboot[64];
	1633	sprintf(filemasterboot,"PS%s_PH%s.msb",widperfilsoft,widperfilhard); // Idem para el sector de arranque MBR
[09907c1]	1634	res=RestaurandoImagen(disco,compres,mettran,fileperfil,pathperfil,wparticion,Propiedades.iprepo);
[c77c7d2]	1635	// Toma la nueva configuración
	1636	char *parametroscfg=LeeConfiguracion(disco);
	1637	Log("Finalizada la restauracion de imagen");
	1638
	1639	int lon;
	1640	lon=sprintf(nwtrama->parametros,"nfn=RESPUESTA_RestaurarImagen\r");
	1641	lon+=sprintf(nwtrama->parametros+lon,"cfg=%s\r",parametroscfg);
	1642	lon+=sprintf(nwtrama->parametros+lon,"idi=%s\r",widimagen);
	1643	lon+=sprintf(nwtrama->parametros+lon,"par=%s\r",wparticion);
	1644	RespuestaEjecucionComando(trama,nwtrama,res);
[09907c1]	1645	return(res);
[c77c7d2]	1646	}
	1647	return(false);
	1648	}
	1649	//______________________________________________________________________________________________________
	1650	// Función: RestaurandoImagen
	1651	//
	1652	// Descripción:
	1653	// Restaura na imagen en una partición
	1654	// Parámetros:
	1655	// -disco Disco a clonar 1,2,3..
	1656	// -fileimg Nombre de la imagen
	1657	// -pathimg Ruta de la imagen
	1658	// -particion Partición a clonar
	1659	// -iprepo Dirección IP del repositorio ( Si es la IP local el repositorio será la caché)
	1660	// Devuelve:
	1661	// true si el proceso fue correcto o false en caso contrario
	1662	//____________________________________________________________________________________________________
	1663	int RestaurandoImagen(char* disco,char* compres,char* mettran,char* fileimg,char* pathimg,char* particion,char*iprepo)
	1664	{
	1665	int herror;
	1666
[b0bb14f]	1667	sprintf(cmdshell,"%s/admRestoreImage",HIDRASCRIPTS);
	1668	sprintf(parametros," %s %s %s %s %s","admRestoreImage","REPO",fileimg,disco,particion);
[1b66a79]	1669
[c77c7d2]	1670	if(ndebug>3){
[1b66a79]	1671	sprintf(msglog,"Restaurando Imagen disco:%s, partición:%s, Repositorio:%s, Imagen:%s",disco,particion,Propiedades.iprepo,fileimg);
[c77c7d2]	1672	Log(msglog);
	1673	}
	1674
	1675	herror=EjecutarScript(cmdshell,parametros,NULL,true);
	1676	if(herror){
[a6b881e]	1677	UltimoErrorScript(herror,"RestaurandoImagen()"); // Se ha producido algún error
[c77c7d2]	1678	return(false);
	1679	}
	1680	else
	1681	return(true);
	1682	}
	1683
	1684	//______________________________________________________________________________________________________
	1685	// Función: ParticionaryFormatear
	1686	//
	1687	// Descripción:
	1688	// Modifica la tabla de particiones del sector de arranque master y formatea particiones
	1689	// Parámetros:
	1690	// - trama: Trama recibida con las especificaciones del comando
	1691	// - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
	1692	// Devuelve:
	1693	// true si el proceso fue correcto o false en caso contrario
	1694	//____________________________________________________________________________________________________
	1695	int ParticionaryFormatear(TRAMAtrama,TRAMAnwtrama)
	1696	{
	1697	int res,i,parfor;
	1698	char* parametroscfg;
	1699	char ch[2],*parhdc[8];
	1700	char *PrimaryPartitions=TomaParametro("ppa",trama->parametros);
	1701	char *LogicalPartitions=TomaParametro("lpa",trama->parametros);
	1702	char *HDCleanPartition=TomaParametro("hdc",trama->parametros);
	1703
	1704	char disco=(char)ReservaMemoria(2);
	1705	sprintf(disco,"1"); // Siempre el disco 1
	1706
	1707	Log("Creando o modificando tabla de particiones");
	1708	res=Particionar(disco,PrimaryPartitions,LogicalPartitions); // Creando las particiones
	1709	if(res){
	1710	strcpy(ch,";"); // Caracter delimitador
	1711	parfor=SplitParametros(parhdc,HDCleanPartition,ch);
	1712	for(i = 0; i<parfor; i++){ // Formateando particiones
	1713	res=Formatear(disco,parhdc[i]);
	1714	if(!res) break;
	1715	}
	1716	}
	1717	Log("Finalizado el particionado y formateado de particiones");
	1718	parametroscfg=LeeConfiguracion(disco); // Toma la nueva configuración
	1719
	1720	int lon;
	1721	lon=sprintf(nwtrama->parametros,"nfn=RESPUESTA_ParticionaryFormatear\r");
	1722	lon+=sprintf(nwtrama->parametros+lon,"cfg=%s\r",parametroscfg);
	1723	RespuestaEjecucionComando(trama,nwtrama,res);
	1724
	1725	return(res);
	1726	}
	1727	//______________________________________________________________________________________________________
	1728	// Función: Particionar
	1729	//
	1730	// Descripción:
	1731	// Modifica la tabla de particiones del sector de arranque master pero SIN formatear ninguna partición
	1732	// Parámetros:
	1733	// - PrParticion: Cadena con la sintaxis de particionado de las particiones primarias
	1734	// - LoParticion: Cadena con la sintaxis de particionado de las particiones secundarias
	1735	// Devuelve:
	1736	// true si el proceso fue correcto o false en caso contrario
	1737	//______________________________________________________________________________________________________
	1738	int Particionar(char* disco,char* PrParticion,char* LoParticion)
	1739	{
	1740	if (strlen(PrParticion)>0){
[b0bb14f]	1741	if(Particionando(disco,PrParticion,"admCreatePrimaryPartitions")){ // Particiones Primarias
[c77c7d2]	1742	if (strlen(LoParticion)>0)
[b0bb14f]	1743	return(Particionando(disco,PrParticion,"admCreateLogicalPartitions")); // Particiones Logicas
[c77c7d2]	1744	else
	1745	return(true);
	1746	}
	1747	else
	1748	return(false);
	1749	}
	1750	if (strlen(LoParticion)>0)
[b0bb14f]	1751	return(Particionando(disco,PrParticion,"admCreateLogicalPartitions"));
[c77c7d2]	1752	else
	1753	return(false);
	1754	}
	1755	//______________________________________________________________________________________________________
	1756	// Función: Particionando
	1757	//
	1758	// Descripción:
	1759	// Modifica la tabla de particiones del sector de arranque master pero SIN formatear ninguna partición
	1760	// Parámetros:
	1761	// - disco: Disco en el que se modificará la tabla de particiones 1,2,3..
	1762	// - SintaxParticion: Cadena con la sintaxis de particionado de las particiones primarias
	1763	// - script: Nombre del script que se ejecutará
	1764	// Devuelve:
	1765	// true si el proceso fue correcto o false en caso contrario
	1766	// Especificaciones:
	1767	// Esta función es auxiliar de la anterior y es llamda por esta en dos ocasiones, para las particiones Primarias y Lógicas
	1768	//______________________________________________________________________________________________________
	1769	int Particionando(char* disco,char* stxParticion,char* script)
	1770	{
	1771	int herror;
	1772
	1773	sprintf(cmdshell,"%s/%s",HIDRASCRIPTS,script);
	1774	sprintf(parametros," %s %s %s",script,disco,stxParticion);
	1775	if(ndebug>1){
	1776	sprintf(msglog,"Modificando tabla de particiones:%s disco:%s, cadena:%s",script,disco,stxParticion);
	1777	Log(msglog);
	1778	}
	1779	herror=EjecutarScript(cmdshell,parametros,NULL,true);
	1780	if(herror){
[a6b881e]	1781	UltimoErrorScript(herror,"Particionar()"); // Se ha producido algún error
[c77c7d2]	1782	return(false);
	1783	}
	1784	else
	1785	return(true);
	1786	}
	1787	//______________________________________________________________________________________________________
	1788	// Función: Formatear
	1789	//
	1790	// Descripción:
	1791	// Formatea una partición
	1792	// Parámetros:
	1793	// - disco: Número del disco
	1794	// - particion: Número de partición a formatear
	1795	// Devuelve:
	1796	// true si el proceso fue correcto o false en caso contrario
	1797	//______________________________________________________________________________________________________
	1798	int Formatear(char* disco,char* particion)
	1799	{
	1800	int herror;
	1801
[b0bb14f]	1802	sprintf(cmdshell,"%s/admFormatFs",HIDRASCRIPTS);
[044cd96]	1803	sprintf(parametros," %s %s %s","FormatFs",disco,particion);
[c77c7d2]	1804	herror=EjecutarScript(cmdshell,parametros,NULL,true);
	1805	if(herror){
[a6b881e]	1806	UltimoErrorScript(herror,"Formatear()"); // Se ha producido algún error
[c77c7d2]	1807	return(false);
	1808	}
	1809	return(true);
	1810	}
	1811	//______________________________________________________________________________________________________
	1812	// Función: SetCachePartitionSize
	1813	//
	1814	// Descripción:
	1815	// Dimensiona el tamaño de la caché
	1816	// Parámetros:
	1817	// - t : Tamaño a asignar de la caché
	1818	// Devuelve:
	1819	// true si el proceso fue correcto o false en caso contrario
	1820	// ________________________________________________________________________________________________________
	1821	int SetCachePartitionSize(int t)
	1822	{
	1823	return(true);
	1824	}
	1825	//___________________________________________________________________________________________________
	1826	//
	1827	//
	1828	//______________________________________________________________________________________________________
	1829	// Función: AutoClienteHidra
	1830	//
	1831	// Descripción:
	1832	// Ejecuta un fichero autoexec preparado para el cliente
	1833	// ________________________________________________________________________________________________________
	1834	int AutoexecClienteHidra()
	1835	{
[d6dfe7c]	1836	sprintf(fileini,"/autoexec/INI_%s",Propiedades.IPlocal); // Nombre del fichero autoexec
[c77c7d2]	1837	if(ExisteFichero(fileini)){
	1838	if(LoadTextFile(fileini)){ // Lee fichero autoexec
	1839	GestionTramas(trama); // Analiza la trama
	1840	}
	1841	else{
	1842	UltimoError(6,"AutoexecClienteHidra()");
	1843	return(false);
	1844	}
	1845	}
	1846	return(true);
	1847	}
	1848	//______________________________________________________________________________________________________
	1849	// Función: LeeConfiguracion
	1850	//
	1851	// Descripción:
	1852	// Recupera la configuración de particiones del ordenador
	1853	// Parámetros:
	1854	// disco: Disco a analizar 1,2,3..
	1855	// Devuelve:
	1856	// Una cadena con la configuración del cliente (ver manual)
	1857	// ________________________________________________________________________________________________________
	1858	char* LeeConfiguracion(char* disco)
	1859	{
	1860	int herror;
	1861	char *cadenaparticiones;
	1862	char *nomso;
	1863
	1864	cadenaparticiones=(char*)ReservaMemoria(LONGITUD_SCRIPTSALIDA);
[b0bb14f]	1865	sprintf(cmdshell,"%s/admListPrimaryPartitions",HIDRASCRIPTS);
	1866	sprintf(parametros," %s %s","admListPrimaryPartitions",disco);
[c77c7d2]	1867	herror=EjecutarScript(cmdshell,parametros,cadenaparticiones,true);
	1868	if(herror){
[a6b881e]	1869	UltimoErrorScript(herror,"LeeConfiguracion()"); // Se ha producido algún error
[c77c7d2]	1870	return(NULL);
	1871	}
	1872	struct s_Particiones *tbcfg[MAXPARTICIONES];
	1873	char duplasparticiones[MAXPARTICIONES],duplaparticion[2];
	1874
	1875	int iPar=SplitParametros(duplasparticiones,cadenaparticiones," "); // Caracter separatorio de los elementos de un item
	1876	int i,j;
	1877	for( i = 0; i<iPar; i++){
	1878	SplitParametros(duplaparticion,duplasparticiones[i],":");
	1879	tbcfg[i]=(struct s_Particiones*)ReservaMemoria(sizeof(struct s_Particiones)); // Toma espacio para tabla de configuraciones
	1880	strcpy(tbcfg[i]->tipopart,duplaparticion[0]); // Tipo de partición
	1881	strcpy(tbcfg[i]->tamapart,duplaparticion[1]); // Tamaño de partición
	1882	sprintf(tbcfg[i]->numpart,"%d",i+1); // Número de partición
	1883
	1884	for(j=0;j<ntiposo;j++){
[09907c1]	1885	if(strcmp(tiposos[j].tipopart,duplaparticion[0])==0 && strcmp(tiposos[j].tipopart,"LINUX-SWAP")!=0 && strcmp(tiposos[j].tipopart,"EMPTY")!=0){
[c77c7d2]	1886	nomso=TomaNomSO(disco,i+1);
	1887	if(nomso!=NULL){ // Averigua qué sistema operativo está instalado en la partición
	1888	strcpy(tbcfg[i]->tiposo,tiposos[j].tiposo); // Nombre S.O.
	1889	strcpy(tbcfg[i]->nombreso,nomso); // Nombre completo S.O.
	1890	}
	1891	else{
	1892	strcpy(tbcfg[i]->tiposo,""); // Nombre S.O.
	1893	strcpy(tbcfg[i]->nombreso,""); // Nombre completo S.O.
	1894	}
	1895	break;
	1896	}
	1897	}
	1898	}
	1899	char *cfg=ReservaMemoria(LONGITUD_CONFIGURACION);
	1900	if(!cfg){
	1901	UltimoError(1,"LeeConfiguracion()");
	1902	return(NULL);
	1903	}
	1904	int lon=0;
	1905	for( i = 0; i<iPar; i++){
	1906	lon+=sprintf(cfg+lon,"@cfg\n");
	1907	lon+=sprintf(cfg+lon,"tiposo=%s\n",tbcfg[i]->tiposo);
	1908	lon+=sprintf(cfg+lon,"tipopart=%s\n",tbcfg[i]->tipopart);
	1909	lon+=sprintf(cfg+lon,"tamapart=%s\n",tbcfg[i]->tamapart);
	1910	lon+=sprintf(cfg+lon,"numpart=%s\n",tbcfg[i]->numpart);
	1911	lon+=sprintf(cfg+lon,"nombreso=%s\t",tbcfg[i]->nombreso);
	1912	}
	1913	return(cfg);
	1914	}
	1915	//______________________________________________________________________________________________________
	1916	// Función: TomaNomSO
	1917	//
	1918	// Descripción:
	1919	// Recupera el nombre del sistema operativo instalado en una partición
	1920	// Parámetros:
	1921	// disco: Disco 1,2,3..
	1922	// particion: Número de la partición
	1923	// Devuelve:
	1924	// Una cadena con el nombre del S.O.
	1925	// ________________________________________________________________________________________________________
	1926	char* TomaNomSO(char*disco,int particion)
	1927	{
	1928	int herror,lon;
	1929	char *infosopar;
	1930	char* sover[2];
	1931	char ch[2];
	1932
	1933	infosopar=(char*)ReservaMemoria(LONGITUD_SCRIPTSALIDA); // Información del S.O. de la partición
	1934
[b0bb14f]	1935	sprintf(cmdshell,"%s/admGetOsVersion",HIDRASCRIPTS);
	1936	sprintf(parametros," %s %s %d","admGetOsVersion",disco,particion);
[c77c7d2]	1937	herror=EjecutarScript(cmdshell,parametros,infosopar,true);
[a6b881e]	1938	if(herror){
	1939	UltimoErrorScript(herror,"TomaNomSO()"); // Se ha producido algún error
[c77c7d2]	1940	return(NULL);
	1941	}
	1942	if(strlen(infosopar)==0) return(NULL); // NO Existe S.O. en la partición
	1943	strcpy(ch,":");// caracter delimitador (dos puntos)
	1944	lon=SplitParametros(sover,infosopar,ch);
	1945	return(sover[1]);
	1946	}
	1947	//______________________________________________________________________________________________________
[fa2ba4f2]	1948	// Función: MuestraMenu
	1949	//
	1950	// Descripción:
	1951	// Muestra menú del cliente
	1952	// Parámetros:
	1953	// ips: Dirección IP del servidor web que implementa la consola de adminsitración
	1954	// urp: Path o url de la página web que muestra el menu del cliente
	1955	// iph: Dirección ip del cliente
	1956	// Devuelve:
	1957	// Nada
	1958	// ________________________________________________________________________________________________________
[b0bb14f]	1959	int MuestraMenu(char *urp)
[fa2ba4f2]	1960	{
	1961	int herror,nargs,resul;
	1962
[b0bb14f]	1963	sprintf(cmdshell,"%s/admMenuBrowser",HIDRASCRIPTS);
	1964	sprintf(parametros,"%s %s","admMenuBrowser",urp);
[fa2ba4f2]	1965	nargs=SplitParametros(argumentos,parametros," "); // Crea matriz de los argumentos del scripts
[b0bb14f]	1966	if((pidmenu=fork())==0){
[fa2ba4f2]	1967	/* Proceso hijo que ejecuta el script */
	1968	execv(cmdshell,argumentos);
	1969	exit(resul);
	1970	}
	1971	else {
[b0bb14f]	1972	if (pidmenu ==-1){
[fa2ba4f2]	1973	UltimoErrorScript(herror,"MuestraMenu()"); // Se ha producido algún error
	1974	return(false);
	1975	}
	1976	}
	1977	return(true);
	1978	}
	1979	//______________________________________________________________________________________________________
[c77c7d2]	1980	// Función: InventarioHardware
	1981	//
	1982	// Descripción:
	1983	// Recupera la configuración de hardware del ordenador
	1984	// Parámetros:
	1985	// - trama: Trama recibida con las especificaciones del comando
	1986	// - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
	1987	// Devuelve:
	1988	// true si el proceso fue correcto o false en caso contrario
	1989	// Especificaciones:
	1990	// Lo que se envía al servidor es una cadena con el formato de salida del script que ejecuta
	1991	// está función. (Vease scripts hidraHardwareInfo)
	1992	// ________________________________________________________________________________________________________
	1993	int InventarioHardware(TRAMA trama,TRAMA nwtrama)
	1994	{
	1995	int herror,res;
	1996	char *parametroshrd;
	1997
[b0bb14f]	1998	parametroshrd=(char*)ReservaMemoria(LONGITUD_SCRIPTSALIDA);
	1999	sprintf(cmdshell,"%s/admListHardwareInfo",HIDRASCRIPTS);
	2000	herror=EjecutarScript(cmdshell,NULL,parametroshrd,true);
[c77c7d2]	2001	if(herror){
[a6b881e]	2002	UltimoErrorScript(herror,"InventarioHardware()"); // Se ha producido algún error
[c77c7d2]	2003	}
	2004	res=(herror==0); // Si se ha producido algún error el resultado de la ejecución de error
	2005
	2006	int lon;
	2007	lon=sprintf(nwtrama->parametros,"nfn=RESPUESTA_TomaHardware\r");
	2008	lon+=sprintf(nwtrama->parametros+lon,"hrd=%s\r",parametroshrd);
	2009	RespuestaEjecucionComando(trama,nwtrama,res);
[5eae07e]	2010	return(res);
	2011	}
	2012	//______________________________________________________________________________________________________
	2013	// Función: InventarioSoftware
	2014	//
	2015	// Descripción:
	2016	// Recupera la configuración de software del ordenador
	2017	// Parámetros:
	2018	// - trama: Trama recibida con las especificaciones del comando
	2019	// - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
	2020	// Devuelve:
	2021	// true si el proceso fue correcto o false en caso contrario
	2022	// Especificaciones:
	2023	// Lo que se envía al servidor es una cadena con el formato de salida del script que ejecuta
	2024	// está función. (Vease scripts hidraSoftwareInfo)
	2025	// ________________________________________________________________________________________________________
	2026	int InventarioSoftware(TRAMA trama,TRAMA nwtrama)
	2027	{
	2028	int herror,res;
[09907c1]	2029	char parametrossft,infopar;
[5eae07e]	2030	char *particion=TomaParametro("par",trama->parametros); // Toma partición
[b0bb14f]	2031	//char *tipo=TomaParametro("tpl",trama->parametros); // Toma tipo de listado
[5eae07e]	2032
	2033	char disco=(char)ReservaMemoria(2);
	2034	sprintf(disco,"1"); // Siempre el disco 1
	2035
[b0bb14f]	2036	sprintf(cmdshell,"%s/admListSoftwareInfo",HIDRASCRIPTS);
	2037	sprintf(parametros,"%s %s %s","admListSoftwareInfo",disco,particion);
[5eae07e]	2038
[b0bb14f]	2039	parametrossft=(char*)ReservaMemoria(LONGITUD_SCRIPTSALIDA);
	2040	herror=EjecutarScript(cmdshell,parametros,parametrossft,true);
[5eae07e]	2041	if(herror){
	2042	UltimoErrorScript(herror,"InventarioSoftware()"); // Se ha producido algún error
	2043	}
	2044	res=(herror==0); // Si se ha producido algún error el resultado de la ejecución de error
[09907c1]	2045	// Toma tipo de partición
	2046	infopar=(char*)ReservaMemoria(16); //Tipo de partición
	2047	if(res && infopar){
[b0bb14f]	2048	sprintf(cmdshell,"%s/admGetFsType",HIDRASCRIPTS);
[044cd96]	2049	sprintf(parametros," %s %s %s","getFsType",disco,particion);
[09907c1]	2050	herror=EjecutarScript(cmdshell,parametros,infopar,true);
	2051	if(herror){
[ecdc8ec]	2052	UltimoErrorScript(herror,"InventarioSoftware()"); // Se ha producido algún error
	2053	}
[09907c1]	2054	}
	2055	int lon;
[5eae07e]	2056	lon=sprintf(nwtrama->parametros,"nfn=RESPUESTA_TomaSoftware\r");
	2057	lon+=sprintf(nwtrama->parametros+lon,"sft=%s\r",parametrossft);
[536adc4]	2058	lon+=sprintf(nwtrama->parametros+lon,"par=%s\r",particion);
[09907c1]	2059	lon+=sprintf(nwtrama->parametros+lon,"tfs=%s\r",infopar);
[5eae07e]	2060	RespuestaEjecucionComando(trama,nwtrama,res);
[c77c7d2]	2061	return(res);
	2062	}
	2063	//______________________________________________________________________________________________________
	2064	// Función: TomaConfiguracion
	2065	//
	2066	// Descripción:
	2067	// Toma la configuración de particiones de un ordenador
	2068	// Parámetros:
	2069	// - trama: Trama recibida con las especificaciones del comando
	2070	// - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
	2071	// Devuelve:
	2072	// true si el proceso fue correcto o false en caso contrario
	2073	// ________________________________________________________________________________________________________
	2074	int TomaConfiguracion(TRAMA trama,TRAMA nwtrama)
	2075	{
	2076	char* parametroscfg;
	2077
	2078	char disco=(char)ReservaMemoria(2);
	2079	sprintf(disco,"1"); // Siempre el disco 1
	2080
	2081	parametroscfg=LeeConfiguracion(disco);
	2082
	2083	int lon;
	2084	lon=sprintf(nwtrama->parametros,"nfn=RESPUESTA_TomaConfiguracion\r");
	2085	lon+=sprintf(nwtrama->parametros+lon,"cfg=%s\r",parametroscfg);
	2086	RespuestaEjecucionComando(trama,nwtrama,true);
	2087
	2088	return(true);
	2089	}
	2090	//______________________________________________________________________________________________________
	2091	// Función: ExecShell
	2092	//
	2093	// Descripción:
	2094	// Ejecuta un script de la Shell
	2095	// Parámetros:
	2096	// - trama: Trama recibida con las especificaciones del comando
	2097	// - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
	2098	// Devuelve:
	2099	// true si el proceso fue correcto o false en caso contrario
	2100	// ________________________________________________________________________________________________________
	2101	int ExecShell(TRAMA trama,TRAMA nwtrama)
	2102	{
[b0bb14f]	2103	int res;
[c77c7d2]	2104
	2105	char* wscript=TomaParametro("scp",trama->parametros); // Código del script
	2106	char* codigo=URLDecode(wscript); // Decodifica el código recibido con formato URLCode
	2107
[b0bb14f]	2108	res=ExecBash(codigo);
	2109	if(!res){
	2110	UltimoErrorScript(10,"ExecShell()"); // Se ha producido algún error
	2111	}
	2112
	2113	char disco=(char)ReservaMemoria(2);
	2114	sprintf(disco,"1"); // Siempre el disco 1
	2115	char* parametroscfg=LeeConfiguracion(disco);
	2116	int lon;
	2117	lon=sprintf(nwtrama->parametros,"nfn=RESPUESTA_ExecShell\r");
	2118	lon+=sprintf(nwtrama->parametros+lon,"cfg=%s\r",parametroscfg);
	2119	RespuestaEjecucionComando(trama,nwtrama,res);
	2120	return(true);
	2121	}
	2122	//______________________________________________________________________________________________________
	2123	// Función: ExecBash
	2124	//
	2125	// Descripción:
	2126	// Ejecuta código bash
	2127	// Parámetros:
	2128	// - codigo: Código a ejecutar
	2129	// Devuelve:
	2130	// true si el proceso fue correcto o false en caso contrario
	2131	// ________________________________________________________________________________________________________
	2132	int ExecBash(char*codigo){
	2133	FILE* f;
	2134	long lSize;
	2135	int herror,res;
	2136
[635f7e1]	2137	sprintf(filecmdshell,"%s/%s","/tmp","_hidrascript_");
[c77c7d2]	2138	f = fopen(filecmdshell,"wt"); // Abre fichero de script
	2139	if(f==NULL)
	2140	res=false; // Error de apertura del fichero de configuración
	2141	else{
	2142	lSize=strlen(codigo);
	2143	fwrite(codigo,1,lSize,f); // Escribe el código a ejecutar
	2144	fclose(f);
	2145	sprintf(cmdshell,"/bin/chmod"); // Da permiso de ejecución al fichero
	2146	sprintf(parametros," %s %s %s","/bin/chmod","+x",filecmdshell);
	2147
	2148	herror=EjecutarScript(cmdshell,parametros,NULL,true);
	2149	if(herror){
[b0bb14f]	2150	UltimoErrorScript(herror,"ExecBash()"); // Se ha producido algún error
[c77c7d2]	2151	res=false;
	2152	}
	2153	else{
	2154	sprintf(cmdshell,"%s",filecmdshell); // Ejecución el fichero de script creado
	2155	//int herror=EjecutarScript(cmdshell,NULL,NULL,true);
	2156	int herror=system(cmdshell);
	2157	if(herror){
[b0bb14f]	2158	UltimoErrorScript(herror,"ExecBash()"); // Se ha producido algún error
[c77c7d2]	2159	res=false;
	2160	}
	2161	}
	2162	}
	2163	return(res);
	2164	}
	2165	//______________________________________________________________________________________________________
	2166	// Función: URLDecode
	2167	//
	2168	// Descripción:
	2169	// Decodifica una cadena codificada con UrlEncode
	2170	// Parámetros:
	2171	// - src: La cadena a decodificar
	2172	// Devuelve:
	2173	// La cadena decodificada
	2174	// ________________________________________________________________________________________________________
	2175	char* URLDecode(char *src)
	2176	{
	2177	const char *p = src;
	2178	char code[3] = {0};
	2179	unsigned long ascii = 0;
	2180	char *end = NULL;
	2181	char dest,cad;
	2182
	2183	dest=(char*)ReservaMemoria(strlen(src)); // Reserva buffer para la cadena
	2184	cad=dest;
	2185	while(*p){
	2186	if(*p == '%'){
	2187	memcpy(code, ++p, 2);
	2188	ascii = strtoul(code, &end, 16);
	2189	*dest++ = (char)ascii;
	2190	p += 2;
	2191	}
	2192	else
	2193	dest++ = p++;
	2194	}
	2195	return(cad);
	2196	}
	2197	//______________________________________________________________________________________________________
	2198	// Función: RespuestaEjecucionComando
	2199	//
	2200	// Descripción:
[a6b881e]	2201	// Envia una respuesta a una ejecucion de comando al servidor de Administración
[c77c7d2]	2202	// Parámetros:
	2203	// - trama: Trama recibida con las especificaciones del comando
	2204	// - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
	2205	// - res: Resultado de la ejecución (true si la ejecución es correcta y false en caso contrario)
	2206	// Devuelve:
	2207	// true si la respuesta se envía correctamente al servidor
	2208	// ________________________________________________________________________________________________________
	2209	int RespuestaEjecucionComando(TRAMA* trama, TRAMA *nwtrama, int res)
	2210	{
	2211	int idsuceso=0;
	2212	char *widsuceso=TomaParametro("ids",trama->parametros);
	2213	if(widsuceso) idsuceso=atoi(widsuceso);
	2214	int lon;
	2215	lon=strlen(nwtrama->parametros);
	2216	lon+=sprintf(nwtrama->parametros+lon,"ids=%d\r",idsuceso); // Identificador del suceso
	2217	char descrierror[250];
	2218	if (res){ // Resultado satisfactorio
	2219	lon+=sprintf(nwtrama->parametros+lon,"res=%s\r","1"); // Resultado de la ejecucin del comando
	2220	sprintf(descrierror,"%s "," ");
	2221	lon+=sprintf(nwtrama->parametros+lon,"der=%s\r",descrierror); // Dscripcin del error si lo ha habido
	2222	}
	2223	else{ // Algún error
[a6b881e]	2224	lon+=sprintf(nwtrama->parametros+lon,"res=%s\r","2"); // Resultado de la ejecución del comando
[c77c7d2]	2225	sprintf(descrierror,"Error.-(%s) en modulo %s",e.msg,e.modulo);
	2226	lon+=sprintf(nwtrama->parametros+lon,"der=%s\r",descrierror); // Descripción del error si lo ha habido
	2227	}
	2228	if(AbreConexionTCP()){
	2229	if(!EnviaTramasHidra(sock,nwtrama)){
	2230	UltimoError(21,"RespuestaEjecucionComando()");
	2231	return(false);
	2232	}
	2233	if(!RecibeTramasHidra(sock,trama)){
	2234	UltimoError(22,"RespuestaEjecucionComando()");
	2235	return(false);
	2236	}
	2237	CierraConexionTCP();
	2238	GestionTramas(trama); // Analiza la trama
	2239	}
	2240	else{
	2241	UltimoError(2,"RespuestaEjecucionComando()");
	2242	return(false);
	2243	}
	2244	return(true);
	2245	}
[b0bb14f]	2246	//______________________________________________________________________________________________________
	2247	// Función: MuestraMensaje
	2248	//
	2249	// Descripción:
	2250	// Envia una página al browser con un mensaje determinado
	2251	// Parámetros:
	2252	// - idx: Indice de la cadena del mensaje
	2253	// ________________________________________________________________________________________________________
	2254	void MuestraMensaje(int idx){
	2255	sprintf(urlpag,"%s?msg=%d",URLMSG,idx); // Url de la página de mensajes
	2256	MuestraMenu(urlpag);
	2257	}
[c77c7d2]	2258	//***********************************************************************************************************************
	2259	// PROGRAMA PRINCIPAL
	2260	//***********************************************************************************************************************
	2261	int main(int argc, char *argv[])
	2262	{
[a6b881e]	2263	//Archivos por defecto
	2264	strcpy(szPathFileCfg,"ogAdmClient.cfg");
[d6dfe7c]	2265	strcpy(szPathFileLog,"ogAdmClient.log");
[a6b881e]	2266
[c77c7d2]	2267	// Validación de argumentos y lectura del fichero de configuración
	2268	if(!ValidacionParametros(argc,argv))
	2269	exit(EXIT_FAILURE);
	2270	else{
	2271	if(!CrearArchivoLog(szPathFileLog))
	2272	exit(EXIT_FAILURE);
	2273	else
	2274	if(!LeeFileConfiguracion(szPathFileCfg)){ // Toma parámetros de configuracion
	2275	UltimoError(13,"Main()");
	2276	exit(EXIT_FAILURE);
	2277	}
	2278	}
	2279	// Guarda datos básicos del cliente
	2280	strcpy(Propiedades.servidorhidra,Servidorhidra);
	2281	strcpy(Propiedades.puerto,Puerto);
	2282	strcpy(Propiedades.idordenador,"0");
	2283	if(!TomaIPlocal()){ // Error al recuperar la IP local
	2284	UltimoError(0,"Main()");
	2285	exit(EXIT_FAILURE);
	2286	}
	2287	strcpy(Propiedades.IPlocal,IPlocal);
	2288
[a6b881e]	2289	Log("Abriendo sesión en el servidor de Administración");
	2290	if(InclusionCliente()){ // El cliente ha abierto sesión correctamente
[c77c7d2]	2291	if(strcmp(Propiedades.idordenador,"0")==0){ // Ha habido algún problema al inciar sesión
	2292	UltimoError(0,"Main()");
	2293	exit(EXIT_FAILURE);
	2294	}
[a6b881e]	2295	Log("Cliente iniciado");
	2296	Log("Ejecución de archivo Autoexec");
[c77c7d2]	2297	if(!AutoexecClienteHidra()){ // Ejecución fichero autoexec
	2298	UltimoError(0,"Main()");
	2299	exit(EXIT_FAILURE);
	2300	}
	2301	Log("Procesa comandos pendientes");
	2302	ComandosPendientes(); // Bucle para procesar comandos pendientes
	2303	Log("Acciones pendientes procesadas");
[d1abd62]	2304	MuestraMenu(URLMENU);
[c77c7d2]	2305	Log("Disponibilidad para comandos interactivos activada ...");
	2306	ProcesaComandos(); // Bucle para procesar comando s interactivos
[fa2ba4f2]	2307	Log("Disponibilidad para comandos interactivos desactivada...");
[c77c7d2]	2308	}
	2309	else{
	2310	UltimoError(0,"Main()");
	2311	exit(EXIT_FAILURE);
	2312	}
	2313	exit(0);
	2314	}
	2315
	2316
	2317
	2318

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

Context Navigation

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

Download in other formats: