Context Navigation

ogAdmClient.c @ 383edce

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 383edce was f6b42f2, checked in by alonso <alonso@…>, 16 years ago

primeros archivos de administración

git-svn-id: https://opengnsys.es/svn/trunk@458 a21b9725-9963-47de-94b9-378ad31fedc9

Property mode set to 100644

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

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

Context Navigation

source: admin/Sources/ogAdmClient/sources/ogAdmClient.c @ 383edce

Download in other formats: