Context Navigation

ogAdmClient.c @ 91a3b4c

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 91a3b4c was b2651a6, checked in by ramon <ramongomez@…>, 12 years ago

#601: Integrar código del ticket:601 en rama de desarrollo.

git-svn-id: https://opengnsys.es/svn/branches/version1.0@3807 a21b9725-9963-47de-94b9-378ad31fedc9

Property mode set to 100644

File size: 73.6 KB

Rev	Line
[3ec149c]	1	// ********************************************************************************************************
	2	// Cliernte: ogAdmClient
	3	// Autor: José Manuel Alonso (E.T.S.I.I.) Universidad de Sevilla
	4	// Fecha Creación: Marzo-2010
	5	// Fecha Última modificación: Abril-2010
	6	// Nombre del fichero: ogAdmClient.c
	7	// Descripción :Este fichero implementa el cliente general del sistema
	8	// ********************************************************************************************************
	9	#include "ogAdmClient.h"
	10	#include "ogAdmLib.c"
	11	//________________________________________________________________________________________________________
	12	// Función: tomaConfiguracion
	13	//
	14	// Descripción:
	15	// Lee el fichero de configuración del servicio
	16	// Parámetros:
	17	// filecfg : Ruta completa al fichero de configuración
	18	// Devuelve:
	19	// TRUE: Si el proceso es correcto
	20	// FALSE: En caso de ocurrir algún error
	21	//________________________________________________________________________________________________________
	22	BOOLEAN tomaConfiguracion(char* filecfg)
	23	{
	24	char modulo[] = "tomaConfiguracion()";
	25
	26	if (filecfg == NULL \|\| strlen(filecfg) == 0) {
	27	errorLog(modulo, 1, FALSE); // Fichero de configuración del cliente vacío
	28	return (FALSE);
	29	}
	30	FILE *fcfg;
	31	int lSize;
	32	char * buffer, lineas[MAXPRM], dualparametro[2];
	33	int i, numlin, resul;
	34
	35	fcfg = fopen(filecfg, "rt");
	36	if (fcfg == NULL) {
	37	errorLog(modulo, 2, FALSE); // No existe fichero de configuración del cliente
	38	return (FALSE);
	39	}
	40
	41	fseek(fcfg, 0, SEEK_END);
	42	lSize = ftell(fcfg); // Obtiene tamaño del fichero.
	43	rewind(fcfg);
	44	buffer = (char*) reservaMemoria(lSize+1); // Toma memoria para el buffer de lectura.
	45	if (buffer == NULL) { // No hay memoria suficiente para el buffer
	46	errorLog(modulo, 3, FALSE);
	47	return (FALSE);
	48	}
	49	lSize=fread(buffer, 1, lSize, fcfg); // Lee contenido del fichero
	50	buffer[lSize]=CHARNULL;
	51	fclose(fcfg);
	52
	53	/* Inicializar variables globales */
	54	servidoradm[0]=CHARNULL;
	55	puerto[0] = CHARNULL;
	56	pathinterface[0]=CHARNULL;
	57	urlmenu[0]=CHARNULL;
	58	urlmsg[0]=CHARNULL;
	59
	60	numlin = splitCadena(lineas, buffer, '\n');
	61	for (i = 0; i < numlin; i++) {
	62	splitCadena(dualparametro, lineas[i], '=');
	63
	64	resul = strcmp(StrToUpper(dualparametro[0]), "SERVIDORADM");
	65	if (resul == 0)
	66	strcpy(servidoradm, dualparametro[1]);
	67
	68	resul = strcmp(StrToUpper(dualparametro[0]), "PUERTO");
	69	if (resul == 0)
	70	strcpy(puerto, dualparametro[1]);
	71
	72	resul = strcmp(StrToUpper(dualparametro[0]), "PATHINTERFACE");
	73	if (resul == 0)
	74	strcpy(pathinterface, dualparametro[1]);
	75
	76	resul = strcmp(StrToUpper(dualparametro[0]), "URLMENU");
	77	if (resul == 0)
	78	strcpy(urlmenu, dualparametro[1]);
	79
	80	resul = strcmp(StrToUpper(dualparametro[0]), "URLMSG");
	81	if (resul == 0)
	82	strcpy(urlmsg, dualparametro[1]);
	83	}
	84
	85	if (servidoradm[0] == CHARNULL) {
[4329e85]	86	liberaMemoria(buffer);
[3ec149c]	87	errorLog(modulo,4, FALSE); // Falta parámetro SERVIDORADM
	88	return (FALSE);
	89	}
	90
	91	if (puerto[0] == CHARNULL) {
[4329e85]	92	liberaMemoria(buffer);
[3ec149c]	93	errorLog(modulo,5, FALSE); // Falta parámetro PUERTO
	94	return (FALSE);
	95	}
	96	if (pathinterface[0] == CHARNULL) {
[4329e85]	97	liberaMemoria(buffer);
[3ec149c]	98	errorLog(modulo,56, FALSE); // Falta parámetro PATHINTERFACE
	99	return (FALSE);
	100	}
	101
	102	if (urlmenu[0] == CHARNULL) {
[4329e85]	103	liberaMemoria(buffer);
[3ec149c]	104	errorLog(modulo,89, FALSE); // Falta parámetro URLMENU
	105	return (FALSE);
	106	}
	107	if (urlmsg[0] == CHARNULL) {
[4329e85]	108	liberaMemoria(buffer);
[3ec149c]	109	errorLog(modulo,90, FALSE); // Falta parámetro URLMSG
	110	return (FALSE);
	111	}
[4329e85]	112	liberaMemoria(buffer);
[3ec149c]	113	return (TRUE);
	114	}
	115	//______________________________________________________________________________________________________
	116	// Función: FinterfaceAdmin
	117	//
	118	// Descripción:
	119	// Esta función es la puerta de comunicación entre el módulo de administración y el motor de clonación.
	120	// La Aplicación de administración utiliza una interface para ejecutar funciones del motor de clonación;
	121	// esta interface llamará a la API del motor con lo que cambiando el comportamiento de esta interface
	122	// podremos hacer llamadas a otras API de clonación y de esta manera probar distintos motores.
	123	//
	124	// Parámetros:
	125	// - script: Nombre del módulo,función o script de la interface
	126	// - parametros: Parámetros que se le pasarán a la interface
	127	// - salida: Recoge la salida que genera la llamada a la interface
	128
	129	// Devuelve:
	130	// Código de error de la ejecución al módulo , función o script de la interface
	131	//
	132	// Especificaciones:
	133	// El parámetro salida recoge la salida desde un fichero que se genera en la ejecución del script siempre que
	134	// sea distinto de NULL, esto es, si al llamar a la función este parámetro es NULL no se recogerá dicha salida.
	135	// Este fichero tiene una ubicación fija: /tmp/_retinterface
	136	//______________________________________________________________________________________________________
	137
	138	int FinterfaceAdmin( char script,char parametros,char* salida)
	139	{
	140	FILE *f;
	141	int lSize,nargs,i,resul;
	142	char msglog[LONSTD],*argumentos[MAXARGS];
	143	char modulo[] = "FinterfaceAdmin()";
	144
	145
	146	if (ndebug>= DEBUG_MEDIO) {
	147	sprintf(msglog, "%s:%s", tbMensajes[8], script);
	148	infoDebug(msglog);
	149	}
	150
	151	/* Crea matriz de los argumentos */
	152	nargs=splitCadena(argumentos,parametros,32);
	153	for(i=nargs;i<MAXARGS;i++){
	154	argumentos[i]=NULL;
	155	}
	156
	157	/* Muestra matriz de los argumentos */
	158	for(i=0;i<nargs;i++){
	159	if (ndebug>= DEBUG_ALTO) {
	160	sprintf(msglog, "%s: #%d-%s", tbMensajes[9],i+1,argumentos[i]);
	161	infoDebug(msglog);
	162	}
	163	}
	164	/* Elimina fichero de retorno */
	165	if(salida!=(char*)NULL){
	166	f = fopen("/tmp/_retinterface_","w" );
	167	if (f==NULL){ // Error de eliminación
	168	scriptLog(modulo,10);
	169	resul=8;
	170	scriptLog(modulo,resul);
	171	return(resul);
	172	}
	173	fclose(f);
	174	}
	175	/* Compone linea de comando */
	176	if(parametros){
	177	strcat(script," ");
	178	strcat(script,parametros);
	179	}
	180	/* LLamada función interface */
	181	resul=system(script);
	182	if(resul){
	183	scriptLog(modulo,10);
	184	scriptLog(modulo,resul);
	185	return(resul);
	186	}
	187	/* Lee fichero de retorno */
	188	if(salida!=(char*)NULL){
	189	f = fopen("/tmp/_retinterface_","rb" );
	190	if (f==NULL){ // Error de apertura
	191	scriptLog(modulo,10);
	192	resul=9;
	193	scriptLog(modulo,resul);
	194	return(resul);
	195	}
	196	else{
	197	fseek (f ,0,SEEK_END); // Obtiene tamaño del fichero.
	198	lSize = ftell (f);
	199	rewind (f);
	200	if(lSize>LONGITUD_SCRIPTSALIDA){
	201	scriptLog(modulo,10);
	202	resul=11;
	203	scriptLog(modulo,resul);
	204	return(resul);
	205	}
	206	fread (salida,1,lSize,f); // Lee contenido del fichero
	207	rTrim(salida);
	208	fclose(f);
	209	}
	210	}
	211	/* Muestra información de retorno */
	212	if(salida!=(char*)NULL){
	213	if(ndebug>2){
	214	sprintf(msglog,"Información devuelta %s",salida);
	215	infoDebug(msglog);
	216	}
	217	}
	218	return(resul);
	219	}
	220	//______________________________________________________________________________________________________
	221	// Función: interfaceAdmin
	222	//
	223	// Descripción:
	224	// Esta función es la puerta de comunicación entre el módulo de administración y el motor de clonación.
	225	// La Aplicación de administración utiliza una interface para ejecutar funciones del motor de clonación;
	226	// esta interface llamará a la API del motor con lo que cambiando el comportamiento de esta interface
	227	// podremos hacer llamadas a otras API de clonación y de esta manera probar distintos motores.
	228	//
	229	// Parámetros:
	230	// - script: Nombre del módulo,función o script de la interface
	231	// - parametros: Parámetros que se le pasarán a la interface
	232	// - salida: Recoge la salida que genera la llamada a la interface
	233
	234	// Devuelve:
	235	// Código de error de la ejecución al módulo , función o script de la interface
	236	//
	237	// Especificaciones:
	238	// El parámetro salida recoge la salida desde el procedimiento hijo que se genera en la ejecución de éste
	239	// siempre que sea distinto de NULL, esto es, si al llamar a la función este parámetro es NULL no se
	240	// recogerá dicha salida.
	241	//______________________________________________________________________________________________________
	242
	243	int interfaceAdmin( char script,char parametros,char* salida)
	244	{
	245	int descr[2]; /* Descriptores de E y S de la turbería */
	246	int bytesleidos; /* Bytes leidos en el mensaje */
	247	int estado;
	248	pid_t pid;
[12a35e7]	249	char buffer[LONBLK]; // Buffer de lectura de fichero
[3ec149c]	250	pipe (descr);
	251	int i,nargs,resul;
[eb093a4]	252	int lon; // Longitud de cadena
	253	char msglog[LONSUC]; // Mensaje de registro de sucesos
[3eca7c1]	254	char *argumentos[MAXARGS];
[3ec149c]	255	char modulo[] = "interfaceAdmin()";
	256	if (ndebug>= DEBUG_MEDIO) {
	257	sprintf(msglog, "%s:%s", tbMensajes[8], script);
	258	infoDebug(msglog);
	259	}
	260
	261	/* Crea matriz de los argumentos */
	262	nargs=splitCadena(argumentos,parametros,32);
	263	for(i=nargs;i<MAXARGS;i++){
	264	argumentos[i]=NULL;
	265	}
	266	/* Muestra matriz de los argumentos */
	267	for(i=1;i<nargs;i++){
	268	if (ndebug>= DEBUG_ALTO) {
[eb093a4]	269	// Truncar la cadena si es mayor que el tamaño de la línea de log.
	270	sprintf(msglog, "%s: #%d-", tbMensajes[9], i+1);
	271	lon = strlen (msglog);
	272	if (lon + strlen (argumentos[i]) < LONSUC) {
	273	strcat (msglog, argumentos[i]);
	274	}
	275	else
	276	{
[3a254b9]	277	strncat (msglog, argumentos[i], LONSUC - lon - 4);
[eb093a4]	278	strcat (msglog, "...");
	279	}
[3ec149c]	280	infoDebug(msglog);
	281	}
	282	}
	283
	284	if((pid=fork())==0)
	285	{
	286	//_______________________________________________________________
	287
	288	/* Proceso hijo que ejecuta la función de interface */
	289
	290	close (descr[LEER]);
	291	dup2 (descr[ESCRIBIR], 1);
	292	close (descr[ESCRIBIR]);
	293	resul=execv(script,argumentos);
	294	//resul=execlp (script, script, argumentos[0],argumentos[1],NULL);
	295	exit(resul);
	296
	297	/* Fin de proceso hijo */
	298	//_______________________________________________________________
	299	}
	300	else
	301	{
	302	//_______________________________________________________________
	303
	304	/* Proceso padre que espera la ejecución del hijo */
	305
	306	if (pid ==-1){ // Error en la creación del proceso hijo
	307	scriptLog(modulo,10);
	308	resul=13;
	309	scriptLog(modulo,resul);
	310	return(resul);
	311	}
	312	close (descr[ESCRIBIR]);
[3eca7c1]	313	bytesleidos = read (descr[LEER], buffer, LONBLK-1);
[3ec149c]	314	while(bytesleidos>0){
	315	if(salida!=(char*)NULL){ // Si se solicita retorno de información...
	316	buffer[bytesleidos]='\0';
[3eca7c1]	317	// Error si se supera el tamaño máximo de cadena de salida.
[3ec149c]	318	if(strlen(buffer)+strlen(salida)>LONGITUD_SCRIPTSALIDA){
	319	scriptLog(modulo,10);
	320	resul=11;
	321	scriptLog(modulo,resul);
	322	return(resul);
	323	}
	324	rTrim(buffer);
	325	strcat(salida,buffer);
	326	}
[3eca7c1]	327	bytesleidos = read (descr[LEER], buffer, LONBLK-1);
[3ec149c]	328	}
	329	close (descr[LEER]);
	330	//kill(pid,SIGQUIT);
	331	waitpid(pid,&estado,0);
	332	resul=WEXITSTATUS(estado);
	333	if(resul){
	334	scriptLog(modulo,10);
	335	scriptLog(modulo,resul);
	336	return(resul);
	337	}
	338	/* Fin de proceso padre */
	339	//_______________________________________________________________
	340	}
	341
	342	/* Muestra información de retorno */
	343	if(salida!=(char*)NULL){
	344	if(ndebug>2){
[eb093a4]	345	// Truncar la cadena si es mayor que el tamaño de la línea de log.
[3eca7c1]	346	strcpy(msglog,"Informacion devuelta ");
[eb093a4]	347	lon = strlen (msglog);
	348	if (lon + strlen (salida) < LONSUC) {
	349	strcat (msglog, salida);
	350	}
	351	else
	352	{
[9ef26af]	353	strncat (msglog, salida, LONSUC-lon-4);
[eb093a4]	354	strcat (msglog, "...");
[3eca7c1]	355	}
[3ec149c]	356	infoDebug(msglog);
	357	}
	358	}
	359	return(resul);
	360	}
	361	//______________________________________________________________________________________________________
	362	// Función: scriptLog
	363	//
	364	// Descripción:
	365	// Registra los sucesos de errores de scripts en el fichero de log
	366	// Parametros:
	367	// - modulo: Módulo donde se produjo el error
	368	// - coderr : Código del mensaje de error del script
	369	//______________________________________________________________________________________________________
	370	void scriptLog(const char *modulo,int coderr)
	371	{
	372	char msglog[LONSUC];
	373
	374	if(coderr<MAXERRORSCRIPT)
	375	errorInfo(modulo,tbErroresScripts[coderr]); // Se ha producido algún error registrado
	376	else{
	377	sprintf(msglog,"%s: %d",tbErroresScripts[MAXERRORSCRIPT],coderr);
	378	errorInfo(modulo,msglog);
	379	}
	380	}
	381	//______________________________________________________________________________________________________
	382	// Función: TomaIPlocal
	383	//
	384	// Descripción:
	385	// Recupera la IP local
	386	// Parámetros:
	387	// Ninguno
	388	// Devuelve:
	389	// TRUE: Si el proceso es correcto
	390	// FALSE: En caso de ocurrir algún error
	391	// Especificaciones:
	392	// En caso de no encontrar la IP o generarse algún error la IP local sería 0.0.0.0
	393	//______________________________________________________________________________________________________
	394	BOOLEAN tomaIPlocal()
	395	{
	396	char modulo[] = "tomaIPlocal()";
	397
[4329e85]	398	// Para debug
	399	//strcpy(IPlocal,"10.1.15.203");
	400	//return(TRUE);
	401
[3ec149c]	402	sprintf(interface,"%s/getIpAddress",pathinterface);
	403	herror=interfaceAdmin(interface,NULL,IPlocal);
	404	if(herror){
	405	errorLog(modulo,85,FALSE);
	406	return(FALSE);
	407	}
	408	return(TRUE);
	409	}
	410	//______________________________________________________________________________________________________
	411	// Función: cuestionCache
	412	//
	413	// Descripción:
	414	// Procesa la cache en caso de existir.
	415	// Parámetros:
	416	// tam : Tamaño de la cache
	417	// Devuelve:
	418	// TRUE: Si el proceso es correcto
	419	// FALSE: En caso de ocurrir algún error
	420	//______________________________________________________________________________________________________
	421	BOOLEAN cuestionCache(char* tam)
	422	{
[4329e85]	423	return(TRUE);
	424	//>>>>>>>>>>>>>>>>>>>>>>>>>>
[3ec149c]	425	char msglog[LONSTD];
	426	char modulo[] = "cuestionCache()";
	427
	428	sprintf(interface,"%s/%s",pathinterface,"procesaCache");
	429	sprintf(parametros,"%s %s","procesaCache",tam);
	430
	431	herror=interfaceAdmin(interface,parametros,NULL);
	432	if(herror){
	433	sprintf(msglog,"%s",tbErrores[88]);
	434	errorInfo(modulo,msglog);
	435	return(FALSE);
	436	}
	437
	438	return(TRUE);
	439	}
	440	//______________________________________________________________________________________________________
	441	// Función: cargaPaginaWeb
	442	//
	443	// Descripción:
	444	// Muestra una pégina web usando el browser
	445	// Parámetros:
	446	// urp: Dirección url de la página
	447	// Devuelve:
	448	// TRUE: Si el proceso es correcto
	449	// FALSE: En caso de ocurrir algún error
	450	// ________________________________________________________________________________________________________
	451	int cargaPaginaWeb(char *url)
	452	{
	453	int resul=0;
[2beed29]	454	char* argumentos[4];
[3ec149c]	455	char modulo[] = "cargaPaginaWeb()";
	456
	457	if(pidbash>0)
	458	kill(pidbash,SIGQUIT); // Destruye el proceso hijo del proceso bash si existiera una conmutación
	459
	460	if(pidbrowser>0)
	461	kill(pidbrowser,SIGQUIT); // Destruye el proceso hijo anterior y se queda sólo el actual
	462
	463	sprintf(interface,"/opt/opengnsys/bin/browser");
[2beed29]	464	sprintf(parametros,"browser -qws %s",url);
[3ec149c]	465
	466	splitCadena(argumentos,parametros,' '); // Crea matriz de los argumentos del scripts
[2beed29]	467	argumentos[3]=NULL;
[3ec149c]	468	if((pidbrowser=fork())==0){
	469	/* Proceso hijo que ejecuta el script */
	470	resul=execv(interface,argumentos);
	471	exit(resul);
	472	}
	473	else {
	474	if (pidbrowser ==-1){
	475	scriptLog(modulo,10);
	476	resul=13;
	477	scriptLog(modulo,resul);
	478	return(resul);
	479	}
	480	}
	481	return(resul);
	482	}
	483	//________________________________________________________________________________________________________
	484	// Función: muestraMenu
	485	//
	486	// Descripción:
	487	// Muestra el menu inicial del cliente
	488	// Parámetros:
	489	// Ninguno
	490	// Devuelve:
	491	// TRUE: Si el proceso es correcto
	492	// FALSE: En caso de ocurrir algún error
	493	//________________________________________________________________________________________________________
	494	void muestraMenu()
	495	{
	496	cargaPaginaWeb(urlmenu);
	497	}
	498	//______________________________________________________________________________________________________
	499	// Función: muestraMensaje
	500	//
	501	// Descripción:
	502	// Muestra un mensaje en pantalla
	503	// Parámetros:
	504	// - idx: Indice del mensaje
	505	// - msg: Descripción Mensaje
	506	// ________________________________________________________________________________________________________
	507	void muestraMensaje(int idx,char*msg)
	508	{
[4329e85]	509	char *msgpan,url[250];
	510
	511	if(msg){
	512	msgpan=URLEncode(msg);
	513	sprintf(url,"%s?msg=%s",urlmsg,msgpan); // Url de la página de mensajes
	514	liberaMemoria(msgpan);
	515	}
[3ec149c]	516	else
	517	sprintf(url,"%s?idx=%d",urlmsg,idx); // Url de la página de mensajes
	518	cargaPaginaWeb(url);
	519	}
	520	//______________________________________________________________________________________________________
	521	// Función: InclusionCliente
	522	// Descripción:
	523	// Abre una sesión en el servidor de administración y registra al cliente en el sistema
	524	// Parámetros:
	525	// Ninguno
	526	// Devuelve:
	527	// TRUE: Si el proceso es correcto
	528	// FALSE: En caso de ocurrir algún error
	529	//______________________________________________________________________________________________________
	530	BOOLEAN inclusionCliente(TRAMA* ptrTrama)
	531	{
[eb093a4]	532	int lon; // Longitud de cadena
	533	char msglog[LONSUC]; // Mensaje de registro de sucesos
	534	char *cfg; // Datos de configuración
[3ec149c]	535	SOCKET socket_c;
	536	char modulo[] = "inclusionCliente()";
	537
[9ef26af]	538	cfg=LeeConfiguracion();
	539
[3ec149c]	540	if(!cfg){ // No se puede recuperar la configuración del cliente
	541	errorLog(modulo,36,FALSE);
	542	errorLog(modulo,37,FALSE);
	543	return(FALSE);
	544	}
	545	if (ndebug>= DEBUG_ALTO) {
[eb093a4]	546	// Truncar la cadena si es mayor que el tamaño de la línea de log.
[9ef26af]	547	sprintf(msglog, "%s", tbMensajes[14]);
[eb093a4]	548	lon = strlen (msglog);
	549	if (lon + strlen (cfg) < LONSUC) {
	550	strcat (msglog, cfg);
	551	}
	552	else
	553	{
[3a254b9]	554	strncat (msglog, cfg, LONSUC - lon - 4);
[eb093a4]	555	strcat (msglog, "...");
	556	}
[3ec149c]	557	infoDebug(msglog);
	558	}
	559	initParametros(ptrTrama,0);
	560	lon=sprintf(ptrTrama->parametros,"nfn=InclusionCliente\r"); // Nombre de la función a ejecutar en el servidor
	561	lon+=sprintf(ptrTrama->parametros+lon,"cfg=%s\r",cfg); // Configuración de los Sistemas Operativos del cliente
[4329e85]	562	liberaMemoria(cfg);
	563
[3ec149c]	564	if(!enviaMensajeServidor(&socket_c,ptrTrama,MSG_PETICION)){
	565	errorLog(modulo,37,FALSE);
	566	return(FALSE);
	567	}
	568	ptrTrama=recibeMensaje(&socket_c);
	569	if(!ptrTrama){
	570	errorLog(modulo,45,FALSE);
	571	return(FALSE);
	572	}
[eeeb98a]	573
[3ec149c]	574	close(socket_c);
	575
	576	if(!gestionaTrama(ptrTrama)){ // Análisis de la trama
	577	errorLog(modulo,39,FALSE);
	578	return(FALSE);
	579	}
	580
	581	return(TRUE);
	582	}
	583	//______________________________________________________________________________________________________
	584	// Función: RESPUESTA_InclusionCliente
	585	//
	586	// Descripción:
	587	// Respuesta del servidor de administración a la petición de inicio
	588	// enviando los datos identificativos del cliente y otras configuraciones
	589	// Parámetros:
	590	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
	591	// Devuelve:
	592	// TRUE: Si el proceso es correcto
	593	// FALSE: En caso de ocurrir algún error
	594	//______________________________________________________________________________________________________
	595	BOOLEAN RESPUESTA_InclusionCliente(TRAMA* ptrTrama)
	596	{
	597	char* res;
	598	char modulo[] = "RESPUESTA_InclusionCliente()";
	599
	600	res=copiaParametro("res",ptrTrama); // Resultado del proceso de inclusión
	601	if(atoi(res)==0){ // Error en el proceso de inclusión
[4329e85]	602	liberaMemoria(res);
[3ec149c]	603	errorLog(modulo,41,FALSE);
	604	return (FALSE);
	605	}
[4329e85]	606	liberaMemoria(res);
	607
	608	idordenador=copiaParametro("ido",ptrTrama); // Identificador del ordenador
	609	nombreordenador=copiaParametro("npc",ptrTrama); // Nombre del ordenador
	610	cache=copiaParametro("che",ptrTrama); // Tamaño de la caché reservada al cliente
	611	idproautoexec=copiaParametro("exe",ptrTrama); // Procedimento de inicio (Autoexec)
	612	idcentro=copiaParametro("idc",ptrTrama); // Identificador de la Unidad Organizativa
	613	idaula=copiaParametro("ida",ptrTrama); // Identificador del aula
[3ec149c]	614
	615	if(idordenador==NULL \|\| nombreordenador==NULL){
	616	errorLog(modulo,40,FALSE);
	617	return (FALSE);
	618	}
	619	return(TRUE);
	620	}
	621	//______________________________________________________________________________________________________
	622	//
	623	// Función: LeeConfiguracion
	624	// Descripción:
	625	// Abre una sesión en el servidor de administración y registra al cliente en el sistema
	626	// Parámetros:
	627	// Ninguno
	628	// Devuelve:
	629	// TRUE: Si el proceso es correcto
	630	// FALSE: En caso de ocurrir algún error
	631	//______________________________________________________________________________________________________
	632
[b7728bd]	633	char* LeeConfiguracion()
[3ec149c]	634	{
	635	char* parametroscfg;
	636	char modulo[] = "LeeConfiguracion()";
	637
[b7728bd]	638	// Reservar memoria para los datos de cofiguración.
	639	parametroscfg=(char*)reservaMemoria(LONGITUD_SCRIPTSALIDA);
[3ec149c]	640	if(!parametroscfg){
	641	errorLog(modulo,3,FALSE);
	642	return(NULL);
	643	}
[b7728bd]	644	// Ejecutar script y obtener datos.
[3ec149c]	645	sprintf(interface,"%s/%s",pathinterface,"getConfiguration");
	646	herror=interfaceAdmin(interface,NULL,parametroscfg);
	647
	648	if(herror){ // No se puede recuperar la configuración del cliente
[4329e85]	649	liberaMemoria(parametroscfg);
[3ec149c]	650	errorLog(modulo,36,FALSE);
	651	return(NULL);
	652	}
	653	return(parametroscfg);
	654	}
	655	//________________________________________________________________________________________________________
	656	// Función: autoexecCliente
	657	//
	658	// Descripción:
	659	// Solicita procedimiento de autoexec para el cliebnte
	660	// Parámetros:
	661	// Ninguno
	662	// Devuelve:
	663	// TRUE: Si el proceso es correcto
	664	// FALSE: En caso de ocurrir algún error
	665	//________________________________________________________________________________________________________
	666	BOOLEAN autoexecCliente(TRAMA* ptrTrama)
	667	{
	668	int lon;
	669	SOCKET socket_c;
	670	char modulo[] = "autoexecCliente()";
	671
	672	initParametros(ptrTrama,0);
	673	lon=sprintf(ptrTrama->parametros,"nfn=AutoexecCliente\rexe=%s\r",idproautoexec);
	674
	675	if(!enviaMensajeServidor(&socket_c,ptrTrama,MSG_PETICION)){
	676	errorLog(modulo,42,FALSE);
	677	return(FALSE);
	678	}
	679	ptrTrama=recibeMensaje(&socket_c);
	680	if(!ptrTrama){
	681	errorLog(modulo,45,FALSE);
	682	return(FALSE);
	683	}
	684
	685	close(socket_c);
	686
	687	if(!gestionaTrama(ptrTrama)){ // Análisis de la trama
	688	errorLog(modulo,39,FALSE);
	689	return(FALSE);
	690	}
	691
	692	return(TRUE);
	693	}
	694	//________________________________________________________________________________________________________
	695	// Función: autoexecCliente
	696	//
	697	// Descripción:
	698	// Ejecuta un script de autoexec personalizado en todos los inicios para el cliente
	699	// Parámetros:
	700	// Ninguno
	701	// Devuelve:
	702	// TRUE: Si el proceso es correcto
	703	// FALSE: En caso de ocurrir algún error
	704	//________________________________________________________________________________________________________
	705	BOOLEAN RESPUESTA_AutoexecCliente(TRAMA* ptrTrama)
	706	{
	707	SOCKET socket_c;
	708	char res,nfl;
	709	char modulo[] = "RESPUESTA_AutoexecCliente()";
	710
	711	res=copiaParametro("res",ptrTrama);
	712	if(atoi(res)==0){ // Error en el proceso de autoexec
[4329e85]	713	liberaMemoria(res);
[3ec149c]	714	return (FALSE);
	715	}
[4329e85]	716	liberaMemoria(res);
	717
[3ec149c]	718	nfl=copiaParametro("nfl",ptrTrama);
	719	initParametros(ptrTrama,0);
	720	sprintf(ptrTrama->parametros,"nfn=enviaArchivo\rnfl=%s\r",nfl);
[4329e85]	721	liberaMemoria(nfl);
	722
[3ec149c]	723	/* Envía petición */
	724	if(!enviaMensajeServidor(&socket_c,ptrTrama,MSG_PETICION)){
	725	errorLog(modulo,42,FALSE);
	726	return(FALSE);
	727	}
	728	/* Nombre del archivo destino (local)*/
	729	char fileautoexec[LONPRM];
	730	sprintf(fileautoexec,"/tmp/_autoexec_%s",IPlocal);
	731
	732	/* Recibe archivo */
	733	if(!recArchivo(&socket_c,fileautoexec)){
	734	errorLog(modulo,58, FALSE);
	735	close(socket_c);
	736	return(FALSE);
	737	}
	738
	739	close(socket_c);
	740
	741	/* Ejecuta archivo */
	742	ejecutaArchivo(fileautoexec,ptrTrama);
	743	return(TRUE);
	744	}
	745	//______________________________________________________________________________________________________
	746	// Función: comandosPendientes
	747	//
	748	// Descripción:
	749	// Búsqueda de acciones pendientes en el servidor de administración
	750	// Parámetros:
	751	// Ninguno
	752	// Devuelve:
	753	// TRUE: Si el proceso es correcto
	754	// FALSE: En caso de ocurrir algún error
	755	//______________________________________________________________________________________________________
	756	BOOLEAN comandosPendientes(TRAMA* ptrTrama)
	757	{
	758	SOCKET socket_c;
	759	char modulo[] = "comandosPendientes()";
	760
	761	CMDPTES=TRUE;
	762	initParametros(ptrTrama,0);
	763
	764	while(CMDPTES){
	765	sprintf(ptrTrama->parametros,"nfn=ComandosPendientes\r");
	766	if(!enviaMensajeServidor(&socket_c,ptrTrama,MSG_PETICION)){
	767	errorLog(modulo,42,FALSE);
	768	return(FALSE);
	769	}
	770	ptrTrama=recibeMensaje(&socket_c);
	771	if(!ptrTrama){
	772	errorLog(modulo,45,FALSE);
	773	return(FALSE);
	774	}
[eeeb98a]	775
[3ec149c]	776	close(socket_c);
	777
	778	if(!gestionaTrama(ptrTrama)){ // Análisis de la trama
	779	errorLog(modulo,39,FALSE);
	780	return(FALSE);
	781	}
	782	}
	783	return(TRUE);
	784	}
	785	//______________________________________________________________________________________________________
	786	// Función: NoComandosPtes
	787	//
	788	// Descripción:
	789	// Conmuta el switch de los comandos pendientes y lo pone a false
	790	// Parámetros:
	791	// - ptrTrama: contenido del mensaje
	792	// Devuelve:
	793	// TRUE siempre
	794	// Especificaciones:
	795	// Cuando se ejecuta esta función se sale del bucle que recupera los comandos pendientes en el
	796	// servidor y el cliente pasa a a estar disponible para recibir comandos desde el éste.
	797	//______________________________________________________________________________________________________
	798	BOOLEAN NoComandosPtes(TRAMA* ptrTrama)
	799	{
	800	CMDPTES=FALSE; // Corta el bucle de comandos pendientes
	801	return(TRUE);
	802	}
	803	//______________________________________________________________________________________________________
	804	// Función: ProcesaComandos
	805	//
	806	// Descripción:
	807	// Espera comando desde el Servidor de Administración para ejecutarlos
	808	// Parámetros:
	809	// Ninguno
	810	// Devuelve:
	811	// TRUE: Si el proceso es correcto
	812	// FALSE: En caso de ocurrir algún error
	813	// ________________________________________________________________________________________________________
	814	void procesaComandos(TRAMA* ptrTrama)
	815	{
	816	int lon;
	817	SOCKET socket_c;
	818	char modulo[] = "procesaComandos()";
	819
	820	initParametros(ptrTrama,0);
	821	while(TRUE){
	822	lon=sprintf(ptrTrama->parametros,"nfn=DisponibilidadComandos\r");
	823	lon+=sprintf(ptrTrama->parametros+lon,"tpc=%s\r",CLIENTE_OPENGNSYS); // Activar disponibilidad
	824	if(!enviaMensajeServidor(&socket_c,ptrTrama,MSG_INFORMACION)){
	825	errorLog(modulo,43,FALSE);
	826	return;
	827	}
	828	infoLog(19); // Disponibilidad de cliente activada
	829	ptrTrama=recibeMensaje(&socket_c);
	830	if(!ptrTrama){
	831	errorLog(modulo,46,FALSE);
	832	return;
	833	}
	834
	835	close(socket_c);
	836
	837	if(!gestionaTrama(ptrTrama)){ // Análisis de la trama
	838	errorLog(modulo,39,FALSE);
	839	return;
	840	}
	841	if(!comandosPendientes(ptrTrama)){
	842	errorLog(modulo,42,FALSE);
	843	}
	844	}
	845	}
	846	//______________________________________________________________________________________________________
	847	// Función: Actualizar
	848	//
	849	// Descripción:
	850	// Actualiza los datos de un ordenador como si volviera a solicitar la entrada
	851	// en el sistema al servidor de administración
	852	// Parámetros:
	853	// ptrTrama: contenido del mensajede
	854	// Devuelve:
	855	// TRUE: Si el proceso es correcto
	856	// FALSE: En caso de ocurrir algún error
	857	//______________________________________________________________________________________________________
	858	BOOLEAN Actualizar(TRAMA* ptrTrama)
	859	{
[b7728bd]	860	char msglog[LONSTD]; // Mensaje de log
	861	char *cfg; // Cadena de datos de configuración
	862	int lon; // Longitud de cadena
[3ec149c]	863	char modulo[] = "Actualizar()";
	864
	865	if (ndebug>=DEBUG_MAXIMO) {
	866	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
	867	infoDebug(msglog);
	868	}
	869	muestraMensaje(1,NULL);
	870	if(!comandosPendientes(ptrTrama)){
	871	errorLog(modulo,84,FALSE);
	872	return(FALSE);
	873	}
[7224a0a]	874
[b7728bd]	875	cfg=LeeConfiguracion();
[7224a0a]	876	herror=0;
	877	if(!cfg){ // No se puede recuperar la configuración del cliente
	878	errorLog(modulo,36,FALSE);
	879	herror=3;
	880	}
	881	// Envia Configuracion al servidor
	882	initParametros(ptrTrama,0);
	883	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_Configurar");
	884	lon+=sprintf(ptrTrama->parametros+lon,"cfg=%s\r",cfg); // Configuración de los Sistemas Operativos del cliente
	885	respuestaEjecucionComando(ptrTrama,herror,0);
	886
[3ec149c]	887	muestraMenu();
[7224a0a]	888
[3ec149c]	889	return(TRUE);
	890	}
	891	//______________________________________________________________________________________________________
	892	// Función: Purgar
	893	//
	894	// Descripción:
	895	// Detiene la ejecución del browser
	896	// Parámetros:
	897	// ptrTrama: contenido del mensajede
	898	// Devuelve:
	899	// TRUE: Si el proceso es correcto
	900	// FALSE: En caso de ocurrir algún error
	901	//______________________________________________________________________________________________________
	902	int Purgar(TRAMA* ptrTrama)
	903	{
	904	int resul=0;
	905	char modulo[] = "Purgar()";
	906
	907	if(pidbrowser>0)
	908	kill(pidbrowser,SIGQUIT); // Destruye el proceso hijo anterior y se queda sólo el actual
	909
	910	if(pidbash>0)
	911	kill(pidbash,SIGQUIT); // Destruye el proceso hijo del proceso bash si existiera una conmutación
	912
	913	sprintf(interface,"/opt/opengnsys/bin/bash");
	914	if((pidbash=fork())==0){
	915	/* Proceso hijo que ejecuta el script */
	916	resul=execv(interface,NULL);
	917	exit(resul);
	918	}
	919	else {
	920	if (pidbash ==-1){
	921	scriptLog(modulo,10);
	922	resul=13;
	923	scriptLog(modulo,resul);
	924	return(resul);
	925	}
	926	}
	927	exit(EXIT_SUCCESS);
	928	}
	929	//______________________________________________________________________________________________________
	930	// Función: Sondeo
	931	//
	932	// Descripción:
	933	// Envía al servidor una confirmación de que está dentro del sistema
	934	// Parámetros:
	935	// ptrTrama: contenido del mensajede
	936	// Devuelve:
	937	// TRUE: Si el proceso es correcto
	938	// FALSE: En caso de ocurrir algún error
	939	//______________________________________________________________________________________________________
	940	BOOLEAN Sondeo(TRAMA* ptrTrama)
	941	{
	942	return(TRUE);
	943	}
	944	//______________________________________________________________________________________________________
	945	// Función: ConsolaRemota
	946	//
	947	// Descripción:
	948	// Ejecuta un comando de la Shell y envia el eco al servidor (Consola remota)
	949	// Parámetros:
	950	// ptrTrama: contenido del mensaje
	951	// Devuelve:
	952	// TRUE: Si el proceso es correcto
	953	// FALSE: En caso de ocurrir algún error
	954	//______________________________________________________________________________________________________
	955	BOOLEAN ConsolaRemota(TRAMA* ptrTrama)
	956	{
	957	SOCKET socket_c;
[4329e85]	958	char nfn,scp,*aux,ecosrc[LONPRM],ecodst[LONPRM],msglog[LONSTD];;
[3ec149c]	959	char modulo[] = "ConsolaRemota()";
	960
	961	/* Nombre del archivo de script */
	962	char filescript[LONPRM];
	963	sprintf(filescript,"/tmp/_script_%s",IPlocal);
[4329e85]	964
	965	aux=copiaParametro("scp",ptrTrama);
	966	scp=URLDecode(aux);
[3ec149c]	967	escribeArchivo(filescript,scp);
[4329e85]	968	liberaMemoria(aux);
	969	liberaMemoria(scp);
	970
	971	nfn=copiaParametro("nfn",ptrTrama);
[3ec149c]	972	sprintf(interface,"%s/%s",pathinterface,nfn);
	973	sprintf(ecosrc,"/tmp/_econsola_%s",IPlocal);
	974	sprintf(parametros,"%s %s %s",nfn,filescript,ecosrc);
	975	herror=interfaceAdmin(interface,parametros,NULL);
	976	if(herror){
	977	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
	978	errorInfo(modulo,msglog);
	979	}
	980	else{
	981	/* Envía fichero de inventario al servidor */
	982	sprintf(ecodst,"/tmp/_Seconsola_%s",IPlocal); // Nombre que tendra el archivo en el Servidor
	983	initParametros(ptrTrama,0);
	984	sprintf(ptrTrama->parametros,"nfn=recibeArchivo\rnfl=%s\r",ecodst);
	985	if(!enviaMensajeServidor(&socket_c,ptrTrama,MSG_COMANDO)){
	986	errorLog(modulo,42,FALSE);
	987	return(FALSE);
	988	}
	989	/* Espera señal para comenzar el envío */
[4329e85]	990	liberaMemoria(ptrTrama);
[3ec149c]	991	recibeFlag(&socket_c,ptrTrama);
	992	/* Envía archivo */
	993	if(!sendArchivo(&socket_c,ecosrc)){
	994	errorLog(modulo,57, FALSE);
	995	herror=12; // Error de envío de fichero por la red
	996	}
	997	close(socket_c);
	998	}
[4329e85]	999	liberaMemoria(nfn);
[3ec149c]	1000	return(TRUE);
	1001	}
	1002	//_____________________________________________________________________________________________________
	1003	// Función: Comando
	1004	//
	1005	// Descripción:
	1006	// COmando personalizado enviado desde el servidor
	1007	// Parámetros:
	1008	// ptrTrama: contenido del mensaje
	1009	// Devuelve:
	1010	// TRUE: Si el proceso es correcto
	1011	// FALSE: En caso de ocurrir algún error
	1012	//_____________________________________________________________________________________________________
	1013	BOOLEAN Comando(TRAMA* ptrTrama)
	1014	{
	1015	int lon;
	1016	char ids,nfn,msglog[LONSTD];
	1017	char modulo[] = "Comando()";
	1018
	1019	if (ndebug>=DEBUG_MAXIMO) {
	1020	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
	1021	infoDebug(msglog);
	1022	}
	1023	nfn=copiaParametro("nfn",ptrTrama);
	1024	ids=copiaParametro("ids",ptrTrama);
	1025
	1026	sprintf(interface,"%s/%s",pathinterface,nfn);
	1027	herror=interfaceAdmin(interface,NULL,NULL);
	1028	if(herror){
	1029	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
	1030	errorInfo(modulo,msglog);
	1031	}
	1032	/* Envia respuesta de ejecucución del comando */
	1033	initParametros(ptrTrama,0);
	1034	lon=sprintf(ptrTrama->parametros,"nfn=RESPUESTA_%s\r",nfn);
	1035	respuestaEjecucionComando(ptrTrama,herror,ids);
[4329e85]	1036	liberaMemoria(nfn);
	1037	liberaMemoria(ids);
[3ec149c]	1038	return(TRUE);
	1039	}
	1040	//_____________________________________________________________________________________________________
	1041	// Función: Arrancar
	1042	//
	1043	// Descripción:
	1044	// Responde a un comando de encendido por la red
	1045	// Parámetros:
	1046	// ptrTrama: contenido del mensaje
	1047	// Devuelve:
	1048	// TRUE: Si el proceso es correcto
	1049	// FALSE: En caso de ocurrir algún error
	1050	//_____________________________________________________________________________________________________
	1051	BOOLEAN Arrancar(TRAMA* ptrTrama)
	1052	{
	1053	int lon;
	1054	char *ids,msglog[LONSTD];
	1055	char modulo[] = "Arrancar()";
	1056
	1057	if (ndebug>=DEBUG_MAXIMO) {
	1058	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
	1059	infoDebug(msglog);
	1060	}
	1061
	1062	ids=copiaParametro("ids",ptrTrama);
	1063
	1064	/* Envia respuesta de ejecucución del script */
	1065	initParametros(ptrTrama,0);
	1066	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_Arrancar");
	1067	lon+=sprintf(ptrTrama->parametros+lon,"tpc=%s\r",CLIENTE_OPENGNSYS);
	1068	respuestaEjecucionComando(ptrTrama,0,ids);
[4329e85]	1069	liberaMemoria(ids);
[3ec149c]	1070	return(TRUE);
	1071	}
	1072	//_____________________________________________________________________________________________________
	1073	// Función: Apagar
	1074	//
	1075	// Descripción:
	1076	// Apaga el cliente
	1077	// Parámetros:
	1078	// ptrTrama: contenido del mensaje
	1079	// Devuelve:
	1080	// TRUE: Si el proceso es correcto
	1081	// FALSE: En caso de ocurrir algún error
	1082	//_____________________________________________________________________________________________________
	1083	BOOLEAN Apagar(TRAMA* ptrTrama)
	1084	{
	1085	int lon;
	1086	char ids,nfn,msglog[LONSTD];
	1087	char modulo[] = "Apagar()";
	1088
	1089	if (ndebug>=DEBUG_MAXIMO) {
	1090	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
	1091	infoDebug(msglog);
	1092	}
	1093	nfn=copiaParametro("nfn",ptrTrama);
	1094	ids=copiaParametro("ids",ptrTrama);
	1095
	1096	initParametros(ptrTrama,0);
	1097	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_Apagar");
	1098	respuestaEjecucionComando(ptrTrama,0,ids);
	1099
	1100	sprintf(interface,"%s/%s",pathinterface,nfn);
	1101	herror=interfaceAdmin(interface,NULL,NULL);
	1102	if(herror){
	1103	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
[4329e85]	1104	liberaMemoria(nfn);
	1105	liberaMemoria(ids);
[3ec149c]	1106	errorInfo(modulo,msglog);
	1107	return(FALSE);
	1108	}
[4329e85]	1109	liberaMemoria(nfn);
	1110	liberaMemoria(ids);
[3ec149c]	1111	return(TRUE);
	1112	}
	1113	//_____________________________________________________________________________________________________
	1114	// Función: Reiniciar
	1115	//
	1116	// Descripción:
	1117	// Apaga el cliente
	1118	// Parámetros:
	1119	// ptrTrama: contenido del mensaje
	1120	// Devuelve:
	1121	// TRUE: Si el proceso es correcto
	1122	// FALSE: En caso de ocurrir algún error
	1123	//_____________________________________________________________________________________________________
	1124	BOOLEAN Reiniciar(TRAMA* ptrTrama)
	1125	{
	1126	int lon;
	1127	char nfn,ids,msglog[LONSTD];
	1128	char modulo[] = "Reiniciar()";
	1129
	1130	if (ndebug>=DEBUG_MAXIMO) {
	1131	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
	1132	infoDebug(msglog);
	1133	}
	1134	nfn=copiaParametro("nfn",ptrTrama);
	1135	ids=copiaParametro("ids",ptrTrama);
	1136
	1137	initParametros(ptrTrama,0);
	1138	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_Reiniciar");
	1139	respuestaEjecucionComando(ptrTrama,0,ids);
	1140
	1141	sprintf(interface,"%s/%s",pathinterface,nfn);
	1142	herror=interfaceAdmin(interface,NULL,NULL);
	1143	if(herror){
	1144	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
[4329e85]	1145	liberaMemoria(nfn);
	1146	liberaMemoria(ids);
[3ec149c]	1147	errorInfo(modulo,msglog);
	1148	return(FALSE);
	1149	}
[4329e85]	1150	liberaMemoria(nfn);
	1151	liberaMemoria(ids);
[3ec149c]	1152	return(TRUE);
	1153	}
	1154	//_____________________________________________________________________________________________________
	1155	// Función: IniciarSesion
	1156	//
	1157	// Descripción:
	1158	// Inicia sesión en el Sistema Operativo de una de las particiones
	1159	// Parámetros:
	1160	// ptrTrama: contenido del mensaje
	1161	// Devuelve:
	1162	// TRUE: Si el proceso es correcto
	1163	// FALSE: En caso de ocurrir algún error
	1164	//_____________________________________________________________________________________________________
	1165	BOOLEAN IniciarSesion(TRAMA* ptrTrama)
	1166	{
	1167	int lon;
[b2651a6]	1168	char nfn,ids,disk,par,msglog[LONSTD];
[3ec149c]	1169	char modulo[] = "IniciarSesion()";
	1170
	1171	if (ndebug>=DEBUG_MAXIMO) {
	1172	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
	1173	infoDebug(msglog);
	1174	}
	1175	nfn=copiaParametro("nfn",ptrTrama);
	1176	ids=copiaParametro("ids",ptrTrama);
[b2651a6]	1177	disk=copiaParametro("dsk",ptrTrama);
[179ccd2]	1178	par=copiaParametro("par",ptrTrama);
	1179
[3ec149c]	1180	initParametros(ptrTrama,0);
	1181	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_IniciarSesion");
	1182	respuestaEjecucionComando(ptrTrama,0,ids);
[4329e85]	1183	liberaMemoria(ids);
[3ec149c]	1184
	1185	sprintf(interface,"%s/%s",pathinterface,nfn);
[b2651a6]	1186	sprintf(parametros,"%s %s %s",nfn,disk,par);
[4329e85]	1187	liberaMemoria(par);
	1188
[3ec149c]	1189	herror=interfaceAdmin(interface,parametros,NULL);
	1190
	1191	if(herror){
	1192	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
[4329e85]	1193	liberaMemoria(nfn);
[3ec149c]	1194	errorInfo(modulo,msglog);
	1195	return(FALSE);
	1196	}
[4329e85]	1197	liberaMemoria(nfn);
[3ec149c]	1198	return(TRUE);
	1199	}
	1200	//______________________________________________________________________________________________________
	1201	// Función: CrearImagen
	1202	//
	1203	// Descripción:
	1204	// Crea una imagen de una partición
	1205	// Parámetros:
	1206	// ptrTrama: contenido del mensaje
	1207	// Devuelve:
	1208	// TRUE: Si el proceso es correcto
	1209	// FALSE: En caso de ocurrir algún error
	1210	//______________________________________________________________________________________________________
	1211	BOOLEAN CrearImagen(TRAMA* ptrTrama)
	1212	{
	1213	int lon;
	1214	char nfn,dsk,par,cpt,idi,ipr,nci,ids,msglog[LONSTD];
	1215	char modulo[] = "CrearImagen()";
	1216
	1217	if (ndebug>=DEBUG_MAXIMO) {
	1218	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
	1219	infoDebug(msglog);
	1220	}
	1221
	1222	dsk=copiaParametro("dsk",ptrTrama); // Disco
	1223	par=copiaParametro("par",ptrTrama); // Número de partición
	1224	cpt=copiaParametro("cpt",ptrTrama); // Código de la partición
	1225	idi=copiaParametro("idi",ptrTrama); // Identificador de la imagen
	1226	nci=copiaParametro("nci",ptrTrama); // Nombre canónico de la imagen
	1227	ipr=copiaParametro("ipr",ptrTrama); // Ip del repositorio
	1228
	1229	nfn=copiaParametro("nfn",ptrTrama);
	1230	ids=copiaParametro("ids",ptrTrama);
[eb9424f]	1231	muestraMensaje(7,NULL);
[4329e85]	1232
[3ec149c]	1233	if(InventariandoSoftware(ptrTrama,FALSE,"InventarioSoftware")){ // Crea inventario Software previamente
	1234	muestraMensaje(2,NULL);
	1235	sprintf(interface,"%s/%s",pathinterface,nfn);
	1236	sprintf(parametros,"%s %s %s %s %s",nfn,dsk,par,nci,ipr);
	1237	herror=interfaceAdmin(interface,parametros,NULL);
	1238	if(herror){
	1239	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
	1240	errorInfo(modulo,msglog);
	1241	muestraMensaje(10,NULL);
	1242	}
	1243	else
	1244	muestraMensaje(9,NULL);
	1245	}
	1246	else{
	1247	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
	1248	errorInfo(modulo,msglog);
	1249	}
	1250
	1251	/* Envia respuesta de ejecución de la función de interface */
	1252	initParametros(ptrTrama,0);
	1253	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_CrearImagen");
	1254	lon+=sprintf(ptrTrama->parametros+lon,"idi=%s\r",idi); // Identificador de la imagen
	1255	lon+=sprintf(ptrTrama->parametros+lon,"par=%s\r",par); // Número de partición de donde se creó
	1256	lon+=sprintf(ptrTrama->parametros+lon,"cpt=%s\r",cpt); // Tipo o código de partición
	1257	lon+=sprintf(ptrTrama->parametros+lon,"ipr=%s\r",ipr); // Ip del repositorio donde se alojó
	1258	respuestaEjecucionComando(ptrTrama,herror,ids);
[4329e85]	1259
	1260	liberaMemoria(dsk);
	1261	liberaMemoria(par);
	1262	liberaMemoria(cpt);
	1263	liberaMemoria(idi);
	1264	liberaMemoria(nci);
	1265	liberaMemoria(ipr);
	1266	liberaMemoria(nfn);
	1267	liberaMemoria(ids);
[380fe92]	1268
	1269	muestraMenu();
[4329e85]	1270
	1271	return(TRUE);
	1272	}
	1273	//______________________________________________________________________________________________________
	1274	// Función: CrearImagenBasica
	1275	//
	1276	// Descripción:
	1277	// Crea una imagen básica a traverś dela sincronización
	1278	// Parámetros:
	1279	// ptrTrama: contenido del mensaje
	1280	//
	1281	// FDevuelve:
	1282	// TRUE: Si el proceso es correcto
	1283	// FALSE: En caso de ocurrir algún error
	1284	//______________________________________________________________________________________________________
	1285	BOOLEAN CrearImagenBasica(TRAMA* ptrTrama)
	1286	{
	1287	int lon;
[6a830ffa]	1288	char nfn,dsk,par,cpt,idi,nci,rti,ipr,whl,eli,cmp,bpi,cpc,bpc,nba,ids,msglog[LONSTD];
[4329e85]	1289	char modulo[] = "CrearImagenBasica()";
	1290
	1291	if (ndebug>=DEBUG_MAXIMO) {
	1292	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
	1293	infoDebug(msglog);
	1294	}
	1295	nfn=copiaParametro("nfn",ptrTrama);
	1296	dsk=copiaParametro("dsk",ptrTrama); // Disco
	1297	par=copiaParametro("par",ptrTrama); // Número de partición
	1298	cpt=copiaParametro("cpt",ptrTrama); // Tipo de partición
	1299	idi=copiaParametro("idi",ptrTrama); // Identificador de la imagen
	1300	nci=copiaParametro("nci",ptrTrama); // Nombre canónico de la imagen
	1301	rti=copiaParametro("rti",ptrTrama); // Ruta de origen de la imagen
	1302	ipr=copiaParametro("ipr",ptrTrama); // Ip del repositorio
[6a830ffa]	1303
	1304	whl=copiaParametro("whl",ptrTrama); // Envío del fichero completo si hay diferencias
	1305	eli=copiaParametro("eli",ptrTrama); // Elimiar archivos en destino que no estén en origen
	1306	cmp=copiaParametro("cmp",ptrTrama); // Comprimir antes de enviar
	1307
[4329e85]	1308	bpi=copiaParametro("bpi",ptrTrama); // Borrar la imagen antes de crearla
	1309	cpc=copiaParametro("cpc",ptrTrama); // Copiar también imagen a la cache
	1310	bpc=copiaParametro("bpc",ptrTrama); // Borrarla de la cache antes de copiarla en ella
	1311	nba=copiaParametro("nba",ptrTrama); // No borrar archivos en destino
	1312
	1313	//muestraMensaje(7,NULL); // Creando Inventario Software
	1314	//if(InventariandoSoftware(ptrTrama,FALSE,"InventarioSoftware")){ // Crea inventario Software previamente
	1315	muestraMensaje(30,NULL);// Creando Imagen Básica, por favor espere...
	1316	sprintf(interface,"%s/%s",pathinterface,nfn);
[6a830ffa]	1317	sprintf(parametros,"%s %s %s %s %s %s%s%s %s%s%s%s %s",nfn,dsk,par,nci,ipr,whl,eli,cmp,bpi,cpc,bpc,nba,rti);
[4329e85]	1318	herror=interfaceAdmin(interface,parametros,NULL);
	1319	if(herror){
	1320	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
	1321	errorInfo(modulo,msglog);
	1322	muestraMensaje(29,NULL);// Ha habido algún error en el proceso de creación de imagen básica
	1323	}
	1324	else
	1325	muestraMensaje(28,NULL);// El proceso de creación de imagen básica ha terminado correctamente
	1326	//}
	1327	//else{
	1328	// sprintf(msglog,"%s:%s",tbErrores[86],nfn);
	1329	// errorInfo(modulo,msglog);
	1330	//}
	1331
	1332	ids=copiaParametro("ids",ptrTrama); // Identificador de la sesión
	1333
	1334	/* Envia respuesta de ejecución de la función de interface */
	1335	initParametros(ptrTrama,0);
	1336	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_CrearImagenBasica");
	1337	lon+=sprintf(ptrTrama->parametros+lon,"idi=%s\r",idi); // Identificador de la imagen
	1338	lon+=sprintf(ptrTrama->parametros+lon,"par=%s\r",par); // Número de partición de donde se creó
	1339	lon+=sprintf(ptrTrama->parametros+lon,"cpt=%s\r",cpt); // Tipo o código de partición
	1340	lon+=sprintf(ptrTrama->parametros+lon,"ipr=%s\r",ipr); // Ip del repositorio donde se alojó
	1341	respuestaEjecucionComando(ptrTrama,herror,ids);
	1342
	1343	liberaMemoria(nfn);
	1344	liberaMemoria(dsk);
	1345	liberaMemoria(par);
	1346	liberaMemoria(cpt);
	1347	liberaMemoria(idi);
	1348	liberaMemoria(nci);
	1349	liberaMemoria(rti);
	1350	liberaMemoria(ipr);
	1351	liberaMemoria(bpi);
	1352	liberaMemoria(cpc);
	1353	liberaMemoria(bpc);
	1354	liberaMemoria(nba);
	1355	liberaMemoria(ids);
	1356
[380fe92]	1357	muestraMenu();
	1358
[4329e85]	1359	return(TRUE);
	1360	}
	1361	//______________________________________________________________________________________________________
	1362	// Función: CrearSoftIncremental
	1363	//
	1364	// Descripción:
	1365	// Crea una software incremental comparando una partición con una imagen básica
	1366	// Parámetros:
	1367	// ptrTrama: contenido del mensaje
	1368	//
	1369	// Devuelve:
	1370	// TRUE: Si el proceso es correcto
	1371	// FALSE: En caso de ocurrir algún error
	1372	//______________________________________________________________________________________________________
	1373	BOOLEAN CrearSoftIncremental(TRAMA* ptrTrama)
	1374	{
	1375	int lon;
	1376	char nfn,dsk,par,idi,idf,ipr,nci,rti,ncf,bpi,cpc,bpc,nba,ids,msglog[LONSTD];
	1377	char modulo[] = "CrearSoftIncremental()";
	1378
	1379	if (ndebug>=DEBUG_MAXIMO) {
	1380	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
	1381	infoDebug(msglog);
	1382	}
	1383	nfn=copiaParametro("nfn",ptrTrama);
	1384
	1385	dsk=copiaParametro("dsk",ptrTrama); // Disco
	1386	par=copiaParametro("par",ptrTrama); // Número de partición
	1387	idi=copiaParametro("idi",ptrTrama); // Identificador de la imagen
	1388	nci=copiaParametro("nci",ptrTrama); // Nombre canónico de la imagen
	1389	rti=copiaParametro("rti",ptrTrama); // Ruta de origen de la imagen
	1390	ipr=copiaParametro("ipr",ptrTrama); // Ip del repositorio
	1391	idf=copiaParametro("idf",ptrTrama); // Identificador de la imagen diferencial
	1392	ncf=copiaParametro("ncf",ptrTrama); // Nombre canónico de la imagen diferencial
	1393	bpi=copiaParametro("bpi",ptrTrama); // Borrar la imagen antes de crearla
	1394	cpc=copiaParametro("cpc",ptrTrama); // Copiar también imagen a la cache
	1395	bpc=copiaParametro("bpc",ptrTrama); // Borrarla de la cache antes de copiarla en ella
	1396	nba=copiaParametro("nba",ptrTrama); // No borrar archivos en destino
	1397
	1398	// muestraMensaje(7,NULL); // Creando Inventario Software
	1399	// if(InventariandoSoftware(ptrTrama,FALSE,"InventarioSoftware")){ // Crea inventario Software previamente
	1400	muestraMensaje(25,NULL);// Creando Imagen Incremental, por favor espere...
	1401	sprintf(interface,"%s/%s",pathinterface,nfn);
	1402	sprintf(parametros,"%s %s %s %s %s %s %s%s%s%s %s",nfn,dsk,par,nci,ipr,ncf,bpi,cpc,bpc,nba,rti);
	1403	herror=interfaceAdmin(interface,parametros,NULL);
	1404	if(herror){
	1405	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
	1406	errorInfo(modulo,msglog);
	1407	muestraMensaje(27,NULL);// Ha habido algún error en el proceso de creación de imagen básica
	1408	}
	1409	else
	1410	muestraMensaje(26,NULL);// El proceso de creación de imagen básica ha terminado correctamente
	1411	// }
	1412	// else{
	1413	// sprintf(msglog,"%s:%s",tbErrores[86],nfn);
	1414	// errorInfo(modulo,msglog);
	1415	// }
	1416
	1417	ids=copiaParametro("ids",ptrTrama); // Identificador de la sesión
	1418
	1419	/* Envia respuesta de ejecución de la función de interface */
	1420	initParametros(ptrTrama,0);
	1421	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_CrearSoftIncremental");
	1422	lon+=sprintf(ptrTrama->parametros+lon,"idf=%s\r",idf); // Identificador de la imagen incremental
	1423	lon+=sprintf(ptrTrama->parametros+lon,"par=%s\r",par); // Número de partición
	1424	respuestaEjecucionComando(ptrTrama,herror,ids);
	1425
	1426	liberaMemoria(nfn);
	1427	liberaMemoria(dsk);
	1428	liberaMemoria(par);
	1429	liberaMemoria(idi);
	1430	liberaMemoria(nci);
	1431	liberaMemoria(rti);
	1432	liberaMemoria(ipr);
	1433	liberaMemoria(idf);
	1434	liberaMemoria(ncf);
	1435	liberaMemoria(bpi);
	1436	liberaMemoria(cpc);
	1437	liberaMemoria(bpc);
	1438	liberaMemoria(nba);
	1439	liberaMemoria(ids);
	1440
[380fe92]	1441	muestraMenu();
	1442
[3ec149c]	1443	return(TRUE);
	1444	}
	1445	//______________________________________________________________________________________________________
	1446	// Función: RestaurarImagen
	1447	//
	1448	// Descripción:
	1449	// Restaura una imagen en una partición
	1450	// Parámetros:
	1451	// ptrTrama: contenido del mensaje
	1452	// Devuelve:
	1453	// TRUE: Si el proceso es correcto
[4329e85]	1454	// FALSE: En bpccaso de ocurrir algún error
[3ec149c]	1455	//______________________________________________________________________________________________________
	1456	BOOLEAN RestaurarImagen(TRAMA* ptrTrama)
	1457	{
	1458	int lon;
	1459	char nfn,dsk,par,idi,ipr,ifs,nci,ids,*ptc,msglog[LONSTD];
	1460	char modulo[] = "RestaurarImagen()";
	1461
	1462	if (ndebug>=DEBUG_MAXIMO) {
	1463	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
	1464	infoDebug(msglog);
	1465	}
	1466
	1467	dsk=copiaParametro("dsk",ptrTrama);
	1468	par=copiaParametro("par",ptrTrama);
	1469	idi=copiaParametro("idi",ptrTrama);
	1470	ipr=copiaParametro("ipr",ptrTrama);
	1471	nci=copiaParametro("nci",ptrTrama);
	1472	ifs=copiaParametro("ifs",ptrTrama);
	1473	ptc=copiaParametro("ptc",ptrTrama);
	1474
	1475	nfn=copiaParametro("nfn",ptrTrama);
	1476	ids=copiaParametro("ids",ptrTrama);
	1477	muestraMensaje(3,NULL);
	1478	sprintf(interface,"%s/%s",pathinterface,nfn);
[eb9424f]	1479	sprintf(parametros,"%s %s %s %s %s %s",nfn,dsk,par,nci,ipr,ptc);
[3ec149c]	1480	herror=interfaceAdmin(interface,parametros,NULL);
	1481	if(herror){
	1482	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
	1483	errorInfo(modulo,msglog);
	1484	muestraMensaje(12,NULL);
	1485	}
	1486	else
	1487	muestraMensaje(11,NULL);
	1488
	1489
	1490	/* Envia respuesta de ejecución de la función de interface */
	1491	initParametros(ptrTrama,0);
	1492	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_RestaurarImagen");
	1493	lon+=sprintf(ptrTrama->parametros+lon,"idi=%s\r",idi); // Identificador de la imagen
	1494	lon+=sprintf(ptrTrama->parametros+lon,"par=%s\r",par); // Número de partición
	1495	lon+=sprintf(ptrTrama->parametros+lon,"ifs=%s\r",ifs); // Identificador del perfil software
	1496	respuestaEjecucionComando(ptrTrama,herror,ids);
[4329e85]	1497
	1498	liberaMemoria(nfn);
	1499	liberaMemoria(dsk);
	1500	liberaMemoria(par);
	1501	liberaMemoria(idi);
	1502	liberaMemoria(nci);
	1503	liberaMemoria(ipr);
	1504	liberaMemoria(ifs);
	1505	liberaMemoria(ptc);
	1506	liberaMemoria(ids);
	1507
[380fe92]	1508	muestraMenu();
	1509
[4329e85]	1510	return(TRUE);
	1511	}
	1512	//______________________________________________________________________________________________________
	1513	// Función: RestaurarImagenBasica
	1514	//
	1515	// Descripción:
	1516	// Restaura una imagen básica en una partición
	1517	// Parámetros:
	1518	// ptrTrama: contenido del mensaje
	1519	// Devuelve:
	1520	// TRUE: Si el proceso es correcto
	1521	// FALSE: En caso de ocurrir algún error
	1522	//______________________________________________________________________________________________________
	1523	BOOLEAN RestaurarImagenBasica(TRAMA* ptrTrama)
	1524	{
	1525	int lon;
	1526	char nfn,dsk,par,idi,ipr,met,nci,rti,ifs,bpi,cpc,bpc,nba,ids,msglog[LONSTD];
	1527	char modulo[] = "RestaurarImagenBasica()";
	1528
	1529	if (ndebug>=DEBUG_MAXIMO) {
	1530	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
	1531	infoDebug(msglog);
	1532	}
	1533	dsk=copiaParametro("dsk",ptrTrama);
	1534	par=copiaParametro("par",ptrTrama);
	1535	idi=copiaParametro("idi",ptrTrama);
	1536	ipr=copiaParametro("ipr",ptrTrama);
	1537	met=copiaParametro("met",ptrTrama); // Método de clonación 0= desde caché 1= desde repositorio
	1538	nci=copiaParametro("nci",ptrTrama);
	1539	rti=copiaParametro("rti",ptrTrama); // Ruta de origen de la imagen
	1540	ifs=copiaParametro("ifs",ptrTrama);
	1541	bpi=copiaParametro("bpi",ptrTrama); // Borrar la imagen antes de crearla
	1542	cpc=copiaParametro("cpc",ptrTrama); // Copiar también imagen a la cache
	1543	bpc=copiaParametro("bpc",ptrTrama); // Borrarla de la cache antes de copiarla en ella
	1544	nba=copiaParametro("nba",ptrTrama); // No borrar archivos en destino
	1545
	1546	nfn=copiaParametro("nfn",ptrTrama);
	1547	ids=copiaParametro("ids",ptrTrama);
	1548	muestraMensaje(31,NULL);
	1549	sprintf(interface,"%s/%s",pathinterface,nfn);
	1550	sprintf(parametros,"%s %s %s %s %s %s%s%s%s %s %s",nfn,dsk,par,nci,ipr,bpi,cpc,bpc,nba,met,rti);
	1551	herror=interfaceAdmin(interface,parametros,NULL);
	1552	if(herror){
	1553	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
	1554	errorInfo(modulo,msglog);
	1555	muestraMensaje(33,NULL);
	1556	}
	1557	else
	1558	muestraMensaje(32,NULL);
	1559
	1560	/* Envia respuesta de ejecución de la función de interface */
	1561	initParametros(ptrTrama,0);
	1562	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_RestaurarImagenBasica");
	1563	lon+=sprintf(ptrTrama->parametros+lon,"idi=%s\r",idi); // Identificador de la imagen
	1564	lon+=sprintf(ptrTrama->parametros+lon,"par=%s\r",par); // Número de partición
	1565	lon+=sprintf(ptrTrama->parametros+lon,"ifs=%s\r",ifs); // Identificador del perfil software
	1566	respuestaEjecucionComando(ptrTrama,herror,ids);
	1567
	1568	liberaMemoria(nfn);
	1569	liberaMemoria(dsk);
	1570	liberaMemoria(par);
	1571	liberaMemoria(idi);
	1572	liberaMemoria(nci);
	1573	liberaMemoria(rti);
	1574	liberaMemoria(ifs);
	1575	liberaMemoria(ipr);
	1576	liberaMemoria(met);
	1577	liberaMemoria(bpi);
	1578	liberaMemoria(cpc);
	1579	liberaMemoria(bpc);
	1580	liberaMemoria(nba);
	1581	liberaMemoria(ids);
[380fe92]	1582
	1583	muestraMenu();
[4329e85]	1584
	1585	return(TRUE);
	1586	}
	1587	//______________________________________________________________________________________________________
	1588	// Función: RestaurarSoftIncremental
	1589	//
	1590	// Descripción:
	1591	// Restaura software incremental en una partición
	1592	// Parámetros:
	1593	// ptrTrama: contenido del mensaje
	1594	// Devuelve:
	1595	// TRUE: Si el proceso es correcto
	1596	// FALSE: En caso de ocurrir algún error
	1597	//______________________________________________________________________________________________________
	1598	BOOLEAN RestaurarSoftIncremental(TRAMA* ptrTrama)
	1599	{
	1600	int lon;
	1601	char nfn,dsk,par,idi,ipr,met,ifs,nci,rti,idf,ncf,bpi,cpc,bpc,nba,ids,msglog[LONSTD];
	1602	char modulo[] = "RestaurarSoftIncremental()";
	1603
	1604	if (ndebug>=DEBUG_MAXIMO) {
	1605	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
	1606	infoDebug(msglog);
	1607	}
	1608	dsk=copiaParametro("dsk",ptrTrama);
	1609	par=copiaParametro("par",ptrTrama);
	1610	idi=copiaParametro("idi",ptrTrama);
	1611	idf=copiaParametro("idf",ptrTrama);
	1612	ipr=copiaParametro("ipr",ptrTrama);
	1613	met=copiaParametro("met",ptrTrama); // Método de clonación 0= desde caché 1= desde repositorio
	1614	ifs=copiaParametro("ifs",ptrTrama);
	1615	nci=copiaParametro("nci",ptrTrama);
	1616	rti=copiaParametro("rti",ptrTrama); // Ruta de origen de la imagen
	1617	ncf=copiaParametro("ncf",ptrTrama);
	1618	bpi=copiaParametro("bpi",ptrTrama); // Borrar la imagen antes de crearla
	1619	cpc=copiaParametro("cpc",ptrTrama); // Copiar también imagen a la cache
	1620	bpc=copiaParametro("bpc",ptrTrama); // Borrarla de la cache antes de copiarla en ella
	1621	nba=copiaParametro("nba",ptrTrama); // No borrar archivos en destino
	1622
	1623	nfn=copiaParametro("nfn",ptrTrama);
	1624	ids=copiaParametro("ids",ptrTrama);
	1625	muestraMensaje(31,NULL);
	1626	sprintf(interface,"%s/%s",pathinterface,nfn);
	1627	sprintf(parametros,"%s %s %s %s %s %s %s%s%s%s %s %s",nfn,dsk,par,nci,ipr,ncf,bpi,cpc,bpc,nba,met,rti);
	1628	herror=interfaceAdmin(interface,parametros,NULL);
	1629	if(herror){
	1630	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
	1631	errorInfo(modulo,msglog);
	1632	muestraMensaje(35,NULL);
	1633	}
	1634	else
	1635	muestraMensaje(34,NULL);
	1636
	1637	/* Envia respuesta de ejecución de la función de interface */
	1638	initParametros(ptrTrama,0);
	1639	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_RestaurarSoftIncremental");
	1640	lon+=sprintf(ptrTrama->parametros+lon,"idi=%s\r",idf); // Identificador de la imagen incremental (Forzada a idi)
	1641	lon+=sprintf(ptrTrama->parametros+lon,"par=%s\r",par); // Número de partición
	1642	lon+=sprintf(ptrTrama->parametros+lon,"ifs=%s\r",ifs); // Identificador del perfil software
	1643
	1644	respuestaEjecucionComando(ptrTrama,herror,ids);
	1645
	1646	liberaMemoria(nfn);
	1647	liberaMemoria(dsk);
	1648	liberaMemoria(par);
	1649	liberaMemoria(idi);
	1650	liberaMemoria(idf);
	1651	liberaMemoria(nci);
	1652	liberaMemoria(rti);
	1653	liberaMemoria(ncf);
	1654	liberaMemoria(ifs);
	1655	liberaMemoria(ipr);
	1656	liberaMemoria(met);
	1657	liberaMemoria(bpi);
	1658	liberaMemoria(cpc);
	1659	liberaMemoria(bpc);
	1660	liberaMemoria(nba);
	1661	liberaMemoria(ids);
	1662
[380fe92]	1663	muestraMenu();
	1664
[3ec149c]	1665	return(TRUE);
	1666	}
	1667	//______________________________________________________________________________________________________
	1668	// Función: Configurar
	1669	//
	1670	// Descripción:
	1671	// Configura la tabla de particiones y formatea
	1672	// Parámetros:
	1673	// ptrTrama: contenido del mensaje
	1674	// Devuelve:
	1675	// TRUE: Si el proceso es correcto
	1676	// FALSE: En caso de ocurrir algún error
	1677	//______________________________________________________________________________________________________
	1678	BOOLEAN Configurar(TRAMA* ptrTrama)
	1679	{
	1680	int lon;
	1681	char nfn,dsk,cfg,ids,msglog[LONSTD];
	1682	char modulo[] = "Configurar()";
	1683
	1684	if (ndebug>=DEBUG_MAXIMO) {
	1685	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
	1686	infoDebug(msglog);
	1687	}
	1688
	1689	dsk=copiaParametro("dsk",ptrTrama);
	1690	cfg=copiaParametro("cfg",ptrTrama);
	1691	/* Sustituir caracteres */
	1692	sustituir(cfg,'\n','$');
	1693	sustituir(cfg,'\t','#');
	1694
	1695	nfn=copiaParametro("nfn",ptrTrama);
	1696	ids=copiaParametro("ids",ptrTrama);
	1697	muestraMensaje(4,NULL);
	1698	sprintf(interface,"%s/%s",pathinterface,nfn);
[44912ec5]	1699	sprintf(parametros,"%s %s %s",nfn,dsk,cfg);
[3ec149c]	1700
	1701	herror=interfaceAdmin(interface,parametros,NULL);
	1702	if(herror){
	1703	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
	1704	errorInfo(modulo,msglog);
	1705	muestraMensaje(13,NULL);
	1706	}
	1707	else
	1708	muestraMensaje(14,NULL);
	1709
[9ef26af]	1710	cfg=LeeConfiguracion();
[3ec149c]	1711	if(!cfg){ // No se puede recuperar la configuración del cliente
	1712	errorLog(modulo,36,FALSE);
	1713	return(FALSE);
	1714	}
	1715
	1716	/* Envia respuesta de ejecución del comando*/
	1717	initParametros(ptrTrama,0);
	1718	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_Configurar");
[7224a0a]	1719	lon+=sprintf(ptrTrama->parametros+lon,"cfg=%s\r",cfg); // Configuración de los Sistemas Operativos del cliente
[3ec149c]	1720	respuestaEjecucionComando(ptrTrama,herror,ids);
[4329e85]	1721
	1722	liberaMemoria(dsk);
	1723	liberaMemoria(cfg);
	1724	liberaMemoria(nfn);
	1725	liberaMemoria(ids);
	1726
[380fe92]	1727	muestraMenu();
	1728
[3ec149c]	1729	return(TRUE);
	1730	}
	1731	// ________________________________________________________________________________________________________
	1732	// Función: InventarioHardware
	1733	//
	1734	// Descripción:
	1735	// Envia al servidor el nombre del archivo de inventario de su hardware para posteriormente
	1736	// esperar que éste lo solicite y enviarlo por la red.
	1737	// Parámetros:
	1738	// ptrTrama: contenido del mensaje
	1739	// Devuelve:
	1740	// TRUE: Si el proceso es correcto
	1741	// FALSE: En caso de ocurrir algún error
	1742	//______________________________________________________________________________________________________
	1743	BOOLEAN InventarioHardware(TRAMA* ptrTrama)
	1744	{
	1745	int lon;
	1746	SOCKET socket_c;
	1747	char nfn,ids,msglog[LONSTD],hrdsrc[LONPRM],hrddst[LONPRM];
	1748	char modulo[] = "InventarioHardware()";
	1749
	1750	if (ndebug>=DEBUG_MAXIMO) {
	1751	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
	1752	infoDebug(msglog);
	1753	}
	1754
	1755	nfn=copiaParametro("nfn",ptrTrama);
	1756	ids=copiaParametro("ids",ptrTrama);
	1757	muestraMensaje(6,NULL);
	1758
	1759	sprintf(interface,"%s/%s",pathinterface,nfn);
	1760	sprintf(hrdsrc,"/tmp/Chrd-%s",IPlocal); // Nombre que tendra el archivo de inventario
	1761	sprintf(parametros,"%s %s",nfn,hrdsrc);
	1762	herror=interfaceAdmin(interface,parametros,NULL);
	1763	if(herror){
	1764	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
	1765	errorInfo(modulo,msglog);
	1766	muestraMensaje(18,NULL);
	1767	}
	1768	else{
	1769	/* Envía fichero de inventario al servidor */
	1770	sprintf(hrddst,"/tmp/Shrd-%s",IPlocal); // Nombre que tendra el archivo en el Servidor
	1771	initParametros(ptrTrama,0);
	1772	sprintf(ptrTrama->parametros,"nfn=recibeArchivo\rnfl=%s\r",hrddst);
	1773	if(!enviaMensajeServidor(&socket_c,ptrTrama,MSG_COMANDO)){
[4329e85]	1774	liberaMemoria(nfn);
	1775	liberaMemoria(ids);
[3ec149c]	1776	errorLog(modulo,42,FALSE);
	1777	return(FALSE);
	1778	}
	1779	/* Espera señal para comenzar el envío */
[4329e85]	1780	liberaMemoria(ptrTrama);
[3ec149c]	1781	recibeFlag(&socket_c,ptrTrama);
	1782	/* Envía archivo */
	1783	if(!sendArchivo(&socket_c,hrdsrc)){
	1784	errorLog(modulo,57, FALSE);
	1785	herror=12; // Error de envío de fichero por la red
	1786	}
	1787	close(socket_c);
	1788	muestraMensaje(17,NULL);
	1789	}
	1790
	1791	/* Envia respuesta de ejecución de la función de interface */
	1792	initParametros(ptrTrama,0);
	1793	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_InventarioHardware");
	1794	lon+=sprintf(ptrTrama->parametros+lon,"hrd=%s\r",hrddst);
	1795	respuestaEjecucionComando(ptrTrama,herror,ids);
[4329e85]	1796	liberaMemoria(nfn);
[380fe92]	1797	liberaMemoria(ids);
	1798
	1799	muestraMenu();
	1800
[3ec149c]	1801	return(TRUE);
	1802	}
	1803	// ________________________________________________________________________________________________________
	1804	// Función: InventarioSoftware
	1805	//
	1806	// Descripción:
	1807	// Crea el inventario software de un sistema operativo instalado en una partición.
	1808	// Parámetros:
	1809	// ptrTrama: contenido del mensaje
	1810	// Devuelve:
	1811	// TRUE: Si el proceso es correcto
	1812	// FALSE: En caso de ocurrir algún error
	1813	//______________________________________________________________________________________________________
	1814	BOOLEAN InventarioSoftware(TRAMA* ptrTrama)
	1815	{
	1816	char nfn,ids,msglog[LONSTD];
	1817	char modulo[] = "InventarioSoftware()";
	1818
	1819	if (ndebug>=DEBUG_MAXIMO) {
	1820	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
	1821	infoDebug(msglog);
	1822	}
	1823	nfn=copiaParametro("nfn",ptrTrama);
	1824	ids=copiaParametro("ids",ptrTrama);
	1825	muestraMensaje(7,NULL);
	1826	InventariandoSoftware(ptrTrama,TRUE,nfn);
	1827	respuestaEjecucionComando(ptrTrama,herror,ids);
[4329e85]	1828	liberaMemoria(nfn);
	1829	liberaMemoria(ids);
[3ec149c]	1830	muestraMenu();
	1831	return(TRUE);
	1832	}
	1833	// ________________________________________________________________________________________________________
	1834	//
	1835	// Función: InventariandoSoftware
	1836	//
	1837	// Descripción:
	1838	// Envia al servidor el nombre del archivo de inventario de su software para posteriormente
	1839	// esperar que éste lo solicite y enviarlo por la red.
	1840	// Parámetros:
	1841	// ptrTrama: contenido del mensaje
	1842	// sw: switch que indica si la función es llamada por el comando InventarioSoftware(true) o CrearImagen(false)
	1843	// nfn: Nombre de la función del Interface que implementa el comando
	1844	// Devuelve:
	1845	// TRUE: Si el proceso es correcto
	1846	// FALSE: En caso de ocurrir algún error
	1847	//______________________________________________________________________________________________________
	1848	BOOLEAN InventariandoSoftware(TRAMA* ptrTrama,BOOLEAN sw,char *nfn)
	1849	{
	1850	int lon;
	1851	SOCKET socket_c;
	1852	char dsk,par,msglog[LONSTD],sftsrc[LONPRM],sftdst[LONPRM];
	1853	char modulo[] = "InventariandoSoftware()";
	1854
	1855	dsk=copiaParametro("dsk",ptrTrama); // Disco
	1856	par=copiaParametro("par",ptrTrama);
	1857
	1858	sprintf(interface,"%s/%s",pathinterface,nfn);
	1859	sprintf(sftsrc,"/tmp/CSft-%s-%s",IPlocal,par); // Nombre que tendra el archivo de inventario
	1860	sprintf(parametros,"%s %s %s %s",nfn,dsk,par,sftsrc);
	1861
	1862	herror=interfaceAdmin(interface,parametros,NULL);
	1863	herror=0;
	1864	if(herror){
	1865	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
	1866	errorInfo(modulo,msglog);
	1867	muestraMensaje(20,NULL);
	1868	}
	1869	else{
	1870	/* Envía fichero de inventario al servidor */
	1871	sprintf(sftdst,"/tmp/Ssft-%s-%s",IPlocal,par); // Nombre que tendra el archivo en el Servidor
	1872	initParametros(ptrTrama,0);
	1873
	1874	sprintf(ptrTrama->parametros,"nfn=recibeArchivo\rnfl=%s\r",sftdst);
	1875	if(!enviaMensajeServidor(&socket_c,ptrTrama,MSG_COMANDO)){
	1876	errorLog(modulo,42,FALSE);
[4329e85]	1877	liberaMemoria(dsk);
	1878	liberaMemoria(par);
[3ec149c]	1879	return(FALSE);
	1880	}
	1881	/* Espera señal para comenzar el envío */
[4329e85]	1882	liberaMemoria(ptrTrama);
[3ec149c]	1883	if(!recibeFlag(&socket_c,ptrTrama)){
	1884	errorLog(modulo,17,FALSE);
	1885	}
	1886	/* Envía archivo */
	1887	if(!sendArchivo(&socket_c,sftsrc)){
	1888	errorLog(modulo,57, FALSE);
	1889	herror=12; // Error de envío de fichero por la red
	1890	}
	1891	close(socket_c);
	1892	muestraMensaje(19,NULL);
	1893	}
	1894	initParametros(ptrTrama,0);
	1895	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_InventarioSoftware");
	1896	lon+=sprintf(ptrTrama->parametros+lon,"par=%s\r",par);
	1897	lon+=sprintf(ptrTrama->parametros+lon,"sft=%s\r",sftdst);
	1898	if(!sw)
	1899	respuestaEjecucionComando(ptrTrama,herror,"0");
	1900
[4329e85]	1901	liberaMemoria(dsk);
	1902	liberaMemoria(par);
[3ec149c]	1903	return(TRUE);
	1904	}
	1905	// ________________________________________________________________________________________________________
	1906	// Función: EjecutarScript
	1907	//
	1908	// Descripción:
	1909	// Ejecuta código de script
	1910	// Parámetros:
	1911	// ptrTrama: contenido del mensaje
	1912	// Devuelve:
	1913	// TRUE: Si el proceso es correcto
	1914	// FALSE: En caso de ocurrir algún error
	1915	//______________________________________________________________________________________________________
	1916	BOOLEAN EjecutarScript(TRAMA* ptrTrama)
	1917	{
	1918	int lon;
[7224a0a]	1919	char nfn,aux,ids,scp,*cfg,msglog[LONSTD];
[3ec149c]	1920	char modulo[] = "EjecutarScript()";
	1921
	1922	if (ndebug>=DEBUG_MAXIMO) {
	1923	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
	1924	infoDebug(msglog);
	1925	}
[4329e85]	1926	aux=copiaParametro("scp",ptrTrama);
	1927	scp=URLDecode(aux);
[3ec149c]	1928	muestraMensaje(8,NULL);
	1929	/* Nombre del archivo de script */
	1930	char filescript[LONPRM];
	1931	sprintf(filescript,"/tmp/_script_%s",IPlocal);
	1932	escribeArchivo(filescript,scp);
[4329e85]	1933	nfn=copiaParametro("nfn",ptrTrama);
[3ec149c]	1934	sprintf(interface,"%s/%s",pathinterface,nfn);
	1935	sprintf(parametros,"%s %s",nfn,filescript);
	1936	herror=interfaceAdmin(interface,parametros,NULL);
	1937	if(herror){
	1938	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
	1939	errorInfo(modulo,msglog);
	1940	muestraMensaje(21,NULL);
	1941	}
	1942	else
	1943	muestraMensaje(22,NULL);
[7224a0a]	1944
	1945	// Toma configuración de particiones
[9ef26af]	1946	cfg=LeeConfiguracion();
[7224a0a]	1947	if(!cfg){ // No se puede recuperar la configuración del cliente
	1948	errorLog(modulo,36,FALSE);
	1949	herror=36;
	1950	}
	1951
	1952	ids=copiaParametro("ids",ptrTrama);
	1953
[3ec149c]	1954	//herror=ejecutarCodigoBash(scp);
	1955	initParametros(ptrTrama,0);
	1956	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_EjecutarScript");
[7224a0a]	1957	lon+=sprintf(ptrTrama->parametros+lon,"cfg=%s\r",cfg); // Configuración de los Sistemas Operativos del cliente
[3ec149c]	1958	respuestaEjecucionComando(ptrTrama,herror,ids);
[4329e85]	1959
	1960	liberaMemoria(nfn);
	1961	liberaMemoria(ids);
	1962	liberaMemoria(aux);
[7224a0a]	1963	liberaMemoria(scp);
	1964	liberaMemoria(cfg);
[380fe92]	1965
	1966	muestraMenu();
	1967
[3ec149c]	1968	return(TRUE);
	1969	}
	1970	//______________________________________________________________________________________________________
	1971	// Función: respuestaEjecucionComando
	1972	//
	1973	// Descripción:
	1974	// Envia una respuesta a una ejecucion de comando al servidor de Administración
	1975	// Parámetros:
	1976	// - ptrTrama: contenido del mensaje
	1977	// - res: Resultado de la ejecución (Código de error devuelto por el script ejecutado)
	1978	// - ids: Identificador de la sesion (En caso de no haber seguimiento es NULO)
	1979	// Devuelve:
	1980	// TRUE: Si el proceso es correcto
	1981	// FALSE: En caso de ocurrir algún error
	1982	// ________________________________________________________________________________________________________
	1983	BOOLEAN respuestaEjecucionComando(TRAMA* ptrTrama,int res,char *ids)
	1984	{
	1985	int lon;
	1986	SOCKET socket_c;
	1987	char modulo[] = "respuestaEjecucionComando()";
	1988
	1989	lon=strlen(ptrTrama->parametros);
	1990	if(ids){ // Existe seguimiento
	1991	lon+=sprintf(ptrTrama->parametros+lon,"ids=%s\r",ids); // Añade identificador de la sesión
	1992	}
	1993	if (res==0){ // Resultado satisfactorio
	1994	lon+=sprintf(ptrTrama->parametros+lon,"res=%s\r","1");
	1995	lon+=sprintf(ptrTrama->parametros+lon,"der=%s\r","");
	1996	}
	1997	else{ // Algún error
	1998	lon+=sprintf(ptrTrama->parametros+lon,"res=%s\r","2");
	1999	if(res>MAXERRORSCRIPT)
[4329e85]	2000	lon+=sprintf(ptrTrama->parametros+lon,"der=%s (Error de script:%d)\r",tbErroresScripts[0],res);// Descripción del error
[3ec149c]	2001	else
	2002	lon+=sprintf(ptrTrama->parametros+lon,"der=%s\r",tbErroresScripts[res]);// Descripción del error
	2003	}
	2004	if(!(enviaMensajeServidor(&socket_c,ptrTrama,MSG_NOTIFICACION))){
	2005	errorLog(modulo,44,FALSE);
	2006	return(FALSE);
	2007	}
[eeeb98a]	2008
[3ec149c]	2009	close(socket_c);
	2010	return(TRUE);
	2011	}
	2012	// ________________________________________________________________________________________________________
	2013	// Función: gestionaTrama
	2014	//
	2015	// Descripción:
	2016	// Procesa las tramas recibidas.
	2017	// Parametros:
	2018	// ptrTrama: contenido del mensaje
	2019	// Devuelve:
	2020	// TRUE: Si el proceso es correcto
	2021	// FALSE: En caso de ocurrir algún error
	2022	// ________________________________________________________________________________________________________
	2023	BOOLEAN gestionaTrama(TRAMA *ptrTrama)
	2024	{
	2025	int i, res;
	2026	char *nfn;
	2027	char modulo[] = "gestionaTrama()";
	2028
	2029	INTROaFINCAD(ptrTrama);
	2030	nfn = copiaParametro("nfn", ptrTrama); // Toma nombre de función
	2031	for (i = 0; i < MAXIMAS_FUNCIONES; i++) { // Recorre funciones que procesan las tramas
	2032	res = strcmp(tbfuncionesClient[i].nf, nfn);
	2033	if (res == 0) { // Encontrada la función que procesa el mensaje
[4329e85]	2034	liberaMemoria(nfn);
[3ec149c]	2035	return(tbfuncionesClient[i].fptr(ptrTrama)); // Invoca la función
	2036	}
	2037	}
[4329e85]	2038
	2039	liberaMemoria(nfn);
	2040
	2041	/* Sólo puede ser un comando personalizado
[3ec149c]	2042	if (ptrTrama->tipo==MSG_COMANDO)
	2043	return(Comando(ptrTrama));
[4329e85]	2044	*/
[3ec149c]	2045	errorLog(modulo, 18, FALSE);
	2046	return (FALSE);
	2047	}
	2048	//________________________________________________________________________________________________________
	2049	// Función: ejecutaArchivo
	2050	//
	2051	// Descripción:
	2052	// Ejecuta los comando contenido en un archivo (cada comando y sus parametros separados por un
	2053	// salto de linea.
	2054	// Parámetros:
	2055	// filecmd: Nombre del archivo de comandos
	2056	// ptrTrama: Puntero a una estructura TRAMA usada en las comunicaciones por red (No debe ser NULL)
	2057	// Devuelve:
	2058	// TRUE: Si el proceso es correcto
	2059	// FALSE: En caso de ocurrir algún error
	2060	//________________________________________________________________________________________________________
	2061	BOOLEAN ejecutaArchivo(char* filecmd,TRAMA *ptrTrama)
	2062	{
	2063	char* buffer,*lineas[MAXIMAS_LINEAS];
	2064	int i,numlin;
	2065	char modulo[] = "ejecutaArchivo()";
	2066
	2067	buffer=leeArchivo(filecmd);
	2068	if(buffer){
	2069	numlin = splitCadena(lineas, buffer, '@');
	2070	initParametros(ptrTrama,0);
	2071	for (i = 0; i < numlin; i++) {
	2072	if(strlen(lineas[i])>0){
	2073	strcpy(ptrTrama->parametros,lineas[i]);
	2074	strcat(ptrTrama->parametros,"\rMCDJ@"); // Fin de trama
	2075	if(!gestionaTrama(ptrTrama)){ // Análisis de la trama
	2076	errorLog(modulo,39,FALSE);
	2077	//return(FALSE);
	2078	}
	2079	}
	2080	}
	2081	}
[4329e85]	2082	liberaMemoria(buffer);
[3ec149c]	2083	return(TRUE);
	2084	}
	2085	//______________________________________________________________________________________________________
	2086	// Función: enviaMensajeServidor
	2087	//
	2088	// Descripción:
	2089	// Envia un mensaje al servidor de Administración
	2090	// Parámetros:
	2091	// - socket_c: (Salida) Socket utilizado para el envío
	2092	// - ptrTrama: contenido del mensaje
	2093	// - tipo: Tipo de mensaje
	2094	// C=Comando, N=Respuesta a un comando, P=Peticion,R=Respuesta a una petición, I=Informacion
	2095	// Devuelve:
	2096	// TRUE: Si el proceso es correcto
	2097	// FALSE: En caso de ocurrir algún error
	2098	// ________________________________________________________________________________________________________
	2099	BOOLEAN enviaMensajeServidor(SOCKET socket_c,TRAMA ptrTrama,char tipo)
	2100	{
	2101	int lon;
	2102	char modulo[] = "enviaMensajeServidor()";
	2103
	2104	*socket_c=abreConexion();
	2105	if(*socket_c==INVALID_SOCKET){
	2106	errorLog(modulo,38,FALSE); // Error de conexión con el servidor
	2107	return(FALSE);
	2108	}
	2109	ptrTrama->arroba='@'; // Cabecera de la trama
	2110	strncpy(ptrTrama->identificador,"JMMLCAMDJ_MCDJ",14); // identificador de la trama
	2111	ptrTrama->tipo=tipo; // Tipo de mensaje
	2112	lon=strlen(ptrTrama->parametros); // Compone la trama
	2113	lon+=sprintf(ptrTrama->parametros+lon,"iph=%s\r",IPlocal); // Ip del ordenador
	2114	lon+=sprintf(ptrTrama->parametros+lon,"ido=%s\r",idordenador); // Identificador del ordenador
	2115	lon+=sprintf(ptrTrama->parametros+lon,"npc=%s\r",nombreordenador); // Nombre del ordenador
	2116	lon+=sprintf(ptrTrama->parametros+lon,"idc=%s\r",idcentro); // Identificador del centro
	2117	lon+=sprintf(ptrTrama->parametros+lon,"ida=%s\r",idaula); // Identificador del aula
	2118
	2119	if (!mandaTrama(socket_c,ptrTrama)) {
	2120	errorLog(modulo,26,FALSE);
	2121	return (FALSE);
	2122	}
	2123	return(TRUE);
	2124	}
	2125	// ********************************************************************************************************
	2126	// PROGRAMA PRINCIPAL (CLIENTE)
	2127	// ********************************************************************************************************
	2128	int main(int argc, char *argv[])
	2129	{
	2130	TRAMA *ptrTrama;
	2131	char modulo[] = "main()";
	2132
	2133	ptrTrama=(TRAMA *)reservaMemoria(sizeof(TRAMA));
	2134	if (ptrTrama == NULL) { // No hay memoria suficiente para el bufer de las tramas
	2135	errorLog(modulo, 3, FALSE);
	2136	exit(EXIT_FAILURE);
	2137	}
	2138	/*--------------------------------------------------------------------------------------------------------
	2139	Validación de parámetros de ejecución y fichero de configuración
	2140	---------------------------------------------------------------------------------------------------------*/
	2141	if (!validacionParametros(argc, argv,3)) // Valida parámetros de ejecución
	2142	exit(EXIT_FAILURE);
	2143
	2144	if (!tomaConfiguracion(szPathFileCfg)) // Toma parametros de configuración
	2145	exit(EXIT_FAILURE);
	2146	/*--------------------------------------------------------------------------------------------------------
	2147	Carga catálogo de funciones que procesan las tramas
	2148	---------------------------------------------------------------------------------------------------------*/
	2149	int cf = 0;
	2150
	2151	strcpy(tbfuncionesClient[cf].nf, "RESPUESTA_AutoexecCliente");
	2152	tbfuncionesClient[cf++].fptr = &RESPUESTA_AutoexecCliente;
	2153
	2154	strcpy(tbfuncionesClient[cf].nf, "RESPUESTA_InclusionCliente");
	2155	tbfuncionesClient[cf++].fptr = &RESPUESTA_InclusionCliente;
	2156
	2157	strcpy(tbfuncionesClient[cf].nf, "NoComandosPtes");
	2158	tbfuncionesClient[cf++].fptr = &NoComandosPtes;
	2159
	2160	strcpy(tbfuncionesClient[cf].nf, "Actualizar");
	2161	tbfuncionesClient[cf++].fptr = &Actualizar;
	2162
	2163	strcpy(tbfuncionesClient[cf].nf, "Purgar");
	2164	tbfuncionesClient[cf++].fptr = &Purgar;
	2165
	2166	strcpy(tbfuncionesClient[cf].nf, "ConsolaRemota");
	2167	tbfuncionesClient[cf++].fptr = &ConsolaRemota;
	2168
	2169	strcpy(tbfuncionesClient[cf].nf, "Sondeo");
	2170	tbfuncionesClient[cf++].fptr = &Sondeo;
	2171
	2172	strcpy(tbfuncionesClient[cf].nf, "Arrancar");
	2173	tbfuncionesClient[cf++].fptr = &Arrancar;
	2174
	2175	strcpy(tbfuncionesClient[cf].nf, "Apagar");
	2176	tbfuncionesClient[cf++].fptr = &Apagar;
	2177
	2178	strcpy(tbfuncionesClient[cf].nf, "Reiniciar");
	2179	tbfuncionesClient[cf++].fptr = &Reiniciar;
	2180
	2181	strcpy(tbfuncionesClient[cf].nf, "IniciarSesion");
	2182	tbfuncionesClient[cf++].fptr = &IniciarSesion;
	2183
	2184	strcpy(tbfuncionesClient[cf].nf, "CrearImagen");
	2185	tbfuncionesClient[cf++].fptr = &CrearImagen;
	2186
[4329e85]	2187	strcpy(tbfuncionesClient[cf].nf, "CrearImagenBasica");
	2188	tbfuncionesClient[cf++].fptr = &CrearImagenBasica;
	2189
	2190	strcpy(tbfuncionesClient[cf].nf, "CrearSoftIncremental");
	2191	tbfuncionesClient[cf++].fptr = &CrearSoftIncremental;
	2192
[3ec149c]	2193	strcpy(tbfuncionesClient[cf].nf, "RestaurarImagen");
	2194	tbfuncionesClient[cf++].fptr = &RestaurarImagen;
	2195
[4329e85]	2196	strcpy(tbfuncionesClient[cf].nf, "RestaurarImagenBasica");
	2197	tbfuncionesClient[cf++].fptr = &RestaurarImagenBasica;
	2198
	2199	strcpy(tbfuncionesClient[cf].nf, "RestaurarSoftIncremental");
	2200	tbfuncionesClient[cf++].fptr = &RestaurarSoftIncremental;
	2201
	2202
[3ec149c]	2203	strcpy(tbfuncionesClient[cf].nf, "Configurar");
	2204	tbfuncionesClient[cf++].fptr = &Configurar;
	2205
	2206	strcpy(tbfuncionesClient[cf].nf, "EjecutarScript");
	2207	tbfuncionesClient[cf++].fptr = &EjecutarScript;
	2208
	2209	strcpy(tbfuncionesClient[cf].nf, "InventarioHardware");
	2210	tbfuncionesClient[cf++].fptr = &InventarioHardware;
	2211
	2212	strcpy(tbfuncionesClient[cf].nf, "InventarioSoftware");
	2213	tbfuncionesClient[cf++].fptr = &InventarioSoftware;
	2214
	2215	/*--------------------------------------------------------------------------------------------------------
	2216	Toma dirección IP del cliente
	2217	---------------------------------------------------------------------------------------------------------*/
	2218	if(!tomaIPlocal()){ // Error al recuperar la IP local
	2219	errorLog(modulo,0,FALSE);
	2220	exit(EXIT_FAILURE);
	2221	}
	2222	/*--------------------------------------------------------------------------------------------------------
	2223	Inicio de sesión
	2224	---------------------------------------------------------------------------------------------------------*/
	2225	infoLog(1); // Inicio de sesión
	2226	infoLog(3); // Abriendo sesión en el servidor de Administración;
	2227	/*--------------------------------------------------------------------------------------------------------
	2228	Inclusión del cliente en el sistema
	2229	---------------------------------------------------------------------------------------------------------*/
	2230	if(!inclusionCliente(ptrTrama)){ // Ha habido algún problema al abrir sesión
	2231	errorLog(modulo,0,FALSE);
	2232	exit(EXIT_FAILURE);
	2233	}
	2234	infoLog(4); // Cliente iniciado
	2235
	2236	/*--------------------------------------------------------------------------------------------------------
	2237	Procesamiento de la cache
	2238	---------------------------------------------------------------------------------------------------------*/
	2239	infoLog(23); // Abriendo sesión en el servidor de Administración;
	2240	if(!cuestionCache(cache)){
	2241	errorLog(modulo,0,FALSE);
	2242	exit(EXIT_FAILURE);
	2243	}
	2244	/*--------------------------------------------------------------------------------------------------------
	2245	Ejecución del autoexec
	2246	---------------------------------------------------------------------------------------------------------*/
	2247	if(atoi(idproautoexec)>0){ // Ejecución de procedimiento Autoexec
	2248	infoLog(5);
	2249	if(!autoexecCliente(ptrTrama)){ // Ejecución fichero autoexec
	2250	errorLog(modulo,0,FALSE);
	2251	exit(EXIT_FAILURE);
	2252	}
	2253	}
	2254	/*--------------------------------------------------------------------------------------------------------
	2255	Comandos pendientes
	2256	---------------------------------------------------------------------------------------------------------*/
	2257	infoLog(6); // Procesa comandos pendientes
	2258	if(!comandosPendientes(ptrTrama)){ // Ejecución de acciones pendientes
	2259	errorLog(modulo,0,FALSE);
	2260	exit(EXIT_FAILURE);
	2261	}
	2262	infoLog(7); // Acciones pendientes procesadas
	2263	/*--------------------------------------------------------------------------------------------------------
	2264	Bucle de recepción de comandos
	2265	---------------------------------------------------------------------------------------------------------*/
	2266	muestraMenu();
	2267	procesaComandos(ptrTrama); // Bucle para procesar comandos interactivos
	2268	/*--------------------------------------------------------------------------------------------------------
	2269	Fin de la sesión
	2270	---------------------------------------------------------------------------------------------------------*/
	2271	exit(EXIT_SUCCESS);
	2272	}

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

Context Navigation

source: admin/Sources/Clients/ogAdmClient/sources/ogAdmClient.c @ 91a3b4c

Download in other formats: