source: admin/Sources/Clients/ogAdmClient/sources/ogAdmClient.c @ 6d8673a

// ********************************************************************************************************
// Cliernte: ogAdmClient
// Autor: José Manuel Alonso (E.T.S.I.I.) Universidad de Sevilla
// Fecha Creación: Marzo-2010
// Fecha Última modificación: Abril-2010
// Nombre del fichero: ogAdmClient.c
// Descripción :Este fichero implementa el cliente general del sistema
// ********************************************************************************************************

#include "ogAdmClient.h"
#include "ogAdmLib.c"
//________________________________________________________________________________________________________
//      Función: tomaConfiguracion
//
//      Descripción:
//              Lee el fichero de configuración del servicio
//      Parámetros:
//              filecfg : Ruta completa al fichero de configuración
//      Devuelve:
//              TRUE: Si el proceso es correcto
//              FALSE: En caso de ocurrir algún error 
//________________________________________________________________________________________________________
BOOLEAN tomaConfiguracion(char* filecfg)
{
        char modulo[] = "tomaConfiguracion()";

        if (filecfg == NULL || strlen(filecfg) == 0) {
                errorLog(modulo, 1, FALSE); // Fichero de configuración del cliente vacío
                return (FALSE);
        }
        FILE *fcfg;
        int lSize;
        char * buffer, *lineas[MAXPRM], *dualparametro[2];
        int i, numlin, resul;

        fcfg = fopen(filecfg, "rt");
        if (fcfg == NULL) {
                errorLog(modulo, 2, FALSE); // No existe fichero de configuración del cliente
                return (FALSE);
        }

        fseek(fcfg, 0, SEEK_END);
        lSize = ftell(fcfg); // Obtiene tamaño del fichero.
        rewind(fcfg);
        buffer = (char*) reservaMemoria(lSize+1); // Toma memoria para el buffer de lectura.
        if (buffer == NULL) { // No hay memoria suficiente para el buffer
                errorLog(modulo, 3, FALSE);
                return (FALSE);
        }
        lSize=fread(buffer, 1, lSize, fcfg); // Lee contenido del fichero
        buffer[lSize]=CHARNULL;
        fclose(fcfg);

        /* Inicializar variables globales */
        servidoradm[0]=CHARNULL;
        puerto[0] = CHARNULL;
        pathinterface[0]=CHARNULL;
        urlmenu[0]=CHARNULL;
        urlmsg[0]=CHARNULL;

        numlin = splitCadena(lineas, buffer, '\n');
        for (i = 0; i < numlin; i++) {
                splitCadena(dualparametro, lineas[i], '=');

                resul = strcmp(StrToUpper(dualparametro[0]), "SERVIDORADM");
                if (resul == 0)
                        strcpy(servidoradm, dualparametro[1]);

                resul = strcmp(StrToUpper(dualparametro[0]), "PUERTO");
                if (resul == 0)
                        strcpy(puerto, dualparametro[1]);

                resul = strcmp(StrToUpper(dualparametro[0]), "PATHINTERFACE");
                if (resul == 0)
                        strcpy(pathinterface, dualparametro[1]);

                resul = strcmp(StrToUpper(dualparametro[0]), "URLMENU");
                if (resul == 0)
                        strcpy(urlmenu, dualparametro[1]);

                resul = strcmp(StrToUpper(dualparametro[0]), "URLMSG");
                if (resul == 0)
                        strcpy(urlmsg, dualparametro[1]);
        }

        if (servidoradm[0] == CHARNULL) {
                liberaMemoria(buffer);
                errorLog(modulo,4, FALSE); // Falta parámetro SERVIDORADM
                return (FALSE);
        }

        if (puerto[0] == CHARNULL) {
                liberaMemoria(buffer);
                errorLog(modulo,5, FALSE); // Falta parámetro PUERTO
                return (FALSE);
        }
        if (pathinterface[0] == CHARNULL) {
                liberaMemoria(buffer);
                errorLog(modulo,56, FALSE); // Falta parámetro PATHINTERFACE
                return (FALSE);
        }

        if (urlmenu[0] == CHARNULL) {
                liberaMemoria(buffer);
                errorLog(modulo,89, FALSE); // Falta parámetro URLMENU
                return (FALSE);
        }
        if (urlmsg[0] == CHARNULL) {
                liberaMemoria(buffer);
                errorLog(modulo,90, FALSE); // Falta parámetro URLMSG
                return (FALSE);
        }
        liberaMemoria(buffer);
        return (TRUE);
}
//______________________________________________________________________________________________________
// Función: FinterfaceAdmin
//
//       Descripción:
//              Esta función es la puerta de comunicación entre el módulo de administración y el motor de clonación.
//              La Aplicación de administración utiliza una interface para ejecutar funciones del motor de clonación;
//              esta interface llamará a la API del motor con lo que cambiando el comportamiento de esta interface
//              podremos hacer llamadas a otras API de clonación y de esta manera probar distintos motores.
//
//      Parámetros:
//              - script: Nombre del módulo,función o script de la interface
//              - parametros: Parámetros que se le pasarán a la interface
//              - salida: Recoge la salida que genera la llamada a la interface

//      Devuelve:
//              Código de error de la ejecución al módulo , función o script de la interface
//
//      Especificaciones:
//              El parámetro salida recoge la salida desde un fichero que se genera en la ejecución del script siempre que
//              sea distinto de NULL, esto es, si al llamar a la función este parámetro es NULL no se recogerá dicha salida.
//              Este fichero tiene una ubicación fija: /tmp/_retinterface
//______________________________________________________________________________________________________

int FinterfaceAdmin( char *script,char* parametros,char* salida)
{
    FILE *f;
        int lSize,nargs,i,resul;
    char msglog[LONSTD],*argumentos[MAXARGS];
        char modulo[] = "FinterfaceAdmin()";


        if (ndebug>= DEBUG_MEDIO) {
                sprintf(msglog, "%s:%s", tbMensajes[8], script);
                infoDebug(msglog);
        }

        /* Crea matriz de los argumentos */
        nargs=splitCadena(argumentos,parametros,32);
        for(i=nargs;i<MAXARGS;i++){
                argumentos[i]=NULL;
        }

        /* Muestra matriz de los argumentos */
        for(i=0;i<nargs;i++){
                if (ndebug>= DEBUG_ALTO) {
                        sprintf(msglog, "%s: #%d-%s", tbMensajes[9],i+1,argumentos[i]);
                        infoDebug(msglog);
                }
        }
        /* Elimina fichero de retorno */
        if(salida!=(char*)NULL){
                f = fopen("/tmp/_retinterface_","w" );
                if (f==NULL){  // Error de eliminación
                        scriptLog(modulo,10);
                        resul=8;
                        scriptLog(modulo,resul);
                        return(resul);
                }
                fclose(f);
        }
        /* Compone linea de comando */
        if(parametros){
                strcat(script," ");
                strcat(script,parametros);
        }
        /* LLamada función interface */
        resul=system(script);
        if(resul){
                scriptLog(modulo,10);
                scriptLog(modulo,resul);
                return(resul);
        }
        /* Lee fichero de retorno */
        if(salida!=(char*)NULL){
                f = fopen("/tmp/_retinterface_","rb" );
                if (f==NULL){ // Error de apertura
                        scriptLog(modulo,10);
                        resul=9;
                        scriptLog(modulo,resul);
                        return(resul);
                }
                else{
                        fseek (f ,0,SEEK_END);  // Obtiene tamaño del fichero.
                        lSize = ftell (f);
                        rewind (f);
                        if(lSize>LONGITUD_SCRIPTSALIDA){
                                scriptLog(modulo,10);
                                resul=11;
                                scriptLog(modulo,resul);
                                return(resul);
                        }
                        fread (salida,1,lSize,f);       // Lee contenido del fichero
                        rTrim(salida);
                        fclose(f);
                }
        }
        /* Muestra información de retorno */
        if(salida!=(char*)NULL){
                if(ndebug>2){
                        sprintf(msglog,"Información devuelta %s",salida);
                        infoDebug(msglog);
                }
        }
        return(resul);
}
//______________________________________________________________________________________________________
// Función: interfaceAdmin
//
//       Descripción:
//              Esta función es la puerta de comunicación entre el módulo de administración y el motor de clonación.
//              La Aplicación de administración utiliza una interface para ejecutar funciones del motor de clonación;
//              esta interface llamará a la API del motor con lo que cambiando el comportamiento de esta interface
//              podremos hacer llamadas a otras API de clonación y de esta manera probar distintos motores.
//
//      Parámetros:
//              - script: Nombre del módulo,función o script de la interface
//              - parametros: Parámetros que se le pasarán a la interface
//              - salida: Recoge la salida que genera la llamada a la interface

//      Devuelve:
//              Código de error de la ejecución al módulo , función o script de la interface
//
//      Especificaciones:
//              El parámetro salida recoge la salida desde el procedimiento hijo que se genera en la ejecución de éste
//              siempre que sea distinto de NULL, esto es, si al llamar a la función este parámetro es NULL no se
//              recogerá dicha salida.
//______________________________________________________________________________________________________

int interfaceAdmin( char *script,char* parametros,char* salida)
{
        int  descr[2];  /* Descriptores de E y S de la turbería */
        int  bytesleidos;       /* Bytes leidos en el mensaje */
        int estado;
        pid_t  pid;
        char buffer[LONBLK];    // Buffer de lectura de fichero
        pipe (descr);
        int i,nargs,resul;
        int lon;                // Longitud de cadena
        char msglog[LONSUC];    // Mensaje de registro de sucesos
        char *argumentos[MAXARGS];
        char modulo[] = "interfaceAdmin()";
        if (ndebug>= DEBUG_MEDIO) {
                sprintf(msglog, "%s:%s", tbMensajes[8], script);
                infoDebug(msglog);
        }

        /* Crea matriz de los argumentos */
        nargs=splitCadena(argumentos,parametros,32);
        for(i=nargs;i<MAXARGS;i++){
                argumentos[i]=NULL;
        }
        /* Muestra matriz de los argumentos */
        for(i=1;i<nargs;i++){
                if (ndebug>= DEBUG_ALTO) {
                        // Truncar la cadena si es mayor que el tamaño de la línea de log.
                        sprintf(msglog, "%s: #%d-", tbMensajes[9], i+1);
                        lon = strlen (msglog);
                        if (lon + strlen (argumentos[i]) < LONSUC) {
                                strcat (msglog, argumentos[i]);
                        }
                        else
                        {
                                strncat (msglog, argumentos[i], LONSUC - lon - 4);
                                strcat (msglog, "...");
                        }
                        infoDebug(msglog);
                }
        }

        if((pid=fork())==0)
        {
                //_______________________________________________________________

                /* Proceso hijo que ejecuta la función de interface */

                close (descr[LEER]);
                dup2 (descr[ESCRIBIR], 1);
                close (descr[ESCRIBIR]);
                resul=execv(script,argumentos);
                //resul=execlp (script, script, argumentos[0],argumentos[1],NULL);
                exit(resul);

                /* Fin de proceso hijo */
                //_______________________________________________________________
        }
        else
        {
                //_______________________________________________________________

                /* Proceso padre que espera la ejecución del hijo */

                if (pid ==-1){ // Error en la creación del proceso hijo
                        scriptLog(modulo,10);
                        resul=13;
                        scriptLog(modulo,resul);
                        return(resul);
                }
                close (descr[ESCRIBIR]);
                bytesleidos = read (descr[LEER], buffer, LONBLK-1);
                while(bytesleidos>0){
                        if(salida!=(char*)NULL){ // Si se solicita retorno de información...
                                buffer[bytesleidos]='\0';
                                // Error si se supera el tamaño máximo de cadena de salida.
                                if(strlen(buffer)+strlen(salida)>LONGITUD_SCRIPTSALIDA){
                                        scriptLog(modulo,10);
                                        resul=11;
                                        scriptLog(modulo,resul);
                                        return(resul);
                                }
                                rTrim(buffer);
                                strcat(salida,buffer);
                        }
                        bytesleidos = read (descr[LEER], buffer, LONBLK-1);
                }
                close (descr[LEER]);
                //kill(pid,SIGQUIT);
                waitpid(pid,&estado,0);
                resul=WEXITSTATUS(estado);
                if(resul){
                        scriptLog(modulo,10);
                        scriptLog(modulo,resul);
                        return(resul);
                }
                /* Fin de proceso padre */
                //_______________________________________________________________
        }

        /* Muestra información de retorno */
        if(salida!=(char*)NULL){
                if(ndebug>2){
                        // Truncar la cadena si es mayor que el tamaño de la línea de log.
                        strcpy(msglog,"Informacion devuelta ");
                        lon = strlen (msglog);
                        if (lon + strlen (salida) < LONSUC) {
                                strcat (msglog, salida);
                        }
                        else
                        {
                                strncat (msglog, salida, LONSUC-lon-4);
                                strcat (msglog, "...");
                        }
                        infoDebug(msglog);
                }
        }
        return(resul);
}
//______________________________________________________________________________________________________
// Función: scriptLog
//
//      Descripción:
//              Registra los sucesos de errores de scripts en el fichero de log
//      Parametros:
//              - modulo: Módulo donde se produjo el error
//              - coderr : Código del mensaje de error del script
//______________________________________________________________________________________________________
void scriptLog(const char *modulo,int coderr)
{
        char msglog[LONSUC];

        if(coderr<MAXERRORSCRIPT)
                errorInfo(modulo,tbErroresScripts[coderr]); // Se ha producido algún error registrado
        else{
                sprintf(msglog,"%s: %d",tbErroresScripts[MAXERRORSCRIPT],coderr);
                errorInfo(modulo,msglog);
        }
}
//______________________________________________________________________________________________________
// Función: TomaIPlocal
//
//       Descripción:
//              Recupera la IP local
//      Parámetros:
//              Ninguno
//      Devuelve:
//              TRUE: Si el proceso es correcto
//              FALSE: En caso de ocurrir algún error
//      Especificaciones:
//              En caso de no encontrar la IP o generarse algún error la IP local sería 0.0.0.0
//______________________________________________________________________________________________________
BOOLEAN tomaIPlocal()
{
        char modulo[] = "tomaIPlocal()";

        // Para debug
        //strcpy(IPlocal,"10.1.15.203");
        //return(TRUE);

        sprintf(interface,"%s/getIpAddress",pathinterface);
        herror=interfaceAdmin(interface,NULL,IPlocal);
        if(herror){
                errorLog(modulo,85,FALSE);
                return(FALSE);
        }
        return(TRUE);
}
//______________________________________________________________________________________________________
//
// Función: cuestionCache
//
//       Descripción:
//              Procesa la cache en caso de existir.
//      Parámetros:
//              tam : Tamaño de la cache
//      Devuelve:
//              TRUE: Si el proceso es correcto
//              FALSE: En caso de ocurrir algún error
//______________________________________________________________________________________________________
BOOLEAN cuestionCache(char* tam)
{
        return(TRUE);
        //>>>>>>>>>>>>>>>>>>>>>>>>>>
        char msglog[LONSTD];
        char modulo[] = "cuestionCache()";

        sprintf(interface,"%s/%s",pathinterface,"procesaCache");
        sprintf(parametros,"%s %s","procesaCache",tam);

        herror=interfaceAdmin(interface,parametros,NULL);
        if(herror){
                sprintf(msglog,"%s",tbErrores[88]);
                errorInfo(modulo,msglog);
                return(FALSE);
        }

        return(TRUE);
}
//______________________________________________________________________________________________________
// Función: cargaPaginaWeb
//
//      Descripción:
//              Muestra una pégina web usando el browser
//      Parámetros:
//        urp: Dirección url de la página
//      Devuelve:
//              TRUE: Si el proceso es correcto
//              FALSE: En caso de ocurrir algún error
// ________________________________________________________________________________________________________
int cargaPaginaWeb(char *url)
{
        pid_t pidbrowser; // Identificador del proceso que se crea para mostrar una página web con el browser
        int resul=0;
        char* argumentos[4];
        char modulo[] = "cargaPaginaWeb()";

        // Destruye los procesos del Browser y lanza uno nuevo.
        system("pkill -9 browser");

        sprintf(interface,"/opt/opengnsys/bin/browser");
        sprintf(parametros,"browser -qws %s",url);

        splitCadena(argumentos,parametros,' '); // Crea matriz de los argumentos del scripts
        argumentos[3]=NULL;
        if((pidbrowser=fork())==0){
                /* Proceso hijo que ejecuta el script */
                resul=execv(interface,argumentos);
                exit(resul);
        }
        else {
                if (pidbrowser ==-1){
                        scriptLog(modulo,10);
                        resul=13;
                        scriptLog(modulo,resul);
                        return(resul);
                }
        }
        return(resul);
}
//________________________________________________________________________________________________________
//      Función: muestraMenu
//
//      Descripción:
//              Muestra el menu inicial del cliente
//      Parámetros:
//              Ninguno
//      Devuelve:
//              TRUE: Si el proceso es correcto
//              FALSE: En caso de ocurrir algún error
//________________________________________________________________________________________________________
void muestraMenu()
{
        cargaPaginaWeb(urlmenu);
}
//______________________________________________________________________________________________________
// Función: muestraMensaje
//
//      Descripción:
//              Muestra un mensaje en pantalla
//      Parámetros:
//              - idx: Indice del mensaje
//              - msg: Descripción Mensaje
// ________________________________________________________________________________________________________
void muestraMensaje(int idx,char*msg)
{
        char *msgpan,url[250];
        
        if(msg){
                msgpan=URLEncode(msg);
                sprintf(url,"%s?msg=%s",urlmsg,msgpan); // Url de la página de mensajes
                liberaMemoria(msgpan);
        }
        else
                sprintf(url,"%s?idx=%d",urlmsg,idx); // Url de la página de mensajes
        cargaPaginaWeb(url);
}
//______________________________________________________________________________________________________
// Función: InclusionCliente
//       Descripción:
//              Abre una sesión en el servidor de administración y registra al cliente en el sistema
//      Parámetros:
//              Ninguno
//      Devuelve:
//              TRUE: Si el proceso es correcto
//              FALSE: En caso de ocurrir algún error
//______________________________________________________________________________________________________
BOOLEAN inclusionCliente(TRAMA* ptrTrama)
{
        int lon;                // Longitud de cadena
        char msglog[LONSUC];    // Mensaje de registro de sucesos
        char *cfg;              // Datos de configuración
        SOCKET socket_c;
        char modulo[] = "inclusionCliente()";

        cfg=LeeConfiguracion();
        
        if(!cfg){ // No se puede recuperar la configuración del cliente
                errorLog(modulo,36,FALSE);
                errorLog(modulo,37,FALSE);
                return(FALSE);
        }
        if (ndebug>= DEBUG_ALTO) {
                // Truncar la cadena si es mayor que el tamaño de la línea de log.
                sprintf(msglog, "%s", tbMensajes[14]);
                lon = strlen (msglog);
                if (lon + strlen (cfg) < LONSUC) {
                        strcat (msglog, cfg);
                }
                else
                {
                        strncat (msglog, cfg, LONSUC - lon - 4);
                        strcat (msglog, "...");
                }
                infoDebug(msglog);
        }
        initParametros(ptrTrama,0);
        lon=sprintf(ptrTrama->parametros,"nfn=InclusionCliente\r"); // Nombre de la función a ejecutar en el servidor
        lon+=sprintf(ptrTrama->parametros+lon,"cfg=%s\r",cfg); // Configuración de los Sistemas Operativos del cliente
        liberaMemoria(cfg);
        
        if(!enviaMensajeServidor(&socket_c,ptrTrama,MSG_PETICION)){
                errorLog(modulo,37,FALSE);
                return(FALSE);
        }
        ptrTrama=recibeMensaje(&socket_c);
        if(!ptrTrama){
                errorLog(modulo,45,FALSE);
                return(FALSE);
        }

        close(socket_c);

        if(!gestionaTrama(ptrTrama)){   // Análisis de la trama
                errorLog(modulo,39,FALSE);
                return(FALSE);
        }

        return(TRUE);
}
//______________________________________________________________________________________________________
// Función: RESPUESTA_InclusionCliente
//
//      Descripción:
//      Respuesta del servidor de administración a la petición de inicio
//              enviando los datos identificativos del cliente y otras configuraciones
//      Parámetros:
//              - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
//      Devuelve:
//              TRUE: Si el proceso es correcto
//              FALSE: En caso de ocurrir algún error
//______________________________________________________________________________________________________
BOOLEAN RESPUESTA_InclusionCliente(TRAMA* ptrTrama)
{
        char* res;
        char modulo[] = "RESPUESTA_InclusionCliente()";

        res=copiaParametro("res",ptrTrama); // Resultado del proceso de inclusión
        if(atoi(res)==0){ // Error en el proceso de inclusión
                liberaMemoria(res);
                errorLog(modulo,41,FALSE);
                return (FALSE);
        }
        liberaMemoria(res);

        idordenador=copiaParametro("ido",ptrTrama); // Identificador del ordenador
        nombreordenador=copiaParametro("npc",ptrTrama); //  Nombre del ordenador
        cache=copiaParametro("che",ptrTrama); // Tamaño de la caché reservada al cliente
        idproautoexec=copiaParametro("exe",ptrTrama); // Procedimento de inicio (Autoexec)
        idcentro=copiaParametro("idc",ptrTrama); // Identificador de la Unidad Organizativa
        idaula=copiaParametro("ida",ptrTrama); // Identificador del aula

        if(idordenador==NULL || nombreordenador==NULL){
                errorLog(modulo,40,FALSE);
                return (FALSE);
        }
        return(TRUE);
}
//______________________________________________________________________________________________________
//
// Función: LeeConfiguracion
//       Descripción:
//              Abre una sesión en el servidor de administración y registra al cliente en el sistema
//      Parámetros:
//              Ninguno
//      Devuelve:
//              TRUE: Si el proceso es correcto
//              FALSE: En caso de ocurrir algún error
//______________________________________________________________________________________________________

char* LeeConfiguracion()
{
        char* parametroscfg;
        char modulo[] = "LeeConfiguracion()";

        // Reservar memoria para los datos de cofiguración.
        parametroscfg=(char*)reservaMemoria(LONGITUD_SCRIPTSALIDA);
        if(!parametroscfg){
                errorLog(modulo,3,FALSE);
                return(NULL);
        }
        // Ejecutar script y obtener datos.
        sprintf(interface,"%s/%s",pathinterface,"getConfiguration");
        herror=interfaceAdmin(interface,NULL,parametroscfg);

        if(herror){ // No se puede recuperar la configuración del cliente
                liberaMemoria(parametroscfg);
                errorLog(modulo,36,FALSE);
                return(NULL);
        }
        return(parametroscfg);
}
//________________________________________________________________________________________________________
//      Función: autoexecCliente
//
//      Descripción:
//              Solicita procedimiento de autoexec para el cliebnte
//      Parámetros:
//              Ninguno
//      Devuelve:
//              TRUE: Si el proceso es correcto
//              FALSE: En caso de ocurrir algún error
//________________________________________________________________________________________________________
BOOLEAN autoexecCliente(TRAMA* ptrTrama)
{
        SOCKET socket_c;
        char modulo[] = "autoexecCliente()";

        initParametros(ptrTrama,0);
        sprintf(ptrTrama->parametros,"nfn=AutoexecCliente\rexe=%s\r",idproautoexec);

        if(!enviaMensajeServidor(&socket_c,ptrTrama,MSG_PETICION)){
                errorLog(modulo,42,FALSE);
                return(FALSE);
        }
        ptrTrama=recibeMensaje(&socket_c);
        if(!ptrTrama){
                errorLog(modulo,45,FALSE);
                return(FALSE);
        }

        close(socket_c);

        if(!gestionaTrama(ptrTrama)){   // Análisis de la trama
                errorLog(modulo,39,FALSE);
                return(FALSE);
        }

        return(TRUE);
}
//________________________________________________________________________________________________________
//      Función: autoexecCliente
//
//      Descripción:
//              Ejecuta un script de autoexec personalizado en todos los inicios para el cliente
//      Parámetros:
//              Ninguno
//      Devuelve:
//              TRUE: Si el proceso es correcto
//              FALSE: En caso de ocurrir algún error
//________________________________________________________________________________________________________
BOOLEAN RESPUESTA_AutoexecCliente(TRAMA* ptrTrama)
{
        SOCKET socket_c;
        char *res,*nfl;
        char modulo[] = "RESPUESTA_AutoexecCliente()";

        res=copiaParametro("res",ptrTrama);
        if(atoi(res)==0){ // Error en el proceso de autoexec
                liberaMemoria(res);
                return (FALSE);
        }
        liberaMemoria(res);

        nfl=copiaParametro("nfl",ptrTrama);
        initParametros(ptrTrama,0);
        sprintf(ptrTrama->parametros,"nfn=enviaArchivo\rnfl=%s\r",nfl);
        liberaMemoria(nfl);

        /* Envía petición */
        if(!enviaMensajeServidor(&socket_c,ptrTrama,MSG_PETICION)){
                errorLog(modulo,42,FALSE);
                return(FALSE);
        }
        /* Nombre del archivo destino (local)*/
        char fileautoexec[LONPRM];
        sprintf(fileautoexec,"/tmp/_autoexec_%s",IPlocal);

        /* Recibe archivo */
        if(!recArchivo(&socket_c,fileautoexec)){
                errorLog(modulo,58, FALSE);
                close(socket_c);
                return(FALSE);
        }

        close(socket_c);

        /* Ejecuta archivo */
        ejecutaArchivo(fileautoexec,ptrTrama);
        return(TRUE);
}
//______________________________________________________________________________________________________
// Función: comandosPendientes
//
//       Descripción:
//               Búsqueda de acciones pendientes en el servidor de administración
//      Parámetros:
//              Ninguno
//      Devuelve:
//              TRUE: Si el proceso es correcto
//              FALSE: En caso de ocurrir algún error
//______________________________________________________________________________________________________
BOOLEAN comandosPendientes(TRAMA* ptrTrama)
{
        SOCKET socket_c;
        char modulo[] = "comandosPendientes()";

        CMDPTES=TRUE;
        initParametros(ptrTrama,0);

        while(CMDPTES){
                sprintf(ptrTrama->parametros,"nfn=ComandosPendientes\r");
                if(!enviaMensajeServidor(&socket_c,ptrTrama,MSG_PETICION)){
                        errorLog(modulo,42,FALSE);
                        return(FALSE);
                }
                ptrTrama=recibeMensaje(&socket_c);
                if(!ptrTrama){
                        errorLog(modulo,45,FALSE);
                        return(FALSE);
                }

                close(socket_c);

                if(!gestionaTrama(ptrTrama)){   // Análisis de la trama
                        errorLog(modulo,39,FALSE);
                        return(FALSE);
                }
        }
        return(TRUE);
}
//______________________________________________________________________________________________________
// Función: NoComandosPtes
//
//       Descripción:
//               Conmuta el switch de los comandos pendientes y lo pone a false
//      Parámetros:
//              - ptrTrama: contenido del mensaje
//      Devuelve:
//              TRUE siempre
//      Especificaciones:
//              Cuando se ejecuta esta función se sale del bucle que recupera los comandos pendientes en el
//              servidor y el cliente pasa a a estar disponible para recibir comandos desde el éste.
//______________________________________________________________________________________________________
BOOLEAN NoComandosPtes(TRAMA* ptrTrama)
{
        CMDPTES=FALSE; // Corta el bucle de comandos pendientes
        return(TRUE);
}
//______________________________________________________________________________________________________
// Función: ProcesaComandos
//
//      Descripción:
//              Espera comando desde el Servidor de Administración para ejecutarlos
//      Parámetros:
//              Ninguno
//      Devuelve:
//              TRUE: Si el proceso es correcto
//              FALSE: En caso de ocurrir algún error
// ________________________________________________________________________________________________________
void procesaComandos(TRAMA* ptrTrama)
{
        int lon;
        SOCKET socket_c;
        char modulo[] = "procesaComandos()";

        initParametros(ptrTrama,0);
        while(TRUE){
                lon=sprintf(ptrTrama->parametros,"nfn=DisponibilidadComandos\r");
                lon+=sprintf(ptrTrama->parametros+lon,"tpc=%s\r",CLIENTE_OPENGNSYS); // Activar disponibilidad
                if(!enviaMensajeServidor(&socket_c,ptrTrama,MSG_INFORMACION)){
                        errorLog(modulo,43,FALSE);
                        return;
                }
                infoLog(19); // Disponibilidad de cliente activada
                ptrTrama=recibeMensaje(&socket_c);
                if(!ptrTrama){
                        errorLog(modulo,46,FALSE);
                        return;
                }

                close(socket_c);

                if(!gestionaTrama(ptrTrama)){   // Análisis de la trama
                        errorLog(modulo,39,FALSE);
                        return;
                }
                if(!comandosPendientes(ptrTrama)){
                        errorLog(modulo,42,FALSE);
                }
        }
}
//______________________________________________________________________________________________________
// Función: Actualizar
//
//       Descripción:
//              Actualiza los datos de un ordenador como si volviera a solicitar la entrada
//              en el sistema al  servidor de administración
//      Parámetros:
//              ptrTrama: contenido del mensajede
//      Devuelve:
//              TRUE: Si el proceso es correcto
//              FALSE: En caso de ocurrir algún error
//______________________________________________________________________________________________________
BOOLEAN Actualizar(TRAMA* ptrTrama)
{
        char msglog[LONSTD];    // Mensaje de log
        char *cfg;              // Cadena de datos de configuración
        int lon;                // Longitud de cadena
        char modulo[] = "Actualizar()";

        if (ndebug>=DEBUG_MAXIMO) {
                sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
                infoDebug(msglog);
        }
        muestraMensaje(1,NULL);
        if(!comandosPendientes(ptrTrama)){
                errorLog(modulo,84,FALSE);
                return(FALSE);
        }

        cfg=LeeConfiguracion();
        herror=0;
        if(!cfg){ // No se puede recuperar la configuración del cliente
                errorLog(modulo,36,FALSE);
                herror=3;
        }
        // Envia Configuracion al servidor
        initParametros(ptrTrama,0);
        lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_Configurar");
        lon+=sprintf(ptrTrama->parametros+lon,"cfg=%s\r",cfg); // Configuración de los Sistemas Operativos del cliente
        respuestaEjecucionComando(ptrTrama,herror,0);

        muestraMenu();

        return(TRUE);
}
//______________________________________________________________________________________________________
// Función: Purgar
//
//       Descripción:
//              Detiene la ejecución del browser
//      Parámetros:
//              ptrTrama: contenido del mensajede
//      Devuelve:
//              TRUE: Si el proceso es correcto
//              FALSE: En caso de ocurrir algún error
//______________________________________________________________________________________________________
int Purgar(TRAMA* ptrTrama)
{

        exit(EXIT_SUCCESS);
}
//______________________________________________________________________________________________________
// Función: Sondeo
//
//       Descripción:
//              Envía al servidor una confirmación de que está dentro del sistema
//      Parámetros:
//              ptrTrama: contenido del mensajede
//      Devuelve:
//              TRUE: Si el proceso es correcto
//              FALSE: En caso de ocurrir algún error
//______________________________________________________________________________________________________
BOOLEAN Sondeo(TRAMA* ptrTrama)
{
        return(TRUE);
}
//______________________________________________________________________________________________________
// Función: ConsolaRemota
//
//      Descripción:
//              Ejecuta un comando de la Shell y envia el eco al servidor (Consola remota)
//      Parámetros:
//              ptrTrama: contenido del mensaje
//      Devuelve:
//              TRUE: Si el proceso es correcto
//              FALSE: En caso de ocurrir algún error
//______________________________________________________________________________________________________
BOOLEAN ConsolaRemota(TRAMA* ptrTrama)
{
        SOCKET socket_c;
        char *nfn,*scp,*aux,ecosrc[LONPRM],ecodst[LONPRM],msglog[LONSTD];;
        char modulo[] = "ConsolaRemota()";

        /* Nombre del archivo de script */
        char filescript[LONPRM];
        sprintf(filescript,"/tmp/_script_%s",IPlocal);
        
        aux=copiaParametro("scp",ptrTrama);
        scp=URLDecode(aux);
        escribeArchivo(filescript,scp);
        liberaMemoria(aux);
        liberaMemoria(scp);
        
        nfn=copiaParametro("nfn",ptrTrama);
        sprintf(interface,"%s/%s",pathinterface,nfn);
        sprintf(ecosrc,"/tmp/_econsola_%s",IPlocal);
        sprintf(parametros,"%s %s %s",nfn,filescript,ecosrc);
        herror=interfaceAdmin(interface,parametros,NULL);
        if(herror){
                sprintf(msglog,"%s:%s",tbErrores[86],nfn);
                errorInfo(modulo,msglog);
        }
        else{
                /* Envía fichero de inventario al servidor */
                sprintf(ecodst,"/tmp/_Seconsola_%s",IPlocal); // Nombre que tendra el archivo en el Servidor
                initParametros(ptrTrama,0);
                sprintf(ptrTrama->parametros,"nfn=recibeArchivo\rnfl=%s\r",ecodst);
                if(!enviaMensajeServidor(&socket_c,ptrTrama,MSG_COMANDO)){
                        errorLog(modulo,42,FALSE);
                        return(FALSE);
                }
                 /* Espera señal para comenzar el envío */
                liberaMemoria(ptrTrama);
                recibeFlag(&socket_c,ptrTrama);
                /* Envía archivo */
                if(!sendArchivo(&socket_c,ecosrc)){
                        errorLog(modulo,57, FALSE);
                        herror=12; // Error de envío de fichero por la red
                }
                close(socket_c);
        }
        liberaMemoria(nfn);
        return(TRUE);
}
//_____________________________________________________________________________________________________
// Función: Comando
//
//       Descripción:
//              COmando personalizado enviado desde el servidor
//      Parámetros:
//              ptrTrama: contenido del mensaje
//      Devuelve:
//              TRUE: Si el proceso es correcto
//              FALSE: En caso de ocurrir algún error
//_____________________________________________________________________________________________________
BOOLEAN Comando(TRAMA* ptrTrama)
{
        char *ids,*nfn,msglog[LONSTD];
        char modulo[] = "Comando()";

        if (ndebug>=DEBUG_MAXIMO) {
                sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
                infoDebug(msglog);
        }
        nfn=copiaParametro("nfn",ptrTrama);
        ids=copiaParametro("ids",ptrTrama);

        sprintf(interface,"%s/%s",pathinterface,nfn);
        herror=interfaceAdmin(interface,NULL,NULL);
        if(herror){
                sprintf(msglog,"%s:%s",tbErrores[86],nfn);
                errorInfo(modulo,msglog);
        }
        /* Envia respuesta de ejecucución del comando */
        initParametros(ptrTrama,0);
        sprintf(ptrTrama->parametros,"nfn=RESPUESTA_%s\r",nfn);
        respuestaEjecucionComando(ptrTrama,herror,ids);
        liberaMemoria(nfn);
        liberaMemoria(ids);
        return(TRUE);
}
//_____________________________________________________________________________________________________
// Función: Arrancar
//
//       Descripción:
//              Responde a un comando de encendido por la red
//      Parámetros:
//              ptrTrama: contenido del mensaje
//      Devuelve:
//              TRUE: Si el proceso es correcto
//              FALSE: En caso de ocurrir algún error
//_____________________________________________________________________________________________________
BOOLEAN Arrancar(TRAMA* ptrTrama)
{
        int lon;
        char *ids,msglog[LONSTD];
        char modulo[] = "Arrancar()";

        if (ndebug>=DEBUG_MAXIMO) {
                sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
                infoDebug(msglog);
        }

        ids=copiaParametro("ids",ptrTrama);

        /* Envia respuesta de ejecucución del script */
        initParametros(ptrTrama,0);
        lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_Arrancar");
        lon+=sprintf(ptrTrama->parametros+lon,"tpc=%s\r",CLIENTE_OPENGNSYS);
        respuestaEjecucionComando(ptrTrama,0,ids);
        liberaMemoria(ids);
        return(TRUE);
}
//_____________________________________________________________________________________________________
// Función: Apagar
//
//       Descripción:
//              Apaga el cliente
//      Parámetros:
//              ptrTrama: contenido del mensaje
//      Devuelve:
//              TRUE: Si el proceso es correcto
//              FALSE: En caso de ocurrir algún error
//_____________________________________________________________________________________________________
BOOLEAN Apagar(TRAMA* ptrTrama)
{
        char *ids,*nfn,msglog[LONSTD];
        char modulo[] = "Apagar()";

        if (ndebug>=DEBUG_MAXIMO) {
                sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
                infoDebug(msglog);
        }
        nfn=copiaParametro("nfn",ptrTrama);
        ids=copiaParametro("ids",ptrTrama);

        initParametros(ptrTrama,0);
        sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_Apagar");
        respuestaEjecucionComando(ptrTrama,0,ids);

        sprintf(interface,"%s/%s",pathinterface,nfn);
        herror=interfaceAdmin(interface,NULL,NULL);
        if(herror){
                sprintf(msglog,"%s:%s",tbErrores[86],nfn);
                liberaMemoria(nfn);
                liberaMemoria(ids);                     
                errorInfo(modulo,msglog);
                return(FALSE);
        }
        liberaMemoria(nfn);
        liberaMemoria(ids);     
        return(TRUE);
}
//_____________________________________________________________________________________________________
// Función: Reiniciar
//
//       Descripción:
//              Apaga el cliente
//      Parámetros:
//              ptrTrama: contenido del mensaje
//      Devuelve:
//              TRUE: Si el proceso es correcto
//              FALSE: En caso de ocurrir algún error
//_____________________________________________________________________________________________________
BOOLEAN Reiniciar(TRAMA* ptrTrama)
{
        char *nfn,*ids,msglog[LONSTD];
        char modulo[] = "Reiniciar()";

        if (ndebug>=DEBUG_MAXIMO) {
                sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
                infoDebug(msglog);
        }
        nfn=copiaParametro("nfn",ptrTrama);
        ids=copiaParametro("ids",ptrTrama);

        initParametros(ptrTrama,0);
        sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_Reiniciar");
        respuestaEjecucionComando(ptrTrama,0,ids);

        sprintf(interface,"%s/%s",pathinterface,nfn);
        herror=interfaceAdmin(interface,NULL,NULL);
        if(herror){
                sprintf(msglog,"%s:%s",tbErrores[86],nfn);
                liberaMemoria(nfn);
                liberaMemoria(ids);                     
                errorInfo(modulo,msglog);
                return(FALSE);
        }
        liberaMemoria(nfn);
        liberaMemoria(ids);             
        return(TRUE);
}
//_____________________________________________________________________________________________________
// Función: IniciarSesion
//
//       Descripción:
//              Inicia sesión en el Sistema Operativo de una de las particiones
//      Parámetros:
//              ptrTrama: contenido del mensaje
//      Devuelve:
//              TRUE: Si el proceso es correcto
//              FALSE: En caso de ocurrir algún error
//_____________________________________________________________________________________________________
BOOLEAN IniciarSesion(TRAMA* ptrTrama)
{
        char *nfn,*ids,*disk,*par,msglog[LONSTD];
        char modulo[] = "IniciarSesion()";

        if (ndebug>=DEBUG_MAXIMO) {
                sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
                infoDebug(msglog);
        }
        nfn=copiaParametro("nfn",ptrTrama);
        ids=copiaParametro("ids",ptrTrama);
        disk=copiaParametro("dsk",ptrTrama);
        par=copiaParametro("par",ptrTrama);
        
        initParametros(ptrTrama,0);
        sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_IniciarSesion");
        respuestaEjecucionComando(ptrTrama,0,ids);
        liberaMemoria(ids);                     

        sprintf(interface,"%s/%s",pathinterface,nfn);
        sprintf(parametros,"%s %s %s",nfn,disk,par);
        liberaMemoria(par);                     
        
        herror=interfaceAdmin(interface,parametros,NULL);

        if(herror){
                sprintf(msglog,"%s:%s",tbErrores[86],nfn);
                liberaMemoria(nfn);
                errorInfo(modulo,msglog);
                return(FALSE);
        }
        liberaMemoria(nfn);
        return(TRUE);
}
//______________________________________________________________________________________________________
// Función: CrearImagen
//
//       Descripción:
//              Crea una imagen de una partición
//      Parámetros:
//              ptrTrama: contenido del mensaje
//      Devuelve:
//              TRUE: Si el proceso es correcto
//              FALSE: En caso de ocurrir algún error
//______________________________________________________________________________________________________
BOOLEAN CrearImagen(TRAMA* ptrTrama)
{
        int lon;
        char *nfn,*dsk,*par,*cpt,*idi,*ipr,*nci,*ids,msglog[LONSTD];
        char modulo[] = "CrearImagen()";

        if (ndebug>=DEBUG_MAXIMO) {
                sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
                infoDebug(msglog);
        }

        dsk=copiaParametro("dsk",ptrTrama); // Disco
        par=copiaParametro("par",ptrTrama); // Número de partición
        cpt=copiaParametro("cpt",ptrTrama); // Código de la partición
        idi=copiaParametro("idi",ptrTrama); // Identificador de la imagen
        nci=copiaParametro("nci",ptrTrama); // Nombre canónico de la imagen
        ipr=copiaParametro("ipr",ptrTrama); // Ip del repositorio

        nfn=copiaParametro("nfn",ptrTrama);
        ids=copiaParametro("ids",ptrTrama);
        muestraMensaje(7,NULL);

        if(InventariandoSoftware(ptrTrama,FALSE,"InventarioSoftware")){ // Crea inventario Software previamente
                muestraMensaje(2,NULL);
                sprintf(interface,"%s/%s",pathinterface,nfn);
                sprintf(parametros,"%s %s %s %s %s",nfn,dsk,par,nci,ipr);
                herror=interfaceAdmin(interface,parametros,NULL);
                if(herror){
                        sprintf(msglog,"%s:%s",tbErrores[86],nfn);
                        errorInfo(modulo,msglog);
                        muestraMensaje(10,NULL);
                }
                else
                        muestraMensaje(9,NULL);
        }
        else{
                sprintf(msglog,"%s:%s",tbErrores[86],nfn);
                errorInfo(modulo,msglog);
        }

        /* Envia respuesta de ejecución de la función de interface */
        initParametros(ptrTrama,0);
        lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_CrearImagen");
        lon+=sprintf(ptrTrama->parametros+lon,"idi=%s\r",idi); // Identificador de la imagen
        lon+=sprintf(ptrTrama->parametros+lon,"dsk=%s\r",dsk); // Número de disco
        lon+=sprintf(ptrTrama->parametros+lon,"par=%s\r",par); // Número de partición de donde se creó
        lon+=sprintf(ptrTrama->parametros+lon,"cpt=%s\r",cpt); // Tipo o código de partición
        lon+=sprintf(ptrTrama->parametros+lon,"ipr=%s\r",ipr); // Ip del repositorio donde se alojó
        respuestaEjecucionComando(ptrTrama,herror,ids);
        
        liberaMemoria(dsk);     
        liberaMemoria(par);     
        liberaMemoria(cpt);     
        liberaMemoria(idi);     
        liberaMemoria(nci);     
        liberaMemoria(ipr);     
        liberaMemoria(nfn);     
        liberaMemoria(ids);     

        muestraMenu();
        
        return(TRUE);
}
//______________________________________________________________________________________________________
// Función: CrearImagenBasica
//
//       Descripción:
//              Crea una imagen básica a travers dela sincronización
//      Parámetros:
//              ptrTrama: contenido del mensaje
//
//      FDevuelve:
//              TRUE: Si el proceso es correcto
//              FALSE: En caso de ocurrir algún error
//______________________________________________________________________________________________________
BOOLEAN CrearImagenBasica(TRAMA* ptrTrama)
{
        int lon;
        char *nfn,*dsk,*par,*cpt,*idi,*nci,*rti,*ipr,*msy,*whl,*eli,*cmp,*bpi,*cpc,*bpc,*nba,*ids,msglog[LONSTD];
        char modulo[] = "CrearImagenBasica()";

        if (ndebug>=DEBUG_MAXIMO) {
                sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
                infoDebug(msglog);
        }
        nfn=copiaParametro("nfn",ptrTrama);
        dsk=copiaParametro("dsk",ptrTrama); // Disco
        par=copiaParametro("par",ptrTrama); // Número de partición
        cpt=copiaParametro("cpt",ptrTrama); // Tipo de partición
        idi=copiaParametro("idi",ptrTrama); // Identificador de la imagen
        nci=copiaParametro("nci",ptrTrama); // Nombre canónico de la imagen
        rti=copiaParametro("rti",ptrTrama); // Ruta de origen de la imagen
        ipr=copiaParametro("ipr",ptrTrama); // Ip del repositorio

        msy=copiaParametro("msy",ptrTrama); // Método de sincronización
        
        whl=copiaParametro("whl",ptrTrama); // Envío del fichero completo si hay diferencias            
        eli=copiaParametro("eli",ptrTrama); // Elimiar archivos en destino que no estén en origen       
        cmp=copiaParametro("cmp",ptrTrama); // Comprimir antes de enviar

        bpi=copiaParametro("bpi",ptrTrama); // Borrar la imagen antes de crearla
        cpc=copiaParametro("cpc",ptrTrama); // Copiar también imagen a la cache
        bpc=copiaParametro("bpc",ptrTrama); // Borrarla de la cache antes de copiarla en ella
        nba=copiaParametro("nba",ptrTrama); // No borrar archivos en destino

        //muestraMensaje(7,NULL); // Creando Inventario Software
        //if(InventariandoSoftware(ptrTrama,FALSE,"InventarioSoftware")){ // Crea inventario Software previamente
                muestraMensaje(30,NULL);// Creando Imagen Básica, por favor espere...
                sprintf(interface,"%s/%s",pathinterface,nfn);
                sprintf(parametros,"%s %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,msy,rti);
                herror=interfaceAdmin(interface,parametros,NULL);
                if(herror){
                        sprintf(msglog,"%s:%s",tbErrores[86],nfn);
                        errorInfo(modulo,msglog);
                        muestraMensaje(29,NULL);// Ha habido algún error en el proceso de creación de imagen básica
                }
                else
                        muestraMensaje(28,NULL);// El proceso de creación de imagen básica ha terminado correctamente
        //}
        //else{
        //      sprintf(msglog,"%s:%s",tbErrores[86],nfn);
        //      errorInfo(modulo,msglog);
        //}

        ids=copiaParametro("ids",ptrTrama); // Identificador de la sesión

        /* Envia respuesta de ejecución de la función de interface */
        initParametros(ptrTrama,0);
        lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_CrearImagenBasica");
        lon+=sprintf(ptrTrama->parametros+lon,"idi=%s\r",idi); // Identificador de la imagen
        lon+=sprintf(ptrTrama->parametros+lon,"dsk=%s\r",dsk); // Número de disco
        lon+=sprintf(ptrTrama->parametros+lon,"par=%s\r",par); // Número de partición de donde se creó
        lon+=sprintf(ptrTrama->parametros+lon,"cpt=%s\r",cpt); // Tipo o código de partición
        lon+=sprintf(ptrTrama->parametros+lon,"ipr=%s\r",ipr); // Ip del repositorio donde se alojó
        respuestaEjecucionComando(ptrTrama,herror,ids);
                
        liberaMemoria(nfn);     
        liberaMemoria(dsk);     
        liberaMemoria(par);     
        liberaMemoria(cpt);     
        liberaMemoria(idi);     
        liberaMemoria(nci);     
        liberaMemoria(rti);     
        liberaMemoria(ipr);     

        liberaMemoria(msy);     
        
        liberaMemoria(whl);     
        liberaMemoria(eli);     
        liberaMemoria(cmp);     

        liberaMemoria(bpi);     
        liberaMemoria(cpc);     
        liberaMemoria(bpc);     
        liberaMemoria(nba);
        liberaMemoria(ids);             
        
        muestraMenu();

        return(TRUE);
}
//______________________________________________________________________________________________________
// Función: CrearSoftIncremental
//
//       Descripción:
//              Crea una software incremental comparando una partición con una imagen básica
//      Parámetros:
//              ptrTrama: contenido del mensaje
//
//      Devuelve:
//              TRUE: Si el proceso es correcto
//              FALSE: En caso de ocurrir algún error
//______________________________________________________________________________________________________
BOOLEAN CrearSoftIncremental(TRAMA* ptrTrama)
{
        int lon;
        char *nfn,*dsk,*par,*idi,*idf,*ipr,*nci,*rti,*ncf,*msy,*whl,*eli,*cmp,*bpi,*cpc,*bpc,*nba,*ids,msglog[LONSTD];
        char modulo[] = "CrearSoftIncremental()";

        if (ndebug>=DEBUG_MAXIMO) {
                sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
                infoDebug(msglog);
        }
        nfn=copiaParametro("nfn",ptrTrama);

        dsk=copiaParametro("dsk",ptrTrama); // Disco
        par=copiaParametro("par",ptrTrama); // Número de partición
        idi=copiaParametro("idi",ptrTrama); // Identificador de la imagen
        nci=copiaParametro("nci",ptrTrama); // Nombre canónico de la imagen
        rti=copiaParametro("rti",ptrTrama); // Ruta de origen de la imagen
        ipr=copiaParametro("ipr",ptrTrama); // Ip del repositorio
        idf=copiaParametro("idf",ptrTrama); // Identificador de la imagen diferencial
        ncf=copiaParametro("ncf",ptrTrama); // Nombre canónico de la imagen diferencial

        msy=copiaParametro("msy",ptrTrama); // Método de sincronización

        whl=copiaParametro("whl",ptrTrama); // Envío del fichero completo si hay diferencias    
        eli=copiaParametro("eli",ptrTrama); // Elimiar archivos en destino que no estén en origen       
        cmp=copiaParametro("cmp",ptrTrama); // Comprimir antes de enviar

        bpi=copiaParametro("bpi",ptrTrama); // Borrar la imagen antes de crearla
        cpc=copiaParametro("cpc",ptrTrama); // Copiar también imagen a la cache
        bpc=copiaParametro("bpc",ptrTrama); // Borrarla de la cache antes de copiarla en ella
        nba=copiaParametro("nba",ptrTrama); // No borrar archivos en destino

//      muestraMensaje(7,NULL); // Creando Inventario Software
//      if(InventariandoSoftware(ptrTrama,FALSE,"InventarioSoftware")){ // Crea inventario Software previamente
                muestraMensaje(25,NULL);// Creando Imagen Incremental, por favor espere...
                sprintf(interface,"%s/%s",pathinterface,nfn);
                sprintf(parametros,"%s %s %s %s %s %s %s%s%s %s%s%s%s %s %s",nfn,dsk,par,nci,ipr,ncf,whl,eli,cmp,bpi,cpc,bpc,nba,msy,rti);

                herror=interfaceAdmin(interface,parametros,NULL);
                if(herror){
                        sprintf(msglog,"%s:%s",tbErrores[86],nfn);
                        errorInfo(modulo,msglog);
                        muestraMensaje(27,NULL);// Ha habido algún error en el proceso de creación de imagen básica
                }
                else
                        muestraMensaje(26,NULL);// El proceso de creación de imagen incremental ha terminado correctamente
//      }
//      else{
//              sprintf(msglog,"%s:%s",tbErrores[86],nfn);
//              errorInfo(modulo,msglog);
//      }

        ids=copiaParametro("ids",ptrTrama); // Identificador de la sesión

        /* Envia respuesta de ejecución de la función de interface */
        initParametros(ptrTrama,0);
        lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_CrearSoftIncremental");
        lon+=sprintf(ptrTrama->parametros+lon,"idf=%s\r",idf); // Identificador de la imagen incremental
        lon+=sprintf(ptrTrama->parametros+lon,"dsk=%s\r",dsk); // Número de disco
        lon+=sprintf(ptrTrama->parametros+lon,"par=%s\r",par); // Número de partición
        respuestaEjecucionComando(ptrTrama,herror,ids);
        
        liberaMemoria(nfn);     
        liberaMemoria(dsk);     
        liberaMemoria(par);     
        liberaMemoria(idi);     
        liberaMemoria(nci);     
        liberaMemoria(rti);     
        liberaMemoria(ipr);     
        liberaMemoria(idf);     
        liberaMemoria(ncf);     
        liberaMemoria(msy);     
        liberaMemoria(whl);
        liberaMemoria(eli);
        liberaMemoria(cmp);
        liberaMemoria(bpi);     
        liberaMemoria(cpc);     
        liberaMemoria(bpc);     
        liberaMemoria(nba);
        liberaMemoria(ids);             
        
        muestraMenu();

        return(TRUE);
}
//______________________________________________________________________________________________________
// Función: RestaurarImagen
//
//       Descripción:
//              Restaura una imagen en una partición
//      Parámetros:
//              ptrTrama: contenido del mensaje
//      Devuelve:
//              TRUE: Si el proceso es correcto
//              FALSE: En bpccaso de ocurrir algún error
//______________________________________________________________________________________________________
BOOLEAN RestaurarImagen(TRAMA* ptrTrama)
{
        int lon;
        char *nfn,*dsk,*par,*idi,*ipr,*ifs,*nci,*ids,*ptc,msglog[LONSTD];
        char modulo[] = "RestaurarImagen()";

        if (ndebug>=DEBUG_MAXIMO) {
                sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
                infoDebug(msglog);
        }

        dsk=copiaParametro("dsk",ptrTrama);
        par=copiaParametro("par",ptrTrama);
        idi=copiaParametro("idi",ptrTrama);
        ipr=copiaParametro("ipr",ptrTrama);
        nci=copiaParametro("nci",ptrTrama);
        ifs=copiaParametro("ifs",ptrTrama);
        ptc=copiaParametro("ptc",ptrTrama);

        nfn=copiaParametro("nfn",ptrTrama);
        ids=copiaParametro("ids",ptrTrama);
        muestraMensaje(3,NULL);
        sprintf(interface,"%s/%s",pathinterface,nfn);
        sprintf(parametros,"%s %s %s %s %s %s",nfn,dsk,par,nci,ipr,ptc);
        herror=interfaceAdmin(interface,parametros,NULL);
        if(herror){
                sprintf(msglog,"%s:%s",tbErrores[86],nfn);
                errorInfo(modulo,msglog);
                muestraMensaje(12,NULL);
        }
        else
                muestraMensaje(11,NULL);


        /* Envia respuesta de ejecución de la función de interface */
        initParametros(ptrTrama,0);
        lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_RestaurarImagen");
        lon+=sprintf(ptrTrama->parametros+lon,"idi=%s\r",idi); // Identificador de la imagen
        lon+=sprintf(ptrTrama->parametros+lon,"dsk=%s\r",dsk); // Número de disco
        lon+=sprintf(ptrTrama->parametros+lon,"par=%s\r",par); // Número de partición
        lon+=sprintf(ptrTrama->parametros+lon,"ifs=%s\r",ifs); // Identificador del perfil software
        respuestaEjecucionComando(ptrTrama,herror,ids);
        
        liberaMemoria(nfn);     
        liberaMemoria(dsk);     
        liberaMemoria(par);     
        liberaMemoria(idi);
        liberaMemoria(nci);     
        liberaMemoria(ipr);     
        liberaMemoria(ifs);     
        liberaMemoria(ptc);     
        liberaMemoria(ids);                     

        muestraMenu();

        return(TRUE);
}
//______________________________________________________________________________________________________
// Función: RestaurarImagenBasica
//
//       Descripción:
//              Restaura una imagen básica en una partición
//      Parámetros:
//              ptrTrama: contenido del mensaje
//      Devuelve:
//              TRUE: Si el proceso es correcto
//              FALSE: En caso de ocurrir algún error
//______________________________________________________________________________________________________
BOOLEAN RestaurarImagenBasica(TRAMA* ptrTrama)
{
        int lon;
        char *nfn,*dsk,*par,*idi,*ipr,*met,*nci,*rti,*ifs,*msy,*whl,*eli,*cmp,*tpt,*bpi,*cpc,*bpc,*nba,*ids,msglog[LONSTD];
        char modulo[] = "RestaurarImagenBasica()";

        if (ndebug>=DEBUG_MAXIMO) {
                sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
                infoDebug(msglog);
        }
        dsk=copiaParametro("dsk",ptrTrama);
        par=copiaParametro("par",ptrTrama);
        idi=copiaParametro("idi",ptrTrama);
        ipr=copiaParametro("ipr",ptrTrama);
        met=copiaParametro("met",ptrTrama); // Método de clonación 0= desde caché 1= desde repositorio
        nci=copiaParametro("nci",ptrTrama);
        rti=copiaParametro("rti",ptrTrama); // Ruta de origen de la imagen
        ifs=copiaParametro("ifs",ptrTrama);

        tpt=copiaParametro("tpt",ptrTrama); // Tipo de trasnmisión unicast o multicast  
        msy=copiaParametro("msy",ptrTrama); // Metodo de sincronizacion 

        whl=copiaParametro("whl",ptrTrama); // Envío del fichero completo si hay diferencias    
        eli=copiaParametro("eli",ptrTrama); // Elimiar archivos en destino que no estén en origen       
        cmp=copiaParametro("cmp",ptrTrama); // Comprimir antes de enviar



        bpi=copiaParametro("bpi",ptrTrama); // Borrar la imagen antes de crearla
        cpc=copiaParametro("cpc",ptrTrama); // Copiar también imagen a la cache
        bpc=copiaParametro("bpc",ptrTrama); // Borrarla de la cache antes de copiarla en ella
        nba=copiaParametro("nba",ptrTrama); // No borrar archivos en destino

        nfn=copiaParametro("nfn",ptrTrama);
        ids=copiaParametro("ids",ptrTrama);
        muestraMensaje(31,NULL);
        sprintf(interface,"%s/%s",pathinterface,nfn);
        sprintf(parametros,"%s %s %s %s %s %s %s%s%s %s%s%s%s %s %s %s",nfn,dsk,par,nci,ipr,tpt,whl,eli,cmp,bpi,cpc,bpc,nba,met,msy,rti);
        herror=interfaceAdmin(interface,parametros,NULL);
        if(herror){
                sprintf(msglog,"%s:%s",tbErrores[86],nfn);
                errorInfo(modulo,msglog);
                muestraMensaje(33,NULL);
        }
        else
                muestraMensaje(32,NULL);

        /* Envia respuesta de ejecución de la función de interface */
        initParametros(ptrTrama,0);
        lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_RestaurarImagenBasica");
        lon+=sprintf(ptrTrama->parametros+lon,"idi=%s\r",idi); // Identificador de la imagen
        lon+=sprintf(ptrTrama->parametros+lon,"dsk=%s\r",dsk); // Número de disco
        lon+=sprintf(ptrTrama->parametros+lon,"par=%s\r",par); // Número de partición
        lon+=sprintf(ptrTrama->parametros+lon,"ifs=%s\r",ifs); // Identificador del perfil software
        respuestaEjecucionComando(ptrTrama,herror,ids);
        
        liberaMemoria(nfn);     
        liberaMemoria(dsk);     
        liberaMemoria(par);     
        liberaMemoria(idi);     
        liberaMemoria(nci);     
        liberaMemoria(rti);     
        liberaMemoria(ifs);     
        liberaMemoria(ipr);     
        liberaMemoria(met);

        liberaMemoria(tpt);     
        liberaMemoria(msy);     

        liberaMemoria(whl);     
        liberaMemoria(eli);     
        liberaMemoria(cmp);     

        liberaMemoria(bpi);     
        liberaMemoria(cpc);     
        liberaMemoria(bpc);     
        liberaMemoria(nba);
        liberaMemoria(ids);             

        muestraMenu();
        
        return(TRUE);
}
//______________________________________________________________________________________________________
// Función: RestaurarSoftIncremental
//
//       Descripción:
//              Restaura software incremental en una partición
//      Parámetros:
//              ptrTrama: contenido del mensaje
//      Devuelve:
//              TRUE: Si el proceso es correcto
//              FALSE: En caso de ocurrir algún error
//______________________________________________________________________________________________________
BOOLEAN RestaurarSoftIncremental(TRAMA* ptrTrama)
{
        int lon;
        char *nfn,*dsk,*par,*idi,*ipr,*met,*ifs,*nci,*rti,*idf,*ncf,*msy,*whl,*eli,*cmp,*tpt,*bpi,*cpc,*bpc,*nba,*ids,msglog[LONSTD];
        char modulo[] = "RestaurarSoftIncremental()";

        if (ndebug>=DEBUG_MAXIMO) {
                sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
                infoDebug(msglog);
        }
        dsk=copiaParametro("dsk",ptrTrama);
        par=copiaParametro("par",ptrTrama);
        idi=copiaParametro("idi",ptrTrama);
        idf=copiaParametro("idf",ptrTrama);
        ipr=copiaParametro("ipr",ptrTrama);
        met=copiaParametro("met",ptrTrama); // Método de clonación 0= desde caché 1= desde repositorio
        ifs=copiaParametro("ifs",ptrTrama);
        nci=copiaParametro("nci",ptrTrama);
        rti=copiaParametro("rti",ptrTrama); // Ruta de origen de la imagen
        ncf=copiaParametro("ncf",ptrTrama);

        tpt=copiaParametro("tpt",ptrTrama); // Tipo de trasnmisión unicast o multicast  
        msy=copiaParametro("msy",ptrTrama); // Metodo de sincronizacion 

        whl=copiaParametro("whl",ptrTrama); // Envío del fichero completo si hay diferencias    
        eli=copiaParametro("eli",ptrTrama); // Elimiar archivos en destino que no estén en origen       
        cmp=copiaParametro("cmp",ptrTrama); // Comprimir antes de enviar

        bpi=copiaParametro("bpi",ptrTrama); // Borrar la imagen antes de crearla
        cpc=copiaParametro("cpc",ptrTrama); // Copiar también imagen a la cache
        bpc=copiaParametro("bpc",ptrTrama); // Borrarla de la cache antes de copiarla en ella
        nba=copiaParametro("nba",ptrTrama); // No borrar archivos en destino

        nfn=copiaParametro("nfn",ptrTrama);
        ids=copiaParametro("ids",ptrTrama);
        muestraMensaje(31,NULL);
        sprintf(interface,"%s/%s",pathinterface,nfn);
        sprintf(parametros,"%s %s %s %s %s %s %s %s%s%s %s%s%s%s %s %s %s",nfn,dsk,par,nci,ipr,ncf,tpt,whl,eli,cmp,bpi,cpc,bpc,nba,met,msy,rti);
        herror=interfaceAdmin(interface,parametros,NULL);
        if(herror){
                sprintf(msglog,"%s:%s",tbErrores[86],nfn);
                errorInfo(modulo,msglog);
                muestraMensaje(35,NULL);
        }
        else
                muestraMensaje(34,NULL);

        /* Envia respuesta de ejecución de la función de interface */
        initParametros(ptrTrama,0);
        lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_RestaurarSoftIncremental");
        lon+=sprintf(ptrTrama->parametros+lon,"idi=%s\r",idf); // Identificador de la imagen incremental (Forzada a idi)
        lon+=sprintf(ptrTrama->parametros+lon,"dsk=%s\r",dsk); // Número de disco
        lon+=sprintf(ptrTrama->parametros+lon,"par=%s\r",par); // Número de partición
        lon+=sprintf(ptrTrama->parametros+lon,"ifs=%s\r",ifs); // Identificador del perfil software

        respuestaEjecucionComando(ptrTrama,herror,ids);
        
        liberaMemoria(nfn);     
        liberaMemoria(dsk);     
        liberaMemoria(par);     
        liberaMemoria(idi);     
        liberaMemoria(idf);     
        liberaMemoria(nci);     
        liberaMemoria(rti);     
        liberaMemoria(ncf);     
        liberaMemoria(ifs);     
        liberaMemoria(ipr);     
        liberaMemoria(met);

        liberaMemoria(tpt);     
        liberaMemoria(msy);     

        liberaMemoria(whl);     
        liberaMemoria(eli);     
        liberaMemoria(cmp);     

        liberaMemoria(bpi);     
        liberaMemoria(cpc);     
        liberaMemoria(bpc);     
        liberaMemoria(nba);
        liberaMemoria(ids);             
        
        muestraMenu();

        return(TRUE);
}
//______________________________________________________________________________________________________
// Función: Configurar
//
//       Descripción:
//              Configura la tabla de particiones y formatea
//      Parámetros:
//              ptrTrama: contenido del mensaje
//      Devuelve:
//              TRUE: Si el proceso es correcto
//              FALSE: En caso de ocurrir algún error
//______________________________________________________________________________________________________
BOOLEAN Configurar(TRAMA* ptrTrama)
{
        int lon;
        char *nfn,*dsk,*cfg,*ids,msglog[LONSTD];
        char modulo[] = "Configurar()";

        if (ndebug>=DEBUG_MAXIMO) {
                sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
                infoDebug(msglog);
        }

        dsk=copiaParametro("dsk",ptrTrama);
        cfg=copiaParametro("cfg",ptrTrama);
        /* Sustituir caracteres */
        sustituir(cfg,'\n','$');
        sustituir(cfg,'\t','#');

        nfn=copiaParametro("nfn",ptrTrama);
        ids=copiaParametro("ids",ptrTrama);
        muestraMensaje(4,NULL);
        sprintf(interface,"%s/%s",pathinterface,nfn);
        sprintf(parametros,"%s %s %s",nfn,dsk,cfg);

        herror=interfaceAdmin(interface,parametros,NULL);
        if(herror){
                sprintf(msglog,"%s:%s",tbErrores[86],nfn);
                errorInfo(modulo,msglog);
                muestraMensaje(13,NULL);
        }
        else
                muestraMensaje(14,NULL);

        cfg=LeeConfiguracion();
        if(!cfg){ // No se puede recuperar la configuración del cliente
                errorLog(modulo,36,FALSE);
                return(FALSE);
        }

        /* Envia respuesta de ejecución del comando*/
        initParametros(ptrTrama,0);
        lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_Configurar");
        lon+=sprintf(ptrTrama->parametros+lon,"cfg=%s\r",cfg); // Configuración de los Sistemas Operativos del cliente
        respuestaEjecucionComando(ptrTrama,herror,ids);
        
        liberaMemoria(dsk);
        liberaMemoria(cfg);
        liberaMemoria(nfn);
        liberaMemoria(ids);

        muestraMenu();

        return(TRUE);
}
// ________________________________________________________________________________________________________
// Función: InventarioHardware
//
//      Descripción:
//              Envia al servidor el nombre del archivo de inventario de su hardware para posteriormente
//              esperar que éste lo solicite y enviarlo por la red.
//      Parámetros:
//              ptrTrama: contenido del mensaje
//      Devuelve:
//              TRUE: Si el proceso es correcto
//              FALSE: En caso de ocurrir algún error
//______________________________________________________________________________________________________
BOOLEAN InventarioHardware(TRAMA* ptrTrama)
{
        int lon;
        SOCKET socket_c;
        char *nfn,*ids,msglog[LONSTD],hrdsrc[LONPRM],hrddst[LONPRM];
        char modulo[] = "InventarioHardware()";

        if (ndebug>=DEBUG_MAXIMO) {
                sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
                infoDebug(msglog);
        }

        nfn=copiaParametro("nfn",ptrTrama);
        ids=copiaParametro("ids",ptrTrama);
        muestraMensaje(6,NULL);

        sprintf(interface,"%s/%s",pathinterface,nfn);
        sprintf(hrdsrc,"/tmp/Chrd-%s",IPlocal); // Nombre que tendra el archivo de inventario
        sprintf(parametros,"%s %s",nfn,hrdsrc);
        herror=interfaceAdmin(interface,parametros,NULL);
        if(herror){
                sprintf(msglog,"%s:%s",tbErrores[86],nfn);
                errorInfo(modulo,msglog);
                muestraMensaje(18,NULL);
        }
        else{
                /* Envía fichero de inventario al servidor */
                sprintf(hrddst,"/tmp/Shrd-%s",IPlocal); // Nombre que tendra el archivo en el Servidor
                initParametros(ptrTrama,0);
                sprintf(ptrTrama->parametros,"nfn=recibeArchivo\rnfl=%s\r",hrddst);
                if(!enviaMensajeServidor(&socket_c,ptrTrama,MSG_COMANDO)){
                        liberaMemoria(nfn);
                        liberaMemoria(ids);
                        errorLog(modulo,42,FALSE);
                        return(FALSE);
                }
                 /* Espera señal para comenzar el envío */
                liberaMemoria(ptrTrama);
                recibeFlag(&socket_c,ptrTrama);
                /* Envía archivo */
                if(!sendArchivo(&socket_c,hrdsrc)){
                        errorLog(modulo,57, FALSE);
                        herror=12; // Error de envío de fichero por la red
                }
                close(socket_c);
                muestraMensaje(17,NULL);
        }

        /* Envia respuesta de ejecución de la función de interface */
        initParametros(ptrTrama,0);
        lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_InventarioHardware");
        lon+=sprintf(ptrTrama->parametros+lon,"hrd=%s\r",hrddst);
        respuestaEjecucionComando(ptrTrama,herror,ids);
        liberaMemoria(nfn);
        liberaMemoria(ids);
        
        muestraMenu();

        return(TRUE);
}
// ________________________________________________________________________________________________________
// Función: InventarioSoftware
//
//      Descripción:
//              Crea el inventario software de un sistema operativo instalado en una partición.
//      Parámetros:
//              ptrTrama: contenido del mensaje
//      Devuelve:
//              TRUE: Si el proceso es correcto
//              FALSE: En caso de ocurrir algún error
//______________________________________________________________________________________________________
BOOLEAN InventarioSoftware(TRAMA* ptrTrama)
{
        char *nfn,*ids,msglog[LONSTD];
        char modulo[] = "InventarioSoftware()";

        if (ndebug>=DEBUG_MAXIMO) {
                sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
                infoDebug(msglog);
        }
        nfn=copiaParametro("nfn",ptrTrama);
        ids=copiaParametro("ids",ptrTrama);
        muestraMensaje(7,NULL);
        InventariandoSoftware(ptrTrama,TRUE,nfn);
        respuestaEjecucionComando(ptrTrama,herror,ids);
        liberaMemoria(nfn);
        liberaMemoria(ids);             
        muestraMenu();
        return(TRUE);
}
// ________________________________________________________________________________________________________
//
// Función: InventariandoSoftware
//
//      Descripción:
//              Envia al servidor el nombre del archivo de inventario de su software para posteriormente
//              esperar que éste lo solicite y enviarlo por la red.
//      Parámetros:
//              ptrTrama: contenido del mensaje
//              sw: switch que indica si la función es llamada por el comando InventarioSoftware(true) o CrearImagen(false)
//              nfn: Nombre de la función del Interface que implementa el comando
//      Devuelve:
//              TRUE: Si el proceso es correcto
//              FALSE: En caso de ocurrir algún error
//______________________________________________________________________________________________________
BOOLEAN InventariandoSoftware(TRAMA* ptrTrama,BOOLEAN sw,char *nfn)
{
        int lon;
        SOCKET socket_c;
        char *dsk,*par,msglog[LONSTD],sftsrc[LONPRM],sftdst[LONPRM];
        char modulo[] = "InventariandoSoftware()";

        dsk=copiaParametro("dsk",ptrTrama); // Disco
        par=copiaParametro("par",ptrTrama);

        sprintf(interface,"%s/%s",pathinterface,nfn);
        sprintf(sftsrc,"/tmp/CSft-%s-%s",IPlocal,par); // Nombre que tendra el archivo de inventario
        sprintf(parametros,"%s %s %s %s",nfn,dsk,par,sftsrc);

        herror=interfaceAdmin(interface,parametros,NULL);
        herror=0;
        if(herror){
                sprintf(msglog,"%s:%s",tbErrores[86],nfn);
                errorInfo(modulo,msglog);
                muestraMensaje(20,NULL);
        }
        else{
                /* Envía fichero de inventario al servidor */
                sprintf(sftdst,"/tmp/Ssft-%s-%s",IPlocal,par); // Nombre que tendra el archivo en el Servidor
                initParametros(ptrTrama,0);

                sprintf(ptrTrama->parametros,"nfn=recibeArchivo\rnfl=%s\r",sftdst);
                if(!enviaMensajeServidor(&socket_c,ptrTrama,MSG_COMANDO)){
                        errorLog(modulo,42,FALSE);
                        liberaMemoria(dsk);
                        liberaMemoria(par);                             
                        return(FALSE);
                }
                /* Espera señal para comenzar el envío */
                liberaMemoria(ptrTrama);
                if(!recibeFlag(&socket_c,ptrTrama)){
                        errorLog(modulo,17,FALSE);
                }
                /* Envía archivo */
                if(!sendArchivo(&socket_c,sftsrc)){
                        errorLog(modulo,57, FALSE);
                        herror=12; // Error de envío de fichero por la red
                }
                close(socket_c);
                muestraMensaje(19,NULL);
        }
        initParametros(ptrTrama,0);
        lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_InventarioSoftware");
        lon+=sprintf(ptrTrama->parametros+lon,"par=%s\r",par);
        lon+=sprintf(ptrTrama->parametros+lon,"sft=%s\r",sftdst);
        if(!sw)
                respuestaEjecucionComando(ptrTrama,herror,"0");

        liberaMemoria(dsk);
        liberaMemoria(par);                     
        return(TRUE);
}
// ________________________________________________________________________________________________________
// Función: EjecutarScript
//
//      Descripción:
//              Ejecuta código de script
//      Parámetros:
//              ptrTrama: contenido del mensaje
//      Devuelve:
//              TRUE: Si el proceso es correcto
//              FALSE: En caso de ocurrir algún error
//______________________________________________________________________________________________________
BOOLEAN EjecutarScript(TRAMA* ptrTrama)
{
        int lon;
        char *nfn,*aux,*ids,*scp,*cfg,msglog[LONSTD];
        char modulo[] = "EjecutarScript()";

        if (ndebug>=DEBUG_MAXIMO) {
                sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
                infoDebug(msglog);
        }
        aux=copiaParametro("scp",ptrTrama);
        scp=URLDecode(aux);


        muestraMensaje(8,NULL);
        /* Nombre del archivo de script */
        char filescript[LONPRM];
        sprintf(filescript,"/tmp/_script_%s",IPlocal);
        escribeArchivo(filescript,scp);
        nfn=copiaParametro("nfn",ptrTrama);
        sprintf(interface,"%s/%s",pathinterface,nfn);
        sprintf(parametros,"%s %s",nfn,filescript);
        herror=interfaceAdmin(interface,parametros,NULL);
        if(herror){
                sprintf(msglog,"%s:%s",tbErrores[86],nfn);
                errorInfo(modulo,msglog);
                muestraMensaje(21,NULL);
        }
        else
                muestraMensaje(22,NULL);

        // Toma configuración de particiones
        cfg=LeeConfiguracion();
        if(!cfg){ // No se puede recuperar la configuración del cliente
                errorLog(modulo,36,FALSE);
                herror=36;
        }

        ids=copiaParametro("ids",ptrTrama);

        //herror=ejecutarCodigoBash(scp);
        initParametros(ptrTrama,0);
        lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_EjecutarScript");
        lon+=sprintf(ptrTrama->parametros+lon,"cfg=%s\r",cfg); // Configuración de los Sistemas Operativos del cliente
        respuestaEjecucionComando(ptrTrama,herror,ids);
        
        liberaMemoria(nfn);
        liberaMemoria(ids);             
        liberaMemoria(aux);             
        liberaMemoria(scp);     
        liberaMemoria(cfg);

        muestraMenu();

        return(TRUE);
}
//______________________________________________________________________________________________________
// Función: respuestaEjecucionComando
//
//      Descripción:
//              Envia una respuesta a una ejecucion de comando al servidor de Administración
//      Parámetros:
//              - ptrTrama: contenido del mensaje
//              - res: Resultado de la ejecución (Código de error devuelto por el script ejecutado)
//              - ids: Identificador de la sesion (En caso de no haber seguimiento es NULO)
//      Devuelve:
//              TRUE: Si el proceso es correcto
//              FALSE: En caso de ocurrir algún error
// ________________________________________________________________________________________________________
BOOLEAN respuestaEjecucionComando(TRAMA* ptrTrama,int res,char *ids)
{
        int lon;
        SOCKET socket_c;
        char modulo[] = "respuestaEjecucionComando()";

        lon=strlen(ptrTrama->parametros);
        if(ids){ // Existe seguimiento
                lon+=sprintf(ptrTrama->parametros+lon,"ids=%s\r",ids); // Añade identificador de la sesión
        }
        if (res==0){ // Resultado satisfactorio
                lon+=sprintf(ptrTrama->parametros+lon,"res=%s\r","1");
                lon+=sprintf(ptrTrama->parametros+lon,"der=%s\r","");
        }
        else{ // Algún error
                lon+=sprintf(ptrTrama->parametros+lon,"res=%s\r","2");
                if(res>MAXERRORSCRIPT)
                        lon+=sprintf(ptrTrama->parametros+lon,"der=%s (Error de script:%d)\r",tbErroresScripts[0],res);// Descripción del error
                else
                        lon+=sprintf(ptrTrama->parametros+lon,"der=%s\r",tbErroresScripts[res]);// Descripción del error
        }
        if(!(enviaMensajeServidor(&socket_c,ptrTrama,MSG_NOTIFICACION))){
                errorLog(modulo,44,FALSE);
                return(FALSE);
        }

        close(socket_c);
        return(TRUE);
}
// ________________________________________________________________________________________________________
// Función: gestionaTrama
//
//      Descripción:
//              Procesa las tramas recibidas.
//      Parametros:
//              ptrTrama: contenido del mensaje
//      Devuelve:
//              TRUE: Si el proceso es correcto
//              FALSE: En caso de ocurrir algún error
// ________________________________________________________________________________________________________
BOOLEAN gestionaTrama(TRAMA *ptrTrama)
{
        int i, res;
        char *nfn;
        char modulo[] = "gestionaTrama()";

        INTROaFINCAD(ptrTrama);
        nfn = copiaParametro("nfn", ptrTrama); // Toma nombre de función
        for (i = 0; i < MAXIMAS_FUNCIONES; i++) { // Recorre funciones que procesan las tramas
                res = strcmp(tbfuncionesClient[i].nf, nfn);
                if (res == 0) { // Encontrada la función que procesa el mensaje
                        liberaMemoria(nfn);
                        return(tbfuncionesClient[i].fptr(ptrTrama)); // Invoca la función
                }
        }

        liberaMemoria(nfn);

        /* Sólo puede ser un comando personalizado
        if (ptrTrama->tipo==MSG_COMANDO)
                return(Comando(ptrTrama));
         */
        errorLog(modulo, 18, FALSE);
        return (FALSE);
}
//________________________________________________________________________________________________________
//      Función: ejecutaArchivo
//
//      Descripción:
//              Ejecuta los comando contenido en un archivo (cada comando y sus parametros separados por un
//              salto de linea.
//      Parámetros:
//              filecmd: Nombre del archivo de comandos
//              ptrTrama: Puntero a una estructura TRAMA usada en las comunicaciones por red (No debe ser NULL)
//      Devuelve:
//              TRUE: Si el proceso es correcto
//              FALSE: En caso de ocurrir algún error
//________________________________________________________________________________________________________
BOOLEAN ejecutaArchivo(char* filecmd,TRAMA *ptrTrama)
{
        char* buffer,*lineas[MAXIMAS_LINEAS];
        int i,numlin;
        char modulo[] = "ejecutaArchivo()";

        buffer=leeArchivo(filecmd);
        if(buffer){
                numlin = splitCadena(lineas, buffer, '@');
                initParametros(ptrTrama,0);
                for (i = 0; i < numlin; i++) {
                        if(strlen(lineas[i])>0){
                                strcpy(ptrTrama->parametros,lineas[i]);
                                //strcat(ptrTrama->parametros,"\rMCDJ@");       // Fin de trama
                                if(!gestionaTrama(ptrTrama)){   // Análisis de la trama
                                        errorLog(modulo,39,FALSE);
                                        //return(FALSE);
                                }
                        }
                }
        }
        liberaMemoria(buffer);
        return(TRUE);
}
//______________________________________________________________________________________________________
// Función: enviaMensajeServidor
//
//      Descripción:
//              Envia un mensaje al servidor de Administración
//      Parámetros:
//              - socket_c: (Salida) Socket utilizado para el envío
//              - ptrTrama: contenido del mensaje
//              - tipo: Tipo de mensaje
//                              C=Comando, N=Respuesta a un comando, P=Peticion,R=Respuesta a una petición, I=Informacion
//      Devuelve:
//              TRUE: Si el proceso es correcto
//              FALSE: En caso de ocurrir algún error
// ________________________________________________________________________________________________________
BOOLEAN enviaMensajeServidor(SOCKET *socket_c,TRAMA *ptrTrama,char tipo)
{
        int lon;
        char modulo[] = "enviaMensajeServidor()";

        *socket_c=abreConexion();
        if(*socket_c==INVALID_SOCKET){
                errorLog(modulo,38,FALSE); // Error de conexión con el servidor
                return(FALSE);
        }
        ptrTrama->arroba='@'; // Cabecera de la trama
        strncpy(ptrTrama->identificador,"JMMLCAMDJ_MCDJ",14);   // identificador de la trama
        ptrTrama->tipo=tipo; // Tipo de mensaje
        lon=strlen(ptrTrama->parametros); // Compone la trama
        lon+=sprintf(ptrTrama->parametros+lon,"iph=%s\r",IPlocal);      // Ip del ordenador
        lon+=sprintf(ptrTrama->parametros+lon,"ido=%s\r",idordenador);  // Identificador del ordenador
        lon+=sprintf(ptrTrama->parametros+lon,"npc=%s\r",nombreordenador);      // Nombre del ordenador
        lon+=sprintf(ptrTrama->parametros+lon,"idc=%s\r",idcentro);     // Identificador del centro
        lon+=sprintf(ptrTrama->parametros+lon,"ida=%s\r",idaula);       // Identificador del aula

        if (!mandaTrama(socket_c,ptrTrama)) {
                errorLog(modulo,26,FALSE);
                return (FALSE);
        }
        return(TRUE);
}
// ********************************************************************************************************
// PROGRAMA PRINCIPAL (CLIENTE)
// ********************************************************************************************************
int main(int argc, char *argv[])
{
        TRAMA *ptrTrama;
        char modulo[] = "main()";

        ptrTrama=(TRAMA *)reservaMemoria(sizeof(TRAMA));
        if (ptrTrama == NULL) { // No hay memoria suficiente para el bufer de las tramas
                errorLog(modulo, 3, FALSE);
                exit(EXIT_FAILURE);
        }
        /*--------------------------------------------------------------------------------------------------------
                Validación de parámetros de ejecución y fichero de configuración 
         ---------------------------------------------------------------------------------------------------------*/
        if (!validacionParametros(argc, argv,3)) // Valida parámetros de ejecución
                exit(EXIT_FAILURE);

        if (!tomaConfiguracion(szPathFileCfg)) // Toma parametros de configuración
                exit(EXIT_FAILURE);
        /*--------------------------------------------------------------------------------------------------------
                Carga catálogo de funciones que procesan las tramas 
         ---------------------------------------------------------------------------------------------------------*/
        int cf = 0;

        strcpy(tbfuncionesClient[cf].nf, "RESPUESTA_AutoexecCliente");
        tbfuncionesClient[cf++].fptr = &RESPUESTA_AutoexecCliente;

        strcpy(tbfuncionesClient[cf].nf, "RESPUESTA_InclusionCliente");
        tbfuncionesClient[cf++].fptr = &RESPUESTA_InclusionCliente;

        strcpy(tbfuncionesClient[cf].nf, "NoComandosPtes");
        tbfuncionesClient[cf++].fptr = &NoComandosPtes;

        strcpy(tbfuncionesClient[cf].nf, "Actualizar");
        tbfuncionesClient[cf++].fptr = &Actualizar;

        strcpy(tbfuncionesClient[cf].nf, "Purgar");
        tbfuncionesClient[cf++].fptr = &Purgar;

        strcpy(tbfuncionesClient[cf].nf, "ConsolaRemota");
        tbfuncionesClient[cf++].fptr = &ConsolaRemota;

        strcpy(tbfuncionesClient[cf].nf, "Sondeo");
        tbfuncionesClient[cf++].fptr = &Sondeo;

        strcpy(tbfuncionesClient[cf].nf, "Arrancar");
        tbfuncionesClient[cf++].fptr = &Arrancar;

        strcpy(tbfuncionesClient[cf].nf, "Apagar");
        tbfuncionesClient[cf++].fptr = &Apagar;

        strcpy(tbfuncionesClient[cf].nf, "Reiniciar");
        tbfuncionesClient[cf++].fptr = &Reiniciar;

        strcpy(tbfuncionesClient[cf].nf, "IniciarSesion");
        tbfuncionesClient[cf++].fptr = &IniciarSesion;

        strcpy(tbfuncionesClient[cf].nf, "CrearImagen");
        tbfuncionesClient[cf++].fptr = &CrearImagen;

        strcpy(tbfuncionesClient[cf].nf, "CrearImagenBasica");
        tbfuncionesClient[cf++].fptr = &CrearImagenBasica;

        strcpy(tbfuncionesClient[cf].nf, "CrearSoftIncremental");
        tbfuncionesClient[cf++].fptr = &CrearSoftIncremental;

        strcpy(tbfuncionesClient[cf].nf, "RestaurarImagen");
        tbfuncionesClient[cf++].fptr = &RestaurarImagen;

        strcpy(tbfuncionesClient[cf].nf, "RestaurarImagenBasica");
        tbfuncionesClient[cf++].fptr = &RestaurarImagenBasica;

        strcpy(tbfuncionesClient[cf].nf, "RestaurarSoftIncremental");
        tbfuncionesClient[cf++].fptr = &RestaurarSoftIncremental;


        strcpy(tbfuncionesClient[cf].nf, "Configurar");
        tbfuncionesClient[cf++].fptr = &Configurar;

        strcpy(tbfuncionesClient[cf].nf, "EjecutarScript");
        tbfuncionesClient[cf++].fptr = &EjecutarScript;

        strcpy(tbfuncionesClient[cf].nf, "InventarioHardware");
        tbfuncionesClient[cf++].fptr = &InventarioHardware;

        strcpy(tbfuncionesClient[cf].nf, "InventarioSoftware");
        tbfuncionesClient[cf++].fptr = &InventarioSoftware;

        /*--------------------------------------------------------------------------------------------------------
                Toma dirección IP del cliente   
         ---------------------------------------------------------------------------------------------------------*/
        if(!tomaIPlocal()){ // Error al recuperar la IP local
                errorLog(modulo,0,FALSE);
                exit(EXIT_FAILURE);
        }
        /*--------------------------------------------------------------------------------------------------------
                Inicio de sesión
         ---------------------------------------------------------------------------------------------------------*/
        infoLog(1); // Inicio de sesión
        infoLog(3); // Abriendo sesión en el servidor de Administración;                
        /*--------------------------------------------------------------------------------------------------------
                Inclusión del cliente en el sistema
         ---------------------------------------------------------------------------------------------------------*/
        if(!inclusionCliente(ptrTrama)){        // Ha habido algún problema al abrir sesión
                errorLog(modulo,0,FALSE);
                exit(EXIT_FAILURE);
        }
        infoLog(4); // Cliente iniciado

        /*--------------------------------------------------------------------------------------------------------
                Procesamiento de la cache
         ---------------------------------------------------------------------------------------------------------*/
        infoLog(23); // Abriendo sesión en el servidor de Administración;
        if(!cuestionCache(cache)){
                errorLog(modulo,0,FALSE);
                exit(EXIT_FAILURE);
        }
        /*--------------------------------------------------------------------------------------------------------
                Ejecución del autoexec
         ---------------------------------------------------------------------------------------------------------*/
        if(atoi(idproautoexec)>0){  // Ejecución de procedimiento Autoexec
                infoLog(5);
                if(!autoexecCliente(ptrTrama)){  // Ejecución fichero autoexec
                        errorLog(modulo,0,FALSE);
                        exit(EXIT_FAILURE);
                }
        }
        /*--------------------------------------------------------------------------------------------------------
                Comandos pendientes
         ---------------------------------------------------------------------------------------------------------*/
        infoLog(6); // Procesa comandos pendientes
        if(!comandosPendientes(ptrTrama)){  // Ejecución de acciones pendientes
                errorLog(modulo,0,FALSE);
                exit(EXIT_FAILURE);
        }
        infoLog(7); // Acciones pendientes procesadas
        /*--------------------------------------------------------------------------------------------------------
                Bucle de recepción de comandos
         ---------------------------------------------------------------------------------------------------------*/
        muestraMenu();
        procesaComandos(ptrTrama); // Bucle para procesar comandos interactivos
        /*--------------------------------------------------------------------------------------------------------
                Fin de la sesión
         ---------------------------------------------------------------------------------------------------------*/
        exit(EXIT_SUCCESS);
}