diff options
Diffstat (limited to 'sources')
| -rw-r--r-- | sources/ogAdmServer.cpp | 3027 | ||||
| -rw-r--r-- | sources/ogAdmServer.h | 118 |
2 files changed, 3145 insertions, 0 deletions
diff --git a/sources/ogAdmServer.cpp b/sources/ogAdmServer.cpp new file mode 100644 index 0000000..25316df --- /dev/null +++ b/sources/ogAdmServer.cpp @@ -0,0 +1,3027 @@ +// ******************************************************************************************************** +// Servicio: ogAdmServer +// Autor: José Manuel Alonso (E.T.S.I.I.) Universidad de Sevilla +// Fecha Creación: Marzo-2010 +// Fecha Última modificación: Marzo-2010 +// Nombre del fichero: ogAdmServer.cpp +// Descripción :Este fichero implementa el servicio de administración general del sistema +// ******************************************************************************************************** +#include "ogAdmServer.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 servicio vacío + return (FALSE); + } + FILE *fcfg; + long 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 servicio + 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); + } + fread(buffer, 1, lSize, fcfg); // Lee contenido del fichero + buffer[lSize] = (char) NULL; + fclose(fcfg); + + servidoradm[0] = (char) NULL; //inicializar variables globales + puerto[0] = (char) NULL; + usuario[0] = (char) NULL; + pasguor[0] = (char) NULL; + datasource[0] = (char) NULL; + catalog[0] = (char) NULL; + aulaup[0] = (char) NULL; + + 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]), "USUARIO"); + if (resul == 0) + strcpy(usuario, dualparametro[1]); + resul = strcmp(StrToUpper(dualparametro[0]), "PASSWORD"); + if (resul == 0) + strcpy(pasguor, dualparametro[1]); + resul = strcmp(StrToUpper(dualparametro[0]), "DATASOURCE"); + if (resul == 0) + strcpy(datasource, dualparametro[1]); + resul = strcmp(StrToUpper(dualparametro[0]), "CATALOG"); + if (resul == 0) + strcpy(catalog, dualparametro[1]); + resul = strcmp(StrToUpper(dualparametro[0]), "AULAUP"); + if (resul == 0) + strcpy(catalog, dualparametro[1]); + } + if (servidoradm[0] == (char) NULL) { + errorLog(modulo, 4, FALSE); // Falta parámetro SERVIDORADM + return (FALSE); + } + if (puerto[0] == (char) NULL) { + errorLog(modulo, 5, FALSE); // Falta parámetro PUERTO + return (FALSE); + } + if (usuario[0] == (char) NULL) { + errorLog(modulo, 6, FALSE); // Falta parámetro USUARIO + return (FALSE); + } + if (pasguor[0] == (char) NULL) { + errorLog(modulo, 7, FALSE); // Falta parámetro PASSWORD + return (FALSE); + } + if (datasource[0] == (char) NULL) { + errorLog(modulo, 8, FALSE); // Falta parámetro DATASOURCE + return (FALSE); + } + if (catalog[0] == (char) NULL) { + errorLog(modulo, 9, FALSE); // Falta parámetro CATALOG + return (FALSE); + } + if (aulaup[0] == (char) NULL) { + strcpy(aulaup, "0"); // Por defecto el conmutador de registro automático esta en off + } + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: gestionaTrama +// +// Descripción: +// Procesa las tramas recibidas . +// Parametros: +// - s : Socket usado para comunicaciones +// Devuelve: +// TRUE: Si el proceso es correcto +// FALSE: En caso de ocurrir algún error +// ________________________________________________________________________________________________________ +BOOLEAN gestionaTrama(SOCKET *socket_c) +{ + TRAMA* ptrTrama; + int i, res; + char *nfn; + char modulo[] = "gestionaTrama()"; + + ptrTrama=recibeTrama(socket_c); + if (ptrTrama){ + INTROaFINCAD(ptrTrama); + nfn = copiaParametro("nfn",ptrTrama); // Toma dirección/es IP + for (i = 0; i < MAXIMAS_FUNCIONES; i++) { // Recorre funciones que procesan las tramas + res = strcmp(tbfuncionesServer[i].nf, nfn); + if (res == 0) { // Encontrada la función que procesa el mensaje + return (tbfuncionesServer[i].fptr(socket_c, ptrTrama)); // Invoca la función + } + } + /* Sólo puede ser un comando personalizado o su notificación */ + if (ptrTrama->tipo == MSG_COMANDO) + return (Comando(socket_c, ptrTrama)); + else { + if (ptrTrama->tipo == MSG_NOTIFICACION) + return (RESPUESTA_Comando(socket_c, ptrTrama)); + else + errorLog(modulo, 18, FALSE); // No se reconoce el mensaje + } + } + else + errorLog(modulo, 17, FALSE); // Error en la recepción + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: Sondeo +// +// Descripción: +// Solicita a los clientes su disponibiliad para recibir comandos interactivos +// Parámetros: +// - socket_c: Socket del cliente que envió el mensaje +// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros del mensaje +// Devuelve: +// TRUE: Si el proceso es correcto +// FALSE: En caso de ocurrir algún error +// ________________________________________________________________________________________________________ +BOOLEAN Sondeo(SOCKET *socket_c, TRAMA* ptrTrama) { + char msglog[LONSTD]; + char modulo[] = "Sondeo()"; + + if (!enviaComando(ptrTrama, CLIENTE_APAGADO)) { + sprintf(msglog, "%s:%s", tbErrores[32], modulo); + errorInfo(modulo, msglog); + respuestaConsola(socket_c, ptrTrama, FALSE); + return (FALSE); + } + respuestaConsola(socket_c, ptrTrama, TRUE); + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: respuestaSondeo +// +// Descripción: +// Recupera el estatus de los ordenadores solicitados leyendo la tabla de sockets +// Parámetros: +// - socket_c: Socket del cliente que envió el mensaje +// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros del mensaje +// Devuelve: +// TRUE: Si el proceso es correcto +// FALSE: En caso de ocurrir algún error +// ________________________________________________________________________________________________________ +BOOLEAN respuestaSondeo(SOCKET *socket_c, TRAMA* ptrTrama) { + int i; + long lSize; + char *iph, *Ipes; + char modulo[] = "respuestaSondeo()"; + + iph = copiaParametro("iph",ptrTrama); // Toma dirección/es IP + lSize = strlen(iph); // Calcula longitud de la cadena de direccion/es IPE/S + Ipes = (char*) reservaMemoria(lSize + 1); + if (Ipes == NULL) { + errorLog(modulo, 3, FALSE); + return (FALSE); + } + strcpy(Ipes, iph); // Copia cadena de IPES + initParametros(ptrTrama,0); + strcpy(ptrTrama->parametros, "tso="); // Compone retorno tso (sistemas operativos de los clientes ) + for (i = 0; i < MAXIMOS_CLIENTES; i++) { + if (strncmp(tbsockets[i].ip, "\0", 1) != 0) { // Si es un cliente activo + if (contieneIP(Ipes, tbsockets[i].ip)) { // Si existe la IP en la cadena + strcat(ptrTrama->parametros, tbsockets[i].ip); // Compone retorno + strcat(ptrTrama->parametros, "/"); // "ip/sistema operativo;" + strcat(ptrTrama->parametros, tbsockets[i].estado); + strcat(ptrTrama->parametros, ";"); + } + } + } + strcat(ptrTrama->parametros, "\r"); + if (!mandaTrama(socket_c, ptrTrama)) { + errorLog(modulo, 26, FALSE); + return (FALSE); + } + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: Actualizar +// +// Descripción: +// Obliga a los clientes a iniciar sesión en el sistema +// Parámetros: +// - socket_c: Socket del cliente que envió el mensaje +// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros del mensaje +// Devuelve: +// TRUE: Si el proceso es correcto +// FALSE: En caso de ocurrir algún error +// ________________________________________________________________________________________________________ +BOOLEAN Actualizar(SOCKET *socket_c, TRAMA* ptrTrama) { + char msglog[LONSTD]; + char modulo[] = "Actualizar()"; + + if (!enviaComando(ptrTrama, CLIENTE_APAGADO)) { + sprintf(msglog, "%s:%s", tbErrores[32], modulo); + errorInfo(modulo, msglog); + return (FALSE); + } + respuestaConsola(socket_c, ptrTrama, TRUE); + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: Purgar +// +// Descripción: +// Detiene la ejecución del browser en el cliente +// Parámetros: +// - socket_c: Socket del cliente que envió el mensaje +// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros del mensaje +// Devuelve: +// TRUE: Si el proceso es correcto +// FALSE: En caso de ocurrir algún error +// ________________________________________________________________________________________________________ +BOOLEAN Purgar(SOCKET *socket_c, TRAMA* ptrTrama) { + char msglog[LONSTD]; + char modulo[] = "Purgar()"; + + if (!enviaComando(ptrTrama, CLIENTE_APAGADO)) { + sprintf(msglog, "%s:%s", tbErrores[32], modulo); + errorInfo(modulo, msglog); + return (FALSE); + } + respuestaConsola(socket_c, ptrTrama, TRUE); + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: ConsolaRemota +// +// Descripción: +// Envia un script al cliente, éste lo ejecuta y manda el archivo que genera la salida por pantalla +// Parámetros: +// - socket_c: Socket del cliente que envió el mensaje +// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros del mensaje +// Devuelve: +// TRUE: Si el proceso es correcto +// FALSE: En caso de ocurrir algún error +// ________________________________________________________________________________________________________ +BOOLEAN ConsolaRemota(SOCKET *socket_c, TRAMA* ptrTrama) +{ + char *iph,fileco[LONPRM],msglog[LONSTD],*ptrIpes[MAXIMOS_CLIENTES];; + FILE* f; + int i,lon; + char modulo[] = "ConsolaRemota()"; + + if (!enviaComando(ptrTrama, CLIENTE_OCUPADO)) { + sprintf(msglog, "%s:%s", tbErrores[32], modulo); + errorInfo(modulo, msglog); + respuestaConsola(socket_c, ptrTrama, FALSE); + return (FALSE); + } + INTROaFINCAD(ptrTrama); + /* Destruye contenido del fichero de eco anterior */ + iph = copiaParametro("iph",ptrTrama); // Toma dirección ip del cliente + lon = splitCadena(ptrIpes,iph,';'); + for (i = 0; i < lon; i++) { + sprintf(fileco,"/tmp/_Seconsola_%s",ptrIpes[i]); // Nombre que tendra el archivo en el Servidor + f = fopen(fileco, "wt"); + fclose(f); + } + respuestaConsola(socket_c, ptrTrama, TRUE); + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: EcoConsola +// +// Descripción: +// Solicita el eco de una consola remota almacenado en un archivo de eco +// Parámetros: +// - socket_c: Socket del cliente que envió el mensaje +// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros del mensaje +// Devuelve: +// TRUE: Si el proceso es correcto +// FALSE: En caso de ocurrir algún error +// ________________________________________________________________________________________________________ +BOOLEAN EcoConsola(SOCKET *socket_c, TRAMA* ptrTrama) +{ + char *iph,fileco[LONPRM],*buffer; + int lSize; + char modulo[] = "EcoConsola()"; + + INTROaFINCAD(ptrTrama); + // Lee archivo de eco de consola + iph = copiaParametro("iph",ptrTrama); // Toma dirección ip del cliente + sprintf(fileco,"/tmp/_Seconsola_%s",iph); // Nombre del archivo en el Servidor + lSize=lonArchivo(fileco); + if(lSize>0){ // Si el fichero tiene contenido... + initParametros(ptrTrama,lSize+LONGITUD_PARAMETROS); + buffer=leeArchivo(fileco); + sprintf(ptrTrama->parametros,"res=%s\r",buffer); + } + else{ + initParametros(ptrTrama,0); + sprintf(ptrTrama->parametros,"res=\r"); + } + ptrTrama->tipo=MSG_RESPUESTA; // Tipo de mensaje + if (!mandaTrama(socket_c, ptrTrama)) { + errorLog(modulo, 26, FALSE); + return (FALSE); + } + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: clienteDisponible +// +// Descripción: +// Comprueba la disponibilidad del cliente para recibir comandos interactivos +// Parametros: +// - ip : La ip del cliente a buscar +// - idx: (Salida) Indice que ocupa el cliente, de estar ya registrado +// Devuelve: +// TRUE: Si el cliente está disponible +// FALSE: En caso contrario +// ________________________________________________________________________________________________________ +BOOLEAN clienteDisponible(char *ip, int* idx) { + int estado; + + if (clienteExistente(ip, idx)) { + estado = strcmp(tbsockets[*idx].estado, CLIENTE_OCUPADO); // Cliente ocupado + if (estado == 0) + return (FALSE); + + estado = strcmp(tbsockets[*idx].estado, CLIENTE_APAGADO); // Cliente apagado + if (estado == 0) + return (FALSE); + + estado = strcmp(tbsockets[*idx].estado, CLIENTE_INICIANDO); // Cliente en proceso de inclusión + if (estado == 0) + return (FALSE); + + return (TRUE); // En caso contrario el cliente está disponible + } + return (FALSE); // Cliente no está registrado en el sistema +} +// ________________________________________________________________________________________________________ +// Función: clienteExistente +// +// Descripción: +// Comprueba si el cliente está registrado en la tabla de socket del sistema +// Parametros: +// - ip : La ip del cliente a buscar +// - idx:(Salida) Indice que ocupa el cliente, de estar ya registrado +// Devuelve: +// TRUE: Si el cliente está registrado +// FALSE: En caso contrario +// ________________________________________________________________________________________________________ +BOOLEAN clienteExistente(char *ip, int* idx) { + int i; + for (i = 0; i < MAXIMOS_CLIENTES; i++) { + if (contieneIP(ip, tbsockets[i].ip)) { // Si existe la IP en la cadena + *idx = i; + return (TRUE); + } + } + return (FALSE); +} +// ________________________________________________________________________________________________________ +// Función: hayHueco +// +// Descripción: +// Esta función devuelve TRUE o FALSE dependiendo de que haya hueco en la tabla de sockets para un nuevo cliente. +// Parametros: +// - idx: Primer indice libre que se podrn utilizar +// Devuelve: +// TRUE: Si el proceso es correcto +// FALSE: En caso de ocurrir algún error +// ________________________________________________________________________________________________________ +BOOLEAN hayHueco(int *idx) { + int i; + + for (i = 0; i < MAXIMOS_CLIENTES; i++) { + if (strncmp(tbsockets[i].ip, "\0", 1) == 0) { // Hay un hueco + *idx = i; + return (TRUE); + } + } + return (FALSE); +} +// ________________________________________________________________________________________________________ +// Función: InclusionCliente +// +// Descripción: +// Esta función incorpora el socket de un nuevo cliente a la tabla de clientes y le devuelve alguna de sus propiedades: +// nombre, identificador, tamaño de la caché , etc ... +// Parámetros: +// - socket_c: Socket del cliente que envió el mensaje +// - 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 InclusionCliente(SOCKET *socket_c, TRAMA *ptrTrama) { + char modulo[] = "InclusionCliente()"; + + if (!procesoInclusionCliente(socket_c, ptrTrama)) { // Ha habido algún error... + initParametros(ptrTrama,0); + strcpy(ptrTrama->parametros, "nfn=RESPUESTA_InclusionCliente\rres=0\r"); + if (!mandaTrama(socket_c, ptrTrama)) { + errorLog(modulo, 26, FALSE); + return (FALSE); + } + } + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: procesoInclusionCliente +// +// Descripción: +// Implementa el proceso de inclusión en el sistema del Cliente +// Parámetros: +// - socket_c: Socket del cliente que envió el mensaje +// - 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 procesoInclusionCliente(SOCKET *socket_c, TRAMA *ptrTrama) { + char msglog[LONSTD], sqlstr[LONSQL]; + Database db; + Table tbl; + + char *iph, *cfg; + char nombreordenador[LONFIL]; + int lon, resul, idordenador, idmenu, cache, idproautoexec, idaula, idcentro; + char modulo[] = "InclusionCliente()"; + + // Toma parámetros + iph = copiaParametro("iph",ptrTrama); // Toma ip + cfg = copiaParametro("cfg",ptrTrama); // Toma configuracion + + if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexión con la BD + errorLog(modulo, 20, FALSE); + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + + // Recupera los datos del cliente + sprintf(sqlstr, + "SELECT ordenadores.*,aulas.idaula,centros.idcentro FROM ordenadores " + " INNER JOIN aulas ON aulas.idaula=ordenadores.idaula" + " INNER JOIN centros ON centros.idcentro=aulas.idcentro" + " WHERE ordenadores.ip = '%s'", iph); + + if (!db.Execute(sqlstr, tbl)) { // Error al recuperar los datos + errorLog(modulo, 21, FALSE); + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + + if (tbl.ISEOF()) { // Si no existe el cliente + errorLog(modulo, 22, FALSE); + return (FALSE); + } + + if (ndebug == DEBUG_ALTO) { + sprintf(msglog, "%s IP:%s", tbMensajes[2], iph); + infoDebug(msglog); + } + if (!tbl.Get("idordenador", idordenador)) { + tbl.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + if (!tbl.Get("nombreordenador", nombreordenador)) { + tbl.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + if (!tbl.Get("idmenu", idmenu)) { + tbl.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + if (!tbl.Get("cache", cache)) { + tbl.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + if (!tbl.Get("idproautoexec", idproautoexec)) { + tbl.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + if (!tbl.Get("idaula", idaula)) { + tbl.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + if (!tbl.Get("idcentro", idcentro)) { + tbl.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + + resul = actualizaConfiguracion(db, tbl, cfg, idordenador); // Actualiza la configuración del ordenador + db.Close(); + + if (!resul) { + errorLog(modulo, 29, FALSE); + return (FALSE); + } + + if (!registraCliente(iph)) { // Incluyendo al cliente en la tabla de sokets + errorLog(modulo, 25, FALSE); + return (FALSE); + } + + /*------------------------------------------------------------------------------------------------------------------------------ + Prepara la trama de respuesta + -------------------------------------------------------------------------------------------------------------------------------*/ + initParametros(ptrTrama,0); + ptrTrama->tipo=MSG_RESPUESTA; + lon = sprintf(ptrTrama->parametros, "nfn=RESPUESTA_InclusionCliente\r"); + lon += sprintf(ptrTrama->parametros + lon, "ido=%d\r", idordenador); + lon += sprintf(ptrTrama->parametros + lon, "npc=%s\r", nombreordenador); + lon += sprintf(ptrTrama->parametros + lon, "che=%d\r", cache); + lon += sprintf(ptrTrama->parametros + lon, "exe=%d\r", idproautoexec); + lon += sprintf(ptrTrama->parametros + lon, "ida=%d\r", idaula); + lon += sprintf(ptrTrama->parametros + lon, "idc=%d\r", idcentro); + lon += sprintf(ptrTrama->parametros + lon, "res=%d\r", 1); // Confirmación proceso correcto + + if (!mandaTrama(socket_c, ptrTrama)) { + errorLog(modulo, 26, FALSE); + return (FALSE); + } + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: actualizaConfiguracion +// +// Descripción: +// Esta función actualiza la base de datos con la configuracion de particiones de un cliente +// Parámetros: +// - db: Objeto base de datos (ya operativo) +// - tbl: Objeto tabla +// - cfg: cadena con una Configuración +// - ido: Identificador del ordenador cliente +// Devuelve: +// TRUE: Si el proceso es correcto +// FALSE: En caso de ocurrir algún error +// Especificaciones: +// Los parametros de la configuración son: +// par= Número de partición +// cpt= Codigo o tipo de partición +// sfi= Sistema de ficheros que está implementado en la partición +// soi= Nombre del sistema de ficheros instalado en la partición +// tam= Tamaño de la partición +// ________________________________________________________________________________________________________ +BOOLEAN actualizaConfiguracion(Database db, Table tbl, char* cfg, int ido) +{ + char msglog[LONSTD], sqlstr[LONSQL]; + int lon, p, c, i, dato, swu, idsoi, idsfi,k; + char *ptrPar[MAXPAR], *ptrCfg[5], *ptrDual[2], tbPar[LONSTD]; + char *par, *cpt, *sfi, *soi, *tam; // Parametros que definen una partición + char modulo[] = "actualizaConfiguracion()"; + + lon = sprintf(tbPar, "("); + p = splitCadena(ptrPar, cfg, '\n'); + for (i = 0; i < p; i++) { + c = splitCadena(ptrCfg, ptrPar[i], '\t'); + par = cpt = sfi = soi = tam = NULL; + splitCadena(ptrDual, ptrCfg[0], '='); + par = ptrDual[1]; // Número de partición + + splitCadena(ptrDual, ptrCfg[1], '='); + cpt = ptrDual[1]; // Código de partición + + k=splitCadena(ptrDual, ptrCfg[2], '='); + if(k==2){ + sfi = ptrDual[1]; // Sistema de ficheros + /* Comprueba existencia del sistema de ficheros instalado */ + idsfi = checkDato(db, tbl, sfi, "sistemasficheros", "descripcion","idsistemafichero"); + } + else + idsfi=0; + + k=splitCadena(ptrDual, ptrCfg[3], '='); + if(k==2){ // Sistema operativo detecdtado + soi = ptrDual[1]; // Nombre del S.O. instalado + /* Comprueba existencia del sistema operativo instalado */ + idsoi = checkDato(db, tbl, soi, "nombresos", "nombreso", "idnombreso"); + } + else + idsoi=0; + + splitCadena(ptrDual, ptrCfg[4], '='); + tam = ptrDual[1]; // Tamaño de la partición + + lon += sprintf(tbPar + lon, "%s,", par); + + sprintf( + sqlstr, + "SELECT numpar,codpar,tamano,idsistemafichero,idnombreso" + " FROM ordenadores_particiones WHERE idordenador=%d AND numpar=%s", + ido, par); + if (!db.Execute(sqlstr, tbl)) { // Error al recuperar los datos + errorLog(modulo, 21, FALSE); + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + if (tbl.ISEOF()) { // Si no existe el registro + sprintf( + sqlstr, + "INSERT INTO ordenadores_particiones(idordenador,numpar,codpar,tamano,idsistemafichero,idnombreso,idimagen)" + " VALUES(%d,%s,0x%s,%s,%d,%d,0)", ido, par, cpt, tam, + idsfi, idsoi); + + if (!db.Execute(sqlstr, tbl)) { // Error al insertar + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + } else { // Existe el registro + swu = TRUE; // Se supone que algún dato ha cambiado + if (!tbl.Get("codpar", dato)) { // Toma dato + tbl.GetErrorErrStr(msglog); // Error al acceder al registro + errorInfo(modulo, msglog); + return (FALSE); + } + if (atoi(cpt) == dato) {// Parámetro tipo de partición igual al almacenado + if (!tbl.Get("tamano", dato)) { // Toma dato + tbl.GetErrorErrStr(msglog); // Error al acceder al registro + errorInfo(modulo, msglog); + return (FALSE); + } + if (atoi(tam) == dato) {// Parámetro tamaño igual al almacenado + if (!tbl.Get("idsistemafichero", dato)) { // Toma dato + tbl.GetErrorErrStr(msglog); // Error al acceder al registro + errorInfo(modulo, msglog); + return (FALSE); + } + if (idsfi == dato) {// Parámetro sistema de fichero igual al almacenado + if (!tbl.Get("idnombreso", dato)) { // Toma dato + tbl.GetErrorErrStr(msglog); // Error al acceder al registro + errorInfo(modulo, msglog); + return (FALSE); + } + if (idsoi == dato) {// Parámetro sistema de fichero distinto al almacenado + swu = FALSE; // Todos los parámetros de la partición son iguales, no se actualiza + } + } + } + } + if (swu) { // Hay que actualizar los parámetros de la partición + sprintf(sqlstr, "UPDATE ordenadores_particiones SET " + " codpar=0x%s," + " tamano=%s," + " idsistemafichero=%d," + " idnombreso=%d," + " idimagen=%d," + " idperfilsoft=%d" + " WHERE idordenador=%d AND numpar=%s"\ +, cpt, tam, idsfi, + idsoi, 0, 0, ido, par); + + if (!db.Execute(sqlstr, tbl)) { // Error al recuperar los datos + errorLog(modulo, 21, FALSE); + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + } + } + } + lon += sprintf(tbPar + lon, "%d)", 0); + // Eliminar particiones almacenadas que ya no existen + sprintf( + sqlstr, + "DELETE FROM ordenadores_particiones WHERE idordenador=%d AND numpar NOT IN %s", + ido, tbPar); + if (!db.Execute(sqlstr, tbl)) { // Error al recuperar los datos + errorLog(modulo, 21, FALSE); + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: checkDato +// +// Descripción: +// Esta función comprueba si existe un dato en una tabla y si no es así lo incluye. devuelve en +// cualquier caso el identificador del registro existenet o del insertado +// Parámetros: +// - db: Objeto base de datos (ya operativo) +// - tbl: Objeto tabla +// - dato: Dato +// - tabla: Nombre de la tabla +// - nomdato: Nombre del dato en la tabla +// - nomidentificador: Nombre del identificador en la tabla +// Devuelve: +// El identificador del registro existente o el del insertado +// +// Especificaciones: +// En caso de producirse algún error se devuelve el valor 0 +// ________________________________________________________________________________________________________ + +int checkDato(Database db, Table tbl, char *dato, const char*tabla, + const char* nomdato, const char *nomidentificador) { + char msglog[LONSTD], sqlstr[LONSQL]; + char modulo[] = "checkDato()"; + int identificador; + + if (strlen(dato) == 0) + return (0); // EL dato no tiene valor + sprintf(sqlstr, "SELECT %s FROM %s WHERE %s ='%s'", nomidentificador, + tabla, nomdato, dato); + + // Ejecuta consulta + if (!db.Execute(sqlstr, tbl)) { // Error al leer + errorLog(modulo, 21, FALSE); + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (0); + } + if (tbl.ISEOF()) { // Software NO existente + sprintf(sqlstr, "INSERT INTO %s (%s) VALUES('%s')", tabla, nomdato, + dato); + if (!db.Execute(sqlstr, tbl)) { // Error al insertar + db.GetErrorErrStr(msglog); // Error al acceder al registro + errorInfo(modulo, msglog); + return (0); + } + // Recupera el identificador del software + sprintf(sqlstr, "SELECT LAST_INSERT_ID() as identificador"); + if (!db.Execute(sqlstr, tbl)) { // Error al leer + db.GetErrorErrStr(msglog); // Error al acceder al registro + errorInfo(modulo, msglog); + return (0); + } + if (!tbl.ISEOF()) { // Si existe registro + if (!tbl.Get("identificador", identificador)) { + tbl.GetErrorErrStr(msglog); // Error al acceder al registro + errorInfo(modulo, msglog); + return (0); + } + } + } else { + if (!tbl.Get(nomidentificador, identificador)) { // Toma dato + tbl.GetErrorErrStr(msglog); // Error al acceder al registro + errorInfo(modulo, msglog); + return (0); + } + } + return (identificador); +} +// ________________________________________________________________________________________________________ +// Función: registraCliente +// +// Descripción: +// Incluye al cliente en la tabla de sokets +// Parámetros: +// - iph: Dirección ip del cliente +// Devuelve: +// TRUE: Si el proceso es correcto +// FALSE: En caso de ocurrir algún error +// ________________________________________________________________________________________________________ +BOOLEAN registraCliente(char *iph) { + int idx; + + if (!clienteExistente(iph, &idx)) { // Si no existe la IP ... + if (!hayHueco(&idx)) { // Busca hueco para el nuevo cliente + return (FALSE); // No hay huecos + } + } + strcpy(tbsockets[idx].ip, iph); // Copia IP + strcpy(tbsockets[idx].estado, CLIENTE_INICIANDO); // Actualiza el estado del cliente + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: AutoexecCliente +// +// Descripción: +// Envía archivo de autoexec al cliente +// Parámetros: +// - socket_c: Socket del cliente que envió el mensaje +// - 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 AutoexecCliente(SOCKET *socket_c, TRAMA *ptrTrama) { + int lon; + char *iph, *exe, msglog[LONSTD]; + Database db; + FILE *fileexe; + char fileautoexec[LONPRM]; + char parametros[LONGITUD_PARAMETROS]; + char modulo[] = "AutoexecCliente()"; + + iph = copiaParametro("iph",ptrTrama); // Toma dirección IP del cliente + exe = copiaParametro("exe",ptrTrama); // Toma identificador del procedimiento inicial + + sprintf(fileautoexec, "/tmp/Sautoexec-%s", iph); + fileexe = fopen(fileautoexec, "wb"); // Abre fichero de script + if (fileexe == NULL) { + errorLog(modulo, 52, FALSE); + return (FALSE); + } + + if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexión con la BD + errorLog(modulo, 20, FALSE); + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + initParametros(ptrTrama,0); + if (recorreProcedimientos(db, parametros, fileexe, exe)) { + lon = sprintf(ptrTrama->parametros, "nfn=RESPUESTA_AutoexecCliente\r"); + lon += sprintf(ptrTrama->parametros + lon, "nfl=%s\r", fileautoexec); + lon += sprintf(ptrTrama->parametros + lon, "res=1\r"); + } else { + lon = sprintf(ptrTrama->parametros, "nfn=RESPUESTA_AutoexecCliente\r"); + lon += sprintf(ptrTrama->parametros + lon, "res=0\r"); + } + + fclose(fileexe); + + if (!mandaTrama(socket_c, ptrTrama)) { + errorLog(modulo, 26, FALSE); + return (FALSE); + } + + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: recorreProcedimientos +// +// Descripción: +// Crea un archivo con el código de un procedimiento separando cada comando por un salto de linea +// Parámetros: +// Database db,char* parametros,FILE* fileexe,char* idp +// Devuelve: +// TRUE: Si el proceso es correcto +// FALSE: En caso de ocurrir algún error +// ________________________________________________________________________________________________________ +BOOLEAN recorreProcedimientos(Database db, char* parametros, FILE* fileexe, + char* idp) { + int procedimientoid, lsize; + char idprocedimiento[LONPRM], msglog[LONSTD], sqlstr[LONSQL]; + Table tbl; + char modulo[] = "recorreProcedimientos()"; + + /* Busca procedimiento */ + sprintf(sqlstr, + "SELECT procedimientoid,parametros FROM procedimientos_acciones" + " WHERE idprocedimiento=%s ORDER BY orden", idp); + // Ejecuta consulta + if (!db.Execute(sqlstr, tbl)) { // Error al leer + errorLog(modulo, 21, FALSE); + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + while (!tbl.ISEOF()) { // Recorre procedimientos + if (!tbl.Get("procedimientoid", procedimientoid)) { // Toma dato + tbl.GetErrorErrStr(msglog); // Error al acceder al registro + errorInfo(modulo, msglog); + return (FALSE); + } + if (procedimientoid > 0) { // Procedimiento recursivo + sprintf(idprocedimiento, "%d", procedimientoid); + if (!recorreProcedimientos(db, parametros, fileexe, idprocedimiento)) { + return (FALSE); + } + } else { + if (!tbl.Get("parametros", parametros)) { // Toma dato + tbl.GetErrorErrStr(msglog); // Error al acceder al registro + errorInfo(modulo, msglog); + return (FALSE); + } + strcat(parametros, "@"); + lsize = strlen(parametros); + fwrite(parametros, 1, lsize, fileexe); // Escribe el código a ejecutar + } + tbl.MoveNext(); + } + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: ComandosPendientes +// +// Descripción: +// Esta función busca en la base de datos,comandos pendientes de ejecutar por un ordenador concreto +// Parámetros: +// - socket_c: Socket del cliente que envió el mensaje +// - 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 ComandosPendientes(SOCKET *socket_c, TRAMA *ptrTrama) { + char *ido, pids[LONPRM], iph[LONIP]; + int ids, idx; + char modulo[] = "ComandosPendientes()"; + + strcpy(iph, copiaParametro("iph",ptrTrama)); // Toma direción IP + ido = copiaParametro("ido",ptrTrama); // Toma identificador del ordenador + + if (!clienteExistente(iph, &idx)) { // Busca índice del cliente + errorLog(modulo, 47, FALSE); + return (FALSE); + } + if (buscaComandos(ido, ptrTrama, &ids)) { // Existen comandos pendientes + ptrTrama->tipo = MSG_COMANDO; + sprintf(pids, "\rids=%d\r", ids); + strcat(ptrTrama->parametros, pids); + strcpy(tbsockets[idx].estado, CLIENTE_OCUPADO); + } else { + initParametros(ptrTrama,0); + strcpy(ptrTrama->parametros, "nfn=NoComandosPtes\r"); + } + if (!mandaTrama(socket_c, ptrTrama)) { + errorLog(modulo, 26, FALSE); + return (FALSE); + } + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: buscaComandos +// +// Descripción: +// Busca en la base de datos,comandos pendientes de ejecutar por el cliente +// Parámetros: +// - ido: Identificador del ordenador +// - cmd: Parámetros del comando (Salida) +// - ids: Identificador de la acción (Salida) +// Devuelve: +// TRUE: Si el proceso es correcto +// FALSE: En caso de ocurrir algún error +// ________________________________________________________________________________________________________ +BOOLEAN buscaComandos(char *ido, TRAMA *ptrTrama, int *ids) +{ + char msglog[LONSTD], sqlstr[LONSQL]; + Database db; + Table tbl; + int lonprm; + + char modulo[] = "buscaComandos()"; + + if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexión con la BD + errorLog(modulo, 20, FALSE); + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + sprintf(sqlstr,"SELECT sesion,parametros,length( parametros) as lonprm"\ + " FROM acciones WHERE idordenador=%s AND estado='%d' ORDER BY idaccion", ido, ACCION_INICIADA); + if (!db.Execute(sqlstr, tbl)) { // Error al recuperar los datos + errorLog(modulo, 21, FALSE); + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + if (tbl.ISEOF()) { + db.Close(); + return (FALSE); // No hay comandos pendientes + } else { // Busca entre todas las acciones de diversos ambitos + if (!tbl.Get("sesion", *ids)) { // Toma identificador de la acción + tbl.GetErrorErrStr(msglog); // Error al acceder al registro + errorInfo(modulo, msglog); + return (FALSE); + } + if (!tbl.Get("lonprm", lonprm)) { // Toma parámetros del comando + tbl.GetErrorErrStr(msglog); // Error al acceder al registro + errorInfo(modulo, msglog); + return (FALSE); + } + if(!initParametros(ptrTrama,lonprm+LONGITUD_PARAMETROS)){ + db.Close(); + errorLog(modulo, 3, FALSE); + return (FALSE); + } + if (!tbl.Get("parametros", ptrTrama->parametros)) { // Toma parámetros del comando + tbl.GetErrorErrStr(msglog); // Error al acceder al registro + errorInfo(modulo, msglog); + return (FALSE); + } + } + db.Close(); + return (TRUE); // Hay comandos pendientes, se toma el primero de la cola +} +// ________________________________________________________________________________________________________ +// Función: DisponibilidadComandos +// +// Descripción: +// Esta función habilita a un cliente para recibir comandos desde la consola +// Parámetros: +// - socket_c: Socket del cliente que envió el mensaje +// - 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 DisponibilidadComandos(SOCKET *socket_c, TRAMA *ptrTrama) { + char *iph, *tpc; + int idx; + char modulo[] = "DisponibilidadComandos()"; + + iph = copiaParametro("iph",ptrTrama); // Toma ip + tpc = copiaParametro("tpc",ptrTrama); // Tipo de cliente (Plataforma y S.O.) + + if (!clienteExistente(iph, &idx)) { // Busca índice del cliente + errorLog(modulo, 47, FALSE); + return (FALSE); + } + strcpy(tbsockets[idx].estado, tpc); + tbsockets[idx].sock = *socket_c; + swcSocket = TRUE; // El socket permanece abierto para recibir comandos desde el servidor + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: respuestaEstandar +// +// Descripción: +// Esta función actualiza la base de datos con el resultado de la ejecución de un comando con seguimiento +// Parámetros: +// - res: resultado de la ejecución del comando +// - der: Descripción del error si hubiese habido +// - iph: Dirección IP +// - ids: identificador de la acción notificada +// - ido: Identificador del ordenador que notifica +// - db: Objeto base de datos (operativo) +// - tbl: Objeto tabla +// Devuelve: +// TRUE: Si el proceso es correcto +// FALSE: En caso de ocurrir algún error +// ________________________________________________________________________________________________________ +BOOLEAN respuestaEstandar(TRAMA *ptrTrama, char *iph, char *ido, Database db, + Table tbl) { + char msglog[LONSTD], sqlstr[LONSQL]; + char *res, *ids, *der; + char fechafin[LONPRM]; + struct tm* st; + char modulo[] = "respuestaEstandar()"; + + res = copiaParametro("res",ptrTrama); // Toma resultado + ids = copiaParametro("ids",ptrTrama); // Toma identificador de la sesión + der = copiaParametro("der",ptrTrama); // Toma descripción del error (si hubiera habido) + + if (ids == NULL) // No existe seguimiento de la acción + return (TRUE); + + sprintf(sqlstr, + "SELECT * FROM acciones WHERE idordenador=%s AND sesion=%s", ido, + ids); + if (!db.Execute(sqlstr, tbl)) { // Error al consultar + errorLog(modulo, 21, FALSE); + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + if (tbl.ISEOF()) { // No existe registro de acciones + errorLog(modulo, 31, FALSE); + return (TRUE); + } + + st = tomaHora(); + sprintf(fechafin, "%d/%d/%d %d:%d:%d", st->tm_year + 1900, st->tm_mon + 1, + st->tm_mday, st->tm_hour, st->tm_min, st->tm_sec); + + sprintf( + sqlstr, + "UPDATE acciones SET resultado='%s',estado='%d',fechahorafin='%s',descrinotificacion='%s'"\ + " WHERE idordenador=%s AND sesion=%s", + res, ACCION_FINALIZADA, fechafin, der, ido, ids); + if (!db.Execute(sqlstr, tbl)) { // Error al actualizar + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + + if (atoi(res) == ACCION_FALLIDA) + return (FALSE); // Error en la ejecución del comando + + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: enviaComando +// +// Descripción: +// Envía un comando a los clientes +// Parámetros: +// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros +// - estado: Estado en el se deja al cliente mientras se ejecuta el comando +// Devuelve: +// TRUE: Si el proceso es correcto +// FALSE: En caso de ocurrir algún error +// ________________________________________________________________________________________________________ +BOOLEAN enviaComando(TRAMA* ptrTrama, const char *estado) { + char *iph, *Ipes, *ptrIpes[MAXIMOS_CLIENTES]; + int i, idx, lon; + char modulo[] = "enviaComando()"; + + iph = copiaParametro("iph",ptrTrama); // Toma dirección/es IP + lon = strlen(iph); // Calcula longitud de la cadena de direccion/es IPE/S + Ipes = (char*) reservaMemoria(lon + 1); + if (Ipes == NULL) { + errorLog(modulo, 3, FALSE); + return (FALSE); + } + strcpy(Ipes, iph); // Copia cadena de IPES + lon = splitCadena(ptrIpes, Ipes, ';'); + FINCADaINTRO(ptrTrama); + for (i = 0; i < lon; i++) { + if (clienteDisponible(ptrIpes[i], &idx)) { // Si el cliente puede recibir comandos + strcpy(tbsockets[idx].estado, estado); // Actualiza el estado del cliente + if (!mandaTrama(&tbsockets[idx].sock, ptrTrama)) { + errorLog(modulo, 26, FALSE); + return (FALSE); + } + close(tbsockets[idx].sock); // Cierra el socket del cliente hasta nueva disponibilidad + } + } + return (TRUE); +} +//______________________________________________________________________________________________________ +// Función: respuestaConsola +// +// Descripción: +// Envia una respuesta a la consola sobre el resultado de la ejecución de un comando +// Parámetros: +// - socket_c: (Salida) Socket utilizado para el envío +// - res: Resultado del envío del comando +// Devuelve: +// TRUE: Si el proceso es correcto +// FALSE: En caso de ocurrir algún error +// ________________________________________________________________________________________________________ +BOOLEAN respuestaConsola(SOCKET *socket_c, TRAMA *ptrTrama, int res) { + char modulo[] = "respuestaConsola()"; + initParametros(ptrTrama,0); + sprintf(ptrTrama->parametros, "res=%d\r", res); + if (!mandaTrama(socket_c, ptrTrama)) { + errorLog(modulo, 26, FALSE); + return (FALSE); + } + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: Arrancar +// +// Descripción: +// Procesa el comando Apagar +// Parámetros: +// - socket_c: Socket de la consola al envió el mensaje +// - 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 Arrancar(SOCKET *socket_c, TRAMA* ptrTrama) { + char *mac, msglog[LONSTD]; + char modulo[] = "Arrancar()"; + + mac = copiaParametro("mac",ptrTrama); // Toma dirección/es MAC + if (!Levanta(mac)) { + sprintf(msglog, "%s:%s", tbErrores[32], modulo); + errorInfo(modulo, msglog); + respuestaConsola(socket_c, ptrTrama, FALSE); + return (FALSE); + } + if (!enviaComando(ptrTrama, CLIENTE_OCUPADO)) { + sprintf(msglog, "%s:%s", tbErrores[32], modulo); + errorInfo(modulo, msglog); + respuestaConsola(socket_c, ptrTrama, FALSE); + return (FALSE); + } + respuestaConsola(socket_c, ptrTrama, TRUE); + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: Levanta +// +// Descripción: +// Enciende ordenadores a través de la red cuyas macs se pasan como parámetro +// Parámetros: +// - mac: Cadena de direcciones mac separadas por ";" +// Devuelve: +// TRUE: Si el proceso es correcto +// FALSE: En caso de ocurrir algún error +// ________________________________________________________________________________________________________ +BOOLEAN Levanta(char *mac) { + char *ptrMacs[MAXIMOS_CLIENTES]; + int i, lon, res; + SOCKET s; + BOOLEAN bOpt; + sockaddr_in local; + char modulo[] = "Levanta()"; + + /* Creación de socket para envío de magig packet */ + s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); + if (s == SOCKET_ERROR) { // Error al crear el socket del servicio + errorLog(modulo, 13, TRUE); + return (FALSE); + } + bOpt = TRUE; // Pone el socket en modo Broadcast + res = setsockopt(s, SOL_SOCKET, SO_BROADCAST, (char *) &bOpt, sizeof(bOpt)); + if (res == SOCKET_ERROR) { + errorLog(modulo, 48, TRUE); + return (FALSE); + } + local.sin_family = AF_INET; + local.sin_port = htons((short) PUERTO_WAKEUP); + local.sin_addr.s_addr = htonl(INADDR_ANY); // cualquier interface + if (bind(s, (sockaddr *) &local, sizeof(local)) == SOCKET_ERROR) { + errorLog(modulo, 14, TRUE); + exit(EXIT_FAILURE); + } + /* fin creación de socket */ + lon = splitCadena(ptrMacs, mac, ';'); + for (i = 0; i < lon; i++) { + if (!WakeUp(&s, ptrMacs[i])) { + errorLog(modulo, 49, TRUE); + close(s); + return (FALSE); + } + } + close(s); + return (TRUE); +} +//_____________________________________________________________________________________________________________ +// Función: WakeUp +// +// Descripción: +// Enciende el ordenador cuya MAC se pasa como parámetro +// Parámetros: +// - s : Socket para enviar trama magic packet +// - mac : Cadena con la dirección mac en formato XXXXXXXXXXXX +// Devuelve: +// TRUE: Si el proceso es correcto +// FALSE: En caso de ocurrir algún error +//_____________________________________________________________________________________________________________ +BOOLEAN WakeUp(SOCKET *s, char *mac) { + int i, res; + char HDaddress_bin[6]; + struct { + BYTE secuencia_FF[6]; + char macbin[16][6]; + } Trama_WakeUp; + sockaddr_in WakeUpCliente; + char modulo[] = "WakeUp()"; + + for (i = 0; i < 6; i++) // Primera secuencia de la trama Wake Up (0xFFFFFFFFFFFF) + Trama_WakeUp.secuencia_FF[i] = 0xFF; + + PasaHexBin(mac, HDaddress_bin); // Pasa a binario la MAC + + for (i = 0; i < 16; i++) // Segunda secuencia de la trama Wake Up , repetir 16 veces su la MAC + memcpy(&Trama_WakeUp.macbin[i][0], &HDaddress_bin, 6); + + /* Creación de socket del cliente que recibe la trama magic packet */ + WakeUpCliente.sin_family = AF_INET; + WakeUpCliente.sin_port = htons((short) PUERTO_WAKEUP); + WakeUpCliente.sin_addr.s_addr = htonl(INADDR_BROADCAST); // Para hacerlo con broadcast + + res = sendto(*s, (char *) &Trama_WakeUp, sizeof(Trama_WakeUp), 0, + (sockaddr *) &WakeUpCliente, sizeof(WakeUpCliente)); + if (res == SOCKET_ERROR) { + errorLog(modulo, 26, FALSE); + return (FALSE); + } + return (TRUE); +} +//_____________________________________________________________________________________________________________ +// Función: PasaHexBin +// +// Descripción: +// Convierte a binario una dirección mac desde una cadena con formato XXXXXXXXXXXX +// +// Parámetros de entrada: +// - cadena : Cadena con el contenido de la mac +// - numero : la dirección mac convertida a binario (6 bytes) +//_____________________________________________________________________________________________________________ +void PasaHexBin(char *cadena, char *numero) { + int i, j, p; + char matrizHex[] = "0123456789ABCDEF"; + char Ucadena[12], aux; + + for (i = 0; i < 12; i++) + Ucadena[i] = toupper(cadena[i]); + p = 0; + for (i = 0; i < 12; i++) { + for (j = 0; j < 16; j++) { + if (Ucadena[i] == matrizHex[j]) { + if (i % 2) { + aux = numero[p]; + aux = (aux << 4); + numero[p] = j; + numero[p] = numero[p] | aux; + p++; + } else + numero[p] = j; + break; + } + } + } +} +// ________________________________________________________________________________________________________ +// Función: RESPUESTA_Arrancar +// +// Descripción: +// Respuesta del cliente al comando Apagar +// Parámetros: +// - socket_c: Socket del cliente que envió el mensaje +// - 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_Arrancar(SOCKET *socket_c, TRAMA* ptrTrama) { + char msglog[LONSTD]; + Database db; + Table tbl; + int i; + char *iph, *ido; + char *tpc; + char modulo[] = "RESPUESTA_Arrancar()"; + + if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexion + errorLog(modulo, 20, FALSE); + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + + iph = copiaParametro("iph",ptrTrama); // Toma dirección ip + ido = copiaParametro("ido",ptrTrama); // Toma identificador del ordenador + + if (!respuestaEstandar(ptrTrama, iph, ido, db, tbl)) { + errorLog(modulo, 30, FALSE); + return (FALSE); // Error al registrar notificacion + } + + tpc = copiaParametro("tpc",ptrTrama); // Tipo de cliente (Plataforma y S.O.) + if (clienteExistente(iph, &i)) // Actualiza estado + strcpy(tbsockets[i].estado, tpc); + + db.Close(); // Cierra conexión + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: Comando +// +// Descripción: +// Procesa un comando personalizado +// Parámetros: +// - socket_c: Socket de la consola al envió el mensaje +// - 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 Comando(SOCKET *socket_c, TRAMA* ptrTrama) { + char msglog[LONSTD]; + char modulo[] = "Comando()"; + + if (!enviaComando(ptrTrama, CLIENTE_OCUPADO)) { + sprintf(msglog, "%s:%s", tbErrores[32], modulo); + errorInfo(modulo, msglog); + respuestaConsola(socket_c, ptrTrama, FALSE); + return (FALSE); + } + respuestaConsola(socket_c, ptrTrama, TRUE); + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: RESPUESTA_Comando +// +// Descripción: +// Respuesta del cliente al un comando personalizado +// Parámetros: +// - socket_c: Socket del cliente que envió el mensaje +// - 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_Comando(SOCKET *socket_c, TRAMA* ptrTrama) { + char msglog[LONSTD]; + Database db; + Table tbl; + char *iph, *ido; + char modulo[] = "RESPUESTA_Comando()"; + + if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexion + errorLog(modulo, 20, FALSE); + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + + iph = copiaParametro("iph",ptrTrama); // Toma dirección ip + ido = copiaParametro("ido",ptrTrama); // Toma identificador del ordenador + + if (!respuestaEstandar(ptrTrama, iph, ido, db, tbl)) { + errorLog(modulo, 30, FALSE); + return (FALSE); // Error al registrar notificacion + } + db.Close(); // Cierra conexión + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: Apagar +// +// Descripción: +// Procesa el comando Apagar +// Parámetros: +// - socket_c: Socket de la consola al envió el mensaje +// - 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 Apagar(SOCKET *socket_c, TRAMA* ptrTrama) { + char msglog[LONSTD]; + char modulo[] = "Apagar()"; + + if (!enviaComando(ptrTrama, CLIENTE_OCUPADO)) { + sprintf(msglog, "%s:%s", tbErrores[32], modulo); + errorInfo(modulo, msglog); + respuestaConsola(socket_c, ptrTrama, FALSE); + return (FALSE); + } + respuestaConsola(socket_c, ptrTrama, TRUE); + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: RESPUESTA_Apagar +// +// Descripción: +// Respuesta del cliente al comando Apagar +// Parámetros: +// - socket_c: Socket del cliente que envió el mensaje +// - 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_Apagar(SOCKET *socket_c, TRAMA* ptrTrama) { + char msglog[LONSTD]; + Database db; + Table tbl; + int i; + char *iph, *ido; + char modulo[] = "RESPUESTA_Apagar()"; + + if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexion + errorLog(modulo, 20, FALSE); + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + + iph = copiaParametro("iph",ptrTrama); // Toma dirección ip + ido = copiaParametro("ido",ptrTrama); // Toma identificador del ordenador + + if (!respuestaEstandar(ptrTrama, iph, ido, db, tbl)) { + errorLog(modulo, 30, FALSE); + return (FALSE); // Error al registrar notificacion + } + + if (clienteExistente(iph, &i)) // Actualiza estado + strcpy(tbsockets[i].estado, CLIENTE_APAGADO); + + db.Close(); // Cierra conexión + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: Reiniciar +// +// Descripción: +// Procesa el comando Reiniciar +// Parámetros: +// - socket_c: Socket de la consola al envió el mensaje +// - 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 Reiniciar(SOCKET *socket_c, TRAMA* ptrTrama) { + char msglog[LONSTD]; + char modulo[] = "Reiniciar()"; + + if (!enviaComando(ptrTrama, CLIENTE_OCUPADO)) { + sprintf(msglog, "%s:%s", tbErrores[32], modulo); + errorInfo(modulo, msglog); + respuestaConsola(socket_c, ptrTrama, FALSE); + return (FALSE); + } + respuestaConsola(socket_c, ptrTrama, TRUE); + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: RESPUESTA_Reiniciar +// +// Descripción: +// Respuesta del cliente al comando Reiniciar +// Parámetros: +// - socket_c: Socket del cliente que envió el mensaje +// - 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_Reiniciar(SOCKET *socket_c, TRAMA* ptrTrama) { + char msglog[LONSTD]; + Database db; + Table tbl; + int i; + char *iph, *ido; + char modulo[] = "RESPUESTA_Reiniciar()"; + + if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexion + errorLog(modulo, 20, FALSE); + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + + iph = copiaParametro("iph",ptrTrama); // Toma dirección ip + ido = copiaParametro("ido",ptrTrama); // Toma identificador del ordenador + + if (!respuestaEstandar(ptrTrama, iph, ido, db, tbl)) { + errorLog(modulo, 30, FALSE); + return (FALSE); // Error al registrar notificacion + } + + if (clienteExistente(iph, &i)) // Actualiza estado + strcpy(tbsockets[i].estado, CLIENTE_APAGADO); + + db.Close(); // Cierra conexión + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: IniciarSesion +// +// Descripción: +// Procesa el comando Iniciar Sesión +// Parámetros: +// - socket_c: Socket de la consola al envió el mensaje +// - 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 IniciarSesion(SOCKET *socket_c, TRAMA* ptrTrama) { + char msglog[LONSTD]; + char modulo[] = "IniciarSesion()"; + + if (!enviaComando(ptrTrama, CLIENTE_OCUPADO)) { + sprintf(msglog, "%s:%s", tbErrores[32], modulo); + errorInfo(modulo, msglog); + respuestaConsola(socket_c, ptrTrama, FALSE); + return (FALSE); + } + respuestaConsola(socket_c, ptrTrama, TRUE); + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: RESPUESTA_IniciarSesion +// +// Descripción: +// Respuesta del cliente al comando Iniciar Sesión +// Parámetros: +// - socket_c: Socket del cliente que envió el mensaje +// - 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_IniciarSesion(SOCKET *socket_c, TRAMA* ptrTrama) { + char msglog[LONSTD]; + Database db; + Table tbl; + int i; + char *iph, *ido; + char modulo[] = "RESPUESTA_IniciarSesion()"; + + if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexion + errorLog(modulo, 20, FALSE); + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + + iph = copiaParametro("iph",ptrTrama); // Toma dirección ip + ido = copiaParametro("ido",ptrTrama); // Toma identificador del ordenador + + if (!respuestaEstandar(ptrTrama, iph, ido, db, tbl)) { + errorLog(modulo, 30, FALSE); + return (FALSE); // Error al registrar notificacion + } + + if (clienteExistente(iph, &i)) // Actualiza estado + strcpy(tbsockets[i].estado, CLIENTE_APAGADO); + + db.Close(); // Cierra conexión + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: CrearImagen +// +// Descripción: +// Crea una imagen de una partición de un disco y la guarda o bien en un repositorio +// Parámetros: +// - socket_c: Socket de la consola al envió el mensaje +// - 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 CrearImagen(SOCKET *socket_c, TRAMA* ptrTrama) { + char msglog[LONSTD]; + char modulo[] = "CrearImagen()"; + + if (!enviaComando(ptrTrama, CLIENTE_OCUPADO)) { + sprintf(msglog, "%s:%s", tbErrores[32], modulo); + errorInfo(modulo, msglog); + respuestaConsola(socket_c, ptrTrama, FALSE); + return (FALSE); + } + respuestaConsola(socket_c, ptrTrama, TRUE); + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: RESPUESTA_CrearImagen +// +// Descripción: +// Respuesta del cliente al comando CrearImagen +// Parámetros: +// - socket_c: Socket del cliente que envió el mensaje +// - 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_CrearImagen(SOCKET *socket_c, TRAMA* ptrTrama) { + char msglog[LONSTD]; + Database db; + Table tbl; + char *iph, *par, *cpt, *ipr, *ido; + char *idi; + char modulo[] = "RESPUESTA_CrearImagen()"; + + if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexion + errorLog(modulo, 20, FALSE); + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + + iph = copiaParametro("iph",ptrTrama); // Toma dirección ip + ido = copiaParametro("ido",ptrTrama); // Toma identificador del ordenador + + if (!respuestaEstandar(ptrTrama, iph, ido, db, tbl)) { + errorLog(modulo, 30, FALSE); + return (FALSE); // Error al registrar notificacion + } + + // Acciones posteriores + idi = copiaParametro("idi",ptrTrama); + par = copiaParametro("par",ptrTrama); + cpt = copiaParametro("cpt",ptrTrama); + ipr = copiaParametro("ipr",ptrTrama); + + if (!actualizaCreacionImagen(db, tbl, idi, par, cpt, ipr, ido)) { + errorLog(modulo, 53, FALSE); + db.Close(); // Cierra conexión + return (FALSE); + } + + db.Close(); // Cierra conexión + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: actualizaCreacionImagen +// +// Descripción: +// Esta función actualiza la base de datos con el resultado de la creación de una imagen +// Parámetros: +// - db: Objeto base de datos (ya operativo) +// - tbl: Objeto tabla +// - idi: Identificador de la imagen +// - par: Partición de donde se creó +// - cpt: Código de partición +// - ipr: Ip del repositorio +// - ido: Identificador del ordenador modelo +// Devuelve: +// TRUE: Si el proceso es correcto +// FALSE: En caso de ocurrir algún error +// ________________________________________________________________________________________________________ +BOOLEAN actualizaCreacionImagen(Database db, Table tbl, char* idi, char* par, + char* cpt, char* ipr, char *ido) { + char msglog[LONSTD], sqlstr[LONSQL]; + char modulo[] = "actualizaCreacionImagen()"; + int idr,ifs; + + /* Toma identificador del repositorio */ + sprintf(sqlstr, "SELECT idrepositorio FROM repositorios WHERE ip='%s'", ipr); + + if (!db.Execute(sqlstr, tbl)) { // Error al leer + errorLog(modulo, 21, FALSE); + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + if (!tbl.Get("idrepositorio", idr)) { // Toma dato + tbl.GetErrorErrStr(msglog); // Error al acceder al registro + errorInfo(modulo, msglog); + return (FALSE); + } + + /* Toma identificador del perfilsoftware */ + sprintf(sqlstr, "SELECT idperfilsoft FROM ordenadores_particiones WHERE idordenador=%s AND numpar=%s", ido,par); + + if (!db.Execute(sqlstr, tbl)) { // Error al leer + errorLog(modulo, 21, FALSE); + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + if (!tbl.Get("idperfilsoft", ifs)) { // Toma dato + tbl.GetErrorErrStr(msglog); // Error al acceder al registro + errorInfo(modulo, msglog); + return (FALSE); + } + + /* Actualizar los datos de la imagen */ + sprintf(sqlstr, + "UPDATE imagenes SET numpar=%s,codpar=%s,idperfilsoft=%d,idrepositorio='%d'" + " WHERE idimagen=%s", par, cpt, ifs, idr, idi); + + if (!db.Execute(sqlstr, tbl)) { // Error al recuperar los datos + errorLog(modulo, 21, FALSE); + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: RestaurarImagen +// +// Descripción: +// Restaura una imagen en una partición +// Parámetros: +// - socket_c: Socket de la consola al envió el mensaje +// - 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 RestaurarImagen(SOCKET *socket_c, TRAMA* ptrTrama) { + char msglog[LONSTD]; + char modulo[] = "RestaurarImagen()"; + + if (!enviaComando(ptrTrama, CLIENTE_OCUPADO)) { + sprintf(msglog, "%s:%s", tbErrores[32], modulo); + errorInfo(modulo, msglog); + respuestaConsola(socket_c, ptrTrama, FALSE); + return (FALSE); + } + respuestaConsola(socket_c, ptrTrama, TRUE); + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: RESPUESTA_RestaurarImagen +// +// Descripción: +// Respuesta del cliente al comando RestaurarImagen +// Parámetros: +// - socket_c: Socket del cliente que envió el mensaje +// - 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_RestaurarImagen(SOCKET *socket_c, TRAMA* ptrTrama) { + char msglog[LONSTD]; + Database db; + Table tbl; + char *iph, *ido, *idi, *par, *ifs; + char modulo[] = "RESPUESTA_RestaurarImagen()"; + + if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexion + errorLog(modulo, 20, FALSE); + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + + iph = copiaParametro("iph",ptrTrama); // Toma dirección ip + ido = copiaParametro("ido",ptrTrama); // Toma identificador del ordenador + + if (!respuestaEstandar(ptrTrama, iph, ido, db, tbl)) { + errorLog(modulo, 30, FALSE); + return (FALSE); // Error al registrar notificacion + } + + // Acciones posteriores + idi = copiaParametro("idi",ptrTrama); // Toma identificador de la imagen + par = copiaParametro("par",ptrTrama); // Número de partición + ifs = copiaParametro("ifs",ptrTrama); // Identificador del perfil software contenido + if (!actualizaRestauracionImagen(db, tbl, idi, par, ido, ifs)) { + errorLog(modulo, 53, FALSE); + db.Close(); // Cierra conexión + return (FALSE); + } + + db.Close(); // Cierra conexión + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: actualizaRestauracionImagen +// +// Descripción: +// Esta función actualiza la base de datos con el resultado de la creación de una imagen +// Parámetros: +// - db: Objeto base de datos (ya operativo) +// - tbl: Objeto tabla +// - idi: Identificador de la imagen +// - par: Partición de donde se restauró +// - ido: Identificador del cliente donde se restauró +// - ifs: Identificador del perfil software contenido en la imagen +// Devuelve: +// TRUE: Si el proceso es correcto +// FALSE: En caso de ocurrir algún error +// ________________________________________________________________________________________________________ +BOOLEAN actualizaRestauracionImagen(Database db, Table tbl, char* idi, + char* par, char* ido, char* ifs) { + char msglog[LONSTD], sqlstr[LONSQL]; + char modulo[] = "actualizaRestauracionImagen()"; + + /* Actualizar los datos de la imagen */ + sprintf(sqlstr, + "UPDATE ordenadores_particiones SET idimagen=%s,idperfilsoft=%s" + " WHERE idordenador=%s AND numpar=%s", idi, ifs, ido, par); + + if (!db.Execute(sqlstr, tbl)) { // Error al recuperar los datos + errorLog(modulo, 21, FALSE); + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: Configurar +// +// Descripción: +// Configura la tabla de particiones +// Parámetros: +// - socket_c: Socket de la consola al envió el mensaje +// - 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 Configurar(SOCKET *socket_c, TRAMA* ptrTrama) { + char msglog[LONSTD]; + char modulo[] = "Configurar()"; + + if (!enviaComando(ptrTrama, CLIENTE_OCUPADO)) { + sprintf(msglog, "%s:%s", tbErrores[32], modulo); + errorInfo(modulo, msglog); + respuestaConsola(socket_c, ptrTrama, FALSE); + return (FALSE); + } + respuestaConsola(socket_c, ptrTrama, TRUE); + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: RESPUESTA_Configurar +// +// Descripción: +// Respuesta del cliente al comando Configurar +// Parámetros: +// - socket_c: Socket del cliente que envió el mensaje +// - 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_Configurar(SOCKET *socket_c, TRAMA* ptrTrama) { + char msglog[LONSTD]; + Database db; + Table tbl; + char *iph, *ido,*cfg; + char modulo[] = "RESPUESTA_Configurar()"; + + if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexion + errorLog(modulo, 20, FALSE); + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + + iph = copiaParametro("iph",ptrTrama); // Toma dirección ip + ido = copiaParametro("ido",ptrTrama); // Toma identificador del ordenador + + if (!respuestaEstandar(ptrTrama, iph, ido, db, tbl)) { + errorLog(modulo, 30, FALSE); + return (FALSE); // Error al registrar notificacion + } + + cfg = copiaParametro("cfg",ptrTrama); // Toma configuración de particiones + if(!actualizaConfiguracion(db, tbl, cfg, atoi(ido))){ // Actualiza la configuración del ordenador + errorLog(modulo, 24, FALSE); + return (FALSE); // Error al registrar notificacion + } + db.Close(); // Cierra conexión + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: EjecutarScript +// +// Descripción: +// Ejecuta un script de código +// Parámetros: +// - socket_c: Socket de la consola al envió el mensaje +// - 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 EjecutarScript(SOCKET *socket_c, TRAMA* ptrTrama) { + char msglog[LONSTD]; + char modulo[] = "EjecutarScript()"; + + if (!enviaComando(ptrTrama, CLIENTE_OCUPADO)) { + sprintf(msglog, "%s:%s", tbErrores[32], modulo); + errorInfo(modulo, msglog); + respuestaConsola(socket_c, ptrTrama, FALSE); + return (FALSE); + } + respuestaConsola(socket_c, ptrTrama, TRUE); + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: RESPUESTA_EjecutarScript +// +// Descripción: +// Respuesta del cliente al comando EjecutarScript +// Parámetros: +// - socket_c: Socket del cliente que envió el mensaje +// - 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_EjecutarScript(SOCKET *socket_c, TRAMA* ptrTrama) { + char msglog[LONSTD]; + Database db; + Table tbl; + char *iph, *ido; + + char modulo[] = "RESPUESTA_EjecutarScript()"; + + if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexion + errorLog(modulo, 20, FALSE); + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + + iph = copiaParametro("iph",ptrTrama); // Toma dirección ip + ido = copiaParametro("ido",ptrTrama); // Toma identificador del ordenador + + if (!respuestaEstandar(ptrTrama, iph, ido, db, tbl)) { + errorLog(modulo, 30, FALSE); + return (FALSE); // Error al registrar notificacion + } + + // Acciones posteriores + db.Close(); // Cierra conexión + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: InventarioHardware +// +// Descripción: +// Solicita al cliente un inventario de su hardware +// Parámetros: +// - socket_c: Socket de la consola al envió el mensaje +// - 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 InventarioHardware(SOCKET *socket_c, TRAMA* ptrTrama) { + char msglog[LONSTD]; + char modulo[] = "InventarioHardware()"; + + if (!enviaComando(ptrTrama, CLIENTE_OCUPADO)) { + sprintf(msglog, "%s:%s", tbErrores[32], modulo); + errorInfo(modulo, msglog); + respuestaConsola(socket_c, ptrTrama, FALSE); + return (FALSE); + } + respuestaConsola(socket_c, ptrTrama, TRUE); + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: RESPUESTA_InventarioHardware +// +// Descripción: +// Respuesta del cliente al comando InventarioHardware +// Parámetros: +// - socket_c: Socket del cliente que envió el mensaje +// - 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_InventarioHardware(SOCKET *socket_c, TRAMA* ptrTrama) { + char msglog[LONSTD]; + Database db; + Table tbl; + char *iph, *ido, *idc, *npc, *hrd, *buffer; + char modulo[] = "RESPUESTA_InventarioHardware()"; + + if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexion + errorLog(modulo, 20, FALSE); + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + iph = copiaParametro("iph",ptrTrama); // Toma dirección ip del cliente + ido = copiaParametro("ido",ptrTrama); // Toma identificador del cliente + npc = copiaParametro("npc",ptrTrama); // Toma Nombre del cliente + idc = copiaParametro("idc",ptrTrama); // Toma identificador del Centro + + if (!respuestaEstandar(ptrTrama, iph, ido, db, tbl)) { + errorLog(modulo, 30, FALSE); + return (FALSE); // Error al registrar notificacion + } + // Lee archivo de inventario enviado anteriormente + hrd = copiaParametro("hrd",ptrTrama); + buffer = rTrim(leeArchivo(hrd)); + + if (buffer) { + if (!actualizaHardware(db, tbl, buffer, ido, npc, idc)) { + errorLog(modulo, 53, FALSE); + return (FALSE); + } + } + db.Close(); // Cierra conexión + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: actualizaHardware +// +// Descripción: +// Actualiza la base de datos con la configuracion hardware del cliente +// Parámetros: +// - db: Objeto base de datos (ya operativo) +// - tbl: Objeto tabla +// - hrd: cadena con el inventario hardware +// - ido: Identificador del ordenador +// - npc: Nombre del ordenador +// - idc: Identificador del centro o Unidad organizativa +// ________________________________________________________________________________________________________ +BOOLEAN actualizaHardware(Database db, Table tbl, char* hrd, char*ido, + char* npc, char *idc) { + char msglog[LONSTD], sqlstr[LONSQL]; + int idtipohardware, idperfilhard; + int lon, i, j, aux; + char *tbHardware[MAXHARDWARE]; + int tbidhardware[MAXHARDWARE]; + char *dualHardware[2], descripcion[250], strInt[LONINT], *idhardwares; + char modulo[] = "actualizaHardware()"; + + /* Toma Centro (Unidad Organizativa) */ + sprintf(sqlstr, "SELECT * FROM ordenadores WHERE idordenador=%s", ido); + + if (!db.Execute(sqlstr, tbl)) { // Error al leer + errorLog(modulo, 21, FALSE); + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + if (!tbl.Get("idperfilhard", idperfilhard)) { // Toma dato + tbl.GetErrorErrStr(msglog); // Error al acceder al registro + errorInfo(modulo, msglog); + return (FALSE); + } + hrd=escaparCadena(hrd); // Codificar comillas simples + if(!hrd) + return (FALSE); + /* Recorre componentes hardware*/ + lon = splitCadena(tbHardware, hrd, '\n'); + if (lon > MAXHARDWARE) + lon = MAXHARDWARE; // Limita el número de componentes hardware + /* + for (i=0;i<lon;i++){ + sprintf(msglog,"Linea de inventario: %s",tbHardware[i]); + RegistraLog(msglog,FALSE); + } + */ + for (i = 0; i < lon; i++) { + splitCadena(dualHardware, rTrim(tbHardware[i]), '='); + //sprintf(msglog,"nemonico: %s",dualHardware[0]); + //RegistraLog(msglog,FALSE); + //sprintf(msglog,"valor: %s",dualHardware[1]); + //RegistraLog(msglog,FALSE); + sprintf(sqlstr, "SELECT idtipohardware,descripcion FROM tipohardwares " + " WHERE nemonico='%s'", dualHardware[0]); + if (!db.Execute(sqlstr, tbl)) { // Error al leer + errorLog(modulo, 21, FALSE); + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + if (tbl.ISEOF()) { // Tipo de Hardware NO existente + sprintf(msglog, "%s: %s)", tbErrores[54], dualHardware[0]); + errorInfo(modulo, msglog); + return (FALSE); + } else { // Tipo de Hardware Existe + if (!tbl.Get("idtipohardware", idtipohardware)) { // Toma dato + tbl.GetErrorErrStr(msglog); // Error al acceder al registro + errorInfo(modulo, msglog); + return (FALSE); + } + if (!tbl.Get("descripcion", descripcion)) { // Toma dato + tbl.GetErrorErrStr(msglog); // Error al acceder al registro + errorInfo(modulo, msglog); + return (FALSE); + } + + sprintf(sqlstr, "SELECT idhardware FROM hardwares " + " WHERE idtipohardware=%d AND descripcion='%s'", + idtipohardware, dualHardware[1]); + + // Ejecuta consulta + if (!db.Execute(sqlstr, tbl)) { // Error al leer + errorLog(modulo, 21, FALSE); + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + + if (tbl.ISEOF()) { // Hardware NO existente + sprintf(sqlstr, + "INSERT hardwares (idtipohardware,descripcion,idcentro,grupoid) " + " VALUES(%d,'%s',%s,0)", idtipohardware, + dualHardware[1], idc); + if (!db.Execute(sqlstr, tbl)) { // Error al insertar + db.GetErrorErrStr(msglog); // Error al acceder al registro + errorInfo(modulo, msglog); + return (FALSE); + } + // Recupera el identificador del hardware + sprintf(sqlstr, "SELECT LAST_INSERT_ID() as identificador"); + if (!db.Execute(sqlstr, tbl)) { // Error al leer + errorLog(modulo, 21, FALSE); + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + if (!tbl.ISEOF()) { // Si existe registro + if (!tbl.Get("identificador", tbidhardware[i])) { + tbl.GetErrorErrStr(msglog); // Error al acceder al registro + errorInfo(modulo, msglog); + return (FALSE); + } + } + } else { + if (!tbl.Get("idhardware", tbidhardware[i])) { // Toma dato + tbl.GetErrorErrStr(msglog); // Error al acceder al registro + errorInfo(modulo, msglog); + return (FALSE); + } + } + } + } + // Ordena tabla de identificadores para cosultar si existe un pefil con esas especificaciones + + for (i = 0; i < lon - 1; i++) { + for (j = i + 1; j < lon; j++) { + if (tbidhardware[i] > tbidhardware[j]) { + aux = tbidhardware[i]; + tbidhardware[i] = tbidhardware[j]; + tbidhardware[j] = aux; + } + } + } + /* Crea cadena de identificadores de componentes hardware separados por coma */ + sprintf(strInt, "%d", tbidhardware[lon - 1]); // Pasa a cadena el último identificador que es de mayor longitud + aux = strlen(strInt); // Calcula longitud de cadena para reservar espacio a todos los perfiles + idhardwares = reservaMemoria(sizeof(aux) * lon + lon); + if (idhardwares == NULL) { + errorLog(modulo, 3, FALSE); + return (FALSE); + } + aux = sprintf(idhardwares, "%d", tbidhardware[0]); + for (i = 1; i < lon; i++) + aux += sprintf(idhardwares + aux, ",%d", tbidhardware[i]); + + if (!cuestionPerfilHardware(db, tbl, idc, ido, idperfilhard, idhardwares, + npc, tbidhardware, lon)) { + errorLog(modulo, 55, FALSE); + errorInfo(modulo, msglog); + return (FALSE); + } + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: cuestionPerfilHardware +// +// Descripción: +// Comprueba existencia de perfil hardware y actualización de éste para el ordenador +// Parámetros: +// - db: Objeto base de datos (ya operativo) +// - tbl: Objeto tabla +// - idc: Identificador de la Unidad organizativa donde se encuentra el cliente +// - ido: Identificador del ordenador +// - tbidhardware: Identificador del tipo de hardware +// - con: Número de componentes detectados para configurar un el perfil hardware +// - npc: Nombre del cliente +// ________________________________________________________________________________________________________ +BOOLEAN cuestionPerfilHardware(Database db, Table tbl, char* idc, char* ido, + int idperfilhardware, char*idhardwares, char *npc, int *tbidhardware, + int lon) +{ + char msglog[LONSTD], *sqlstr; + int i; + int nwidperfilhard; + char modulo[] = "cuestionPerfilHardware()"; + + sqlstr = reservaMemoria(strlen(idhardwares)+LONSQL); // Reserva para escribir sentencia SQL + if (sqlstr == NULL) { + errorLog(modulo, 3, FALSE); + return (FALSE); + } + // Busca perfil hard del ordenador que contenga todos los componentes hardware encontrados + sprintf(sqlstr, "SELECT idperfilhard FROM" + " (SELECT perfileshard_hardwares.idperfilhard as idperfilhard," + " group_concat(cast(perfileshard_hardwares.idhardware AS char( 11) )" + " ORDER BY perfileshard_hardwares.idhardware SEPARATOR ',' ) AS idhardwares" + " FROM perfileshard_hardwares" + " GROUP BY perfileshard_hardwares.idperfilhard) AS temp" + " WHERE idhardwares LIKE '%s'", idhardwares); + // Ejecuta consulta + if (!db.Execute(sqlstr, tbl)) { // Error al leer + errorLog(modulo, 21, FALSE); + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (false); + } + if (tbl.ISEOF()) { // No existe un perfil hardware con esos componentes de componentes hardware, lo crea + sprintf(sqlstr, "INSERT perfileshard (descripcion,idcentro,grupoid)" + " VALUES('Perfil hardware (%s) ',%s,0)", npc, idc); + if (!db.Execute(sqlstr, tbl)) { // Error al insertar + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (false); + } + // Recupera el identificador del nuevo perfil hardware + sprintf(sqlstr, "SELECT LAST_INSERT_ID() as identificador"); + if (!db.Execute(sqlstr, tbl)) { // Error al leer + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (false); + } + if (!tbl.ISEOF()) { // Si existe registro + if (!tbl.Get("identificador", nwidperfilhard)) { + tbl.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (false); + } + } + // Crea la relación entre perfiles y componenetes hardware + for (i = 0; i < lon; i++) { + sprintf(sqlstr, + "INSERT perfileshard_hardwares (idperfilhard,idhardware)" + " VALUES(%d,%d)", nwidperfilhard, tbidhardware[i]); + if (!db.Execute(sqlstr, tbl)) { // Error al insertar + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (false); + } + } + } else { // Existe un perfil con todos esos componentes + if (!tbl.Get("idperfilhard", nwidperfilhard)) { + tbl.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (false); + } + } + if (idperfilhardware != nwidperfilhard) { // No coinciden los perfiles + // Actualiza el identificador del perfil hardware del ordenador + sprintf(sqlstr, "UPDATE ordenadores SET idperfilhard=%d" + " WHERE idordenador=%s", nwidperfilhard, ido); + if (!db.Execute(sqlstr, tbl)) { // Error al insertar + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (false); + } + } + /* Eliminar Relación de hardwares con Perfiles hardware que quedan húerfanos */ + sprintf(sqlstr, "DELETE FROM perfileshard_hardwares WHERE idperfilhard IN " + " (SELECT idperfilhard FROM perfileshard WHERE idperfilhard NOT IN" + " (SELECT DISTINCT idperfilhard from ordenadores))"); + if (!db.Execute(sqlstr, tbl)) { // Error al insertar + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (false); + } + + /* Eliminar Perfiles hardware que quedan húerfanos */ + sprintf(sqlstr, "DELETE FROM perfileshard WHERE idperfilhard NOT IN" + " (SELECT DISTINCT idperfilhard from ordenadores)"); + if (!db.Execute(sqlstr, tbl)) { // Error al insertar + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (false); + } + /* Eliminar Relación de hardwares con Perfiles hardware que quedan húerfanos */ + sprintf(sqlstr, + "DELETE FROM perfileshard_hardwares WHERE idperfilhard NOT IN" + " (SELECT idperfilhard from perfileshard)"); + if (!db.Execute(sqlstr, tbl)) { // Error al insertar + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (false); + } + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: InventarioSoftware +// +// Descripción: +// Solicita al cliente un inventario de su software +// Parámetros: +// - socket_c: Socket de la consola al envió el mensaje +// - 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 InventarioSoftware(SOCKET *socket_c, TRAMA* ptrTrama) { + char msglog[LONSTD]; + char modulo[] = "InventarioSoftware()"; + + if (!enviaComando(ptrTrama, CLIENTE_OCUPADO)) { + sprintf(msglog, "%s:%s", tbErrores[32], modulo); + errorInfo(modulo, msglog); + respuestaConsola(socket_c, ptrTrama, FALSE); + return (FALSE); + } + respuestaConsola(socket_c, ptrTrama, TRUE); + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: RESPUESTA_InventarioSoftware +// +// Descripción: +// Respuesta del cliente al comando InventarioSoftware +// Parámetros: +// - socket_c: Socket del cliente que envió el mensaje +// - 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_InventarioSoftware(SOCKET *socket_c, TRAMA* ptrTrama) { + char msglog[LONSTD]; + Database db; + Table tbl; + char *iph, *ido, *npc, *idc, *par, *sft, *buffer; + char modulo[] = "RESPUESTA_InventarioSoftware()"; + + if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexion + errorLog(modulo, 20, FALSE); + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + + iph = copiaParametro("iph",ptrTrama); // Toma dirección ip + ido = copiaParametro("ido",ptrTrama); // Toma identificador del ordenador + npc = copiaParametro("npc",ptrTrama); // Toma Nombre del cliente + idc = copiaParametro("idc",ptrTrama); // Toma identificador del Centro + + if (!respuestaEstandar(ptrTrama, iph, ido, db, tbl)) { + errorLog(modulo, 30, FALSE); + return (FALSE); // Error al registrar notificacion + } + par = copiaParametro("par",ptrTrama); + // Lee archivo de inventario enviado anteriormente + sft = copiaParametro("sft",ptrTrama); + + buffer = rTrim(leeArchivo(sft)); + if (buffer) { + if (!actualizaSoftware(db, tbl, buffer, par, ido, npc, idc)) { + errorLog(modulo, 82, FALSE); + return (FALSE); + } + } + db.Close(); // Cierra conexión + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: actualizaSoftware +// +// Descripción: +// Actualiza la base de datos con la configuración software del cliente +// Parámetros: +// - db: Objeto base de datos (ya operativo) +// - tbl: Objeto tabla +// - sft: cadena con el inventario software +// - par: Número de la partición +// - ido: Identificador del ordenador del cliente en la tabla +// - npc: Nombre del ordenador +// - idc: Identificador del centro o Unidad organizativa +// Devuelve: +// TRUE: Si el proceso es correcto +// FALSE: En caso de ocurrir algún error +// ________________________________________________________________________________________________________ +BOOLEAN actualizaSoftware(Database db, Table tbl, char* sft, char* par, + char* ido, char* npc, char* idc) { + int i, j, lon, aux, idperfilsoft; + char *tbSoftware[MAXSOFTWARE]; + int tbidsoftware[MAXSOFTWARE]; + char msglog[LONSTD], sqlstr[LONSQL], strInt[LONINT], *idsoftwares; + char modulo[] = "actualizaSoftware()"; + + /* Toma Centro (Unidad Organizativa) y perfil software */ + sprintf(sqlstr, "SELECT idperfilsoft,numpar" + " FROM ordenadores_particiones" + " WHERE idordenador=%s", ido); + + if (!db.Execute(sqlstr, tbl)) { // Error al leer + errorLog(modulo, 21, FALSE); + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + idperfilsoft = 0; // Por defecto se supone que el ordenador no tiene aún detectado el perfil software + while (!tbl.ISEOF()) { // Recorre particiones + if (!tbl.Get("numpar", aux)) { + tbl.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + if (aux == atoi(par)) { // Se encuentra la partición + if (!tbl.Get("idperfilsoft", idperfilsoft)) { + tbl.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + break; + } + tbl.MoveNext(); + } + sft=escaparCadena(sft); // Codificar comillas simples + if(!sft) + return (FALSE); + + /* Recorre componentes software*/ + lon = splitCadena(tbSoftware, sft, '\n'); + if (lon == 0) + return (true); // No hay lineas que procesar + if (lon > MAXSOFTWARE) + lon = MAXSOFTWARE; // Limita el número de componentes software + + for (i = 0; i < lon; i++) { + sprintf(sqlstr, + "SELECT idsoftware FROM softwares WHERE descripcion ='%s'", + rTrim(tbSoftware[i])); + + // Ejecuta consulta + if (!db.Execute(sqlstr, tbl)) { // Error al leer + errorLog(modulo, 21, FALSE); + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + + if (tbl.ISEOF()) { // Software NO existente + sprintf(sqlstr, + "INSERT INTO softwares (idtiposoftware,descripcion,idcentro,grupoid)" + " VALUES(2,'%s',%s,0)", tbSoftware[i], idc); + + if (!db.Execute(sqlstr, tbl)) { // Error al insertar + db.GetErrorErrStr(msglog); // Error al acceder al registro + errorInfo(modulo, msglog); + return (FALSE); + } + // Recupera el identificador del software + sprintf(sqlstr, "SELECT LAST_INSERT_ID() as identificador"); + if (!db.Execute(sqlstr, tbl)) { // Error al leer + db.GetErrorErrStr(msglog); // Error al acceder al registro + errorInfo(modulo, msglog); + return (FALSE); + } + if (!tbl.ISEOF()) { // Si existe registro + if (!tbl.Get("identificador", tbidsoftware[i])) { + tbl.GetErrorErrStr(msglog); // Error al acceder al registro + errorInfo(modulo, msglog); + return (FALSE); + } + } + } else { + if (!tbl.Get("idsoftware", tbidsoftware[i])) { // Toma dato + tbl.GetErrorErrStr(msglog); // Error al acceder al registro + errorInfo(modulo, msglog); + return (FALSE); + } + } + } + + // Ordena tabla de identificadores para cosultar si existe un pefil con esas especificaciones + + for (i = 0; i < lon - 1; i++) { + for (j = i + 1; j < lon; j++) { + if (tbidsoftware[i] > tbidsoftware[j]) { + aux = tbidsoftware[i]; + tbidsoftware[i] = tbidsoftware[j]; + tbidsoftware[j] = aux; + } + } + } + /* Crea cadena de identificadores de componentes software separados por coma */ + sprintf(strInt, "%d", tbidsoftware[lon - 1]); // Pasa a cadena el último identificador que es de mayor longitud + aux = strlen(strInt); // Calcula longitud de cadena para reservar espacio a todos los perfiles + idsoftwares = reservaMemoria((sizeof(aux)+1) * lon + lon); + if (idsoftwares == NULL) { + errorLog(modulo, 3, FALSE); + return (FALSE); + } + aux = sprintf(idsoftwares, "%d", tbidsoftware[0]); + for (i = 1; i < lon; i++) + aux += sprintf(idsoftwares + aux, ",%d", tbidsoftware[i]); + + // Comprueba existencia de perfil software y actualización de éste para el ordenador + if (!cuestionPerfilSoftware(db, tbl, idc, ido, idperfilsoft, idsoftwares, + npc, par, tbidsoftware, lon)) { + errorLog(modulo, 83, FALSE); + errorInfo(modulo, msglog); + return (FALSE); + } + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: CuestionPerfilSoftware +// +// Parámetros: +// - db: Objeto base de datos (ya operativo) +// - tbl: Objeto tabla +// - idcentro: Identificador del centro en la tabla +// - ido: Identificador del ordenador del cliente en la tabla +// - idsoftwares: Cadena con los identificadores de componentes software separados por comas +// - npc: Nombre del ordenador del cliente +// - particion: Número de la partición +// - tbidsoftware: Array con los identificadores de componentes software +// - lon: Número de componentes +// Devuelve: +// TRUE: Si el proceso es correcto +// FALSE: En caso de ocurrir algún error +//________________________________________________________________________________________________________/ +BOOLEAN cuestionPerfilSoftware(Database db, Table tbl, char* idc, char* ido, + int idperfilsoftware, char *idsoftwares, char *npc, char *par, + int *tbidsoftware, int lon) { + char *sqlstr, msglog[LONSTD]; + int i, nwidperfilsoft; + char modulo[] = "cuestionPerfilSoftware()"; + + sqlstr = reservaMemoria(strlen(idsoftwares)+LONSQL); // Reserva para escribir sentencia SQL + if (sqlstr == NULL) { + errorLog(modulo, 3, FALSE); + return (FALSE); + } + // Busca perfil soft del ordenador que contenga todos los componentes software encontrados + sprintf(sqlstr, "SELECT idperfilsoft FROM" + " (SELECT perfilessoft_softwares.idperfilsoft as idperfilsoft," + " group_concat(cast(perfilessoft_softwares.idsoftware AS char( 11) )" + " ORDER BY perfilessoft_softwares.idsoftware SEPARATOR ',' ) AS idsoftwares" + " FROM perfilessoft_softwares" + " GROUP BY perfilessoft_softwares.idperfilsoft) AS temp" + " WHERE idsoftwares LIKE '%s'", idsoftwares); + // Ejecuta consulta + if (!db.Execute(sqlstr, tbl)) { // Error al leer + errorLog(modulo, 21, FALSE); + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (false); + } + if (tbl.ISEOF()) { // No existe un perfil software con esos componentes de componentes software, lo crea + sprintf(sqlstr, "INSERT perfilessoft (descripcion,idcentro,grupoid)" + " VALUES('Perfil Software (%s, Part:%s) ',%s,0)", npc, par, idc); + if (!db.Execute(sqlstr, tbl)) { // Error al insertar + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (false); + } + // Recupera el identificador del nuevo perfil software + sprintf(sqlstr, "SELECT LAST_INSERT_ID() as identificador"); + if (!db.Execute(sqlstr, tbl)) { // Error al leer + tbl.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (false); + } + if (!tbl.ISEOF()) { // Si existe registro + if (!tbl.Get("identificador", nwidperfilsoft)) { + tbl.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (false); + } + } + // Crea la relación entre perfiles y componenetes software + for (i = 0; i < lon; i++) { + sprintf(sqlstr, + "INSERT perfilessoft_softwares (idperfilsoft,idsoftware)" + " VALUES(%d,%d)", nwidperfilsoft, tbidsoftware[i]); + if (!db.Execute(sqlstr, tbl)) { // Error al insertar + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (false); + } + } + } else { // Existe un perfil con todos esos componentes + if (!tbl.Get("idperfilsoft", nwidperfilsoft)) { + tbl.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (false); + } + } + + if (idperfilsoftware != nwidperfilsoft) { // No coinciden los perfiles + // Actualiza el identificador del perfil software del ordenador + sprintf(sqlstr, + "UPDATE ordenadores_particiones SET idperfilsoft=%d,idimagen=0" + " WHERE idordenador=%s AND numpar=%s", nwidperfilsoft, ido, + par); + if (!db.Execute(sqlstr, tbl)) { // Error al insertar + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (false); + } + } + + /* DEPURACIÓN DE PERFILES SOFTWARE */ + + /* Eliminar Relación de softwares con Perfiles software que quedan húerfanos */ + sprintf(sqlstr, "DELETE FROM perfilessoft_softwares WHERE idperfilsoft IN "\ + " (SELECT idperfilsoft FROM perfilessoft WHERE idperfilsoft NOT IN"\ + " (SELECT DISTINCT idperfilsoft from ordenadores_particiones) AND idperfilsoft NOT IN"\ + " (SELECT DISTINCT idperfilsoft from imagenes))"); + if (!db.Execute(sqlstr, tbl)) { // Error al insertar + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (false); + } + /* Eliminar Perfiles software que quedan húerfanos */ + sprintf(sqlstr, "DELETE FROM perfilessoft WHERE idperfilsoft NOT IN" + " (SELECT DISTINCT idperfilsoft from ordenadores_particiones)"\ + " AND idperfilsoft NOT IN"\ + " (SELECT DISTINCT idperfilsoft from imagenes)"); + if (!db.Execute(sqlstr, tbl)) { // Error al insertar + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (false); + } + /* Eliminar Relación de softwares con Perfiles software que quedan húerfanos */ + sprintf(sqlstr, + "DELETE FROM perfilessoft_softwares WHERE idperfilsoft NOT IN" + " (SELECT idperfilsoft from perfilessoft)"); + if (!db.Execute(sqlstr, tbl)) { // Error al insertar + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (false); + } + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: enviaArchivo +// +// Descripción: +// Envia un archivo por la red, por bloques +// Parámetros: +// - socket_c: Socket del cliente que envió el mensaje +// - 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 enviaArchivo(SOCKET *socket_c, TRAMA *ptrTrama) { + char *nfl; + char modulo[] = "enviaArchivo()"; + + // Toma parámetros + nfl = copiaParametro("nfl",ptrTrama); // Toma nombre completo del archivo + if (!sendArchivo(socket_c, nfl)) { + errorLog(modulo, 57, FALSE); + return (FALSE); + } + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: enviaArchivo +// +// Descripción: +// Envia un archivo por la red, por bloques +// Parámetros: +// - socket_c: Socket del cliente que envió el mensaje +// - 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 recibeArchivo(SOCKET *socket_c, TRAMA *ptrTrama) { + char *nfl; + char modulo[] = "recibeArchivo()"; + + // Toma parámetros + nfl = copiaParametro("nfl",ptrTrama); // Toma nombre completo del archivo + ptrTrama->tipo = MSG_NOTIFICACION; + enviaFlag(socket_c, ptrTrama); + if (!recArchivo(socket_c, nfl)) { + errorLog(modulo, 58, FALSE); + return (FALSE); + } + return (TRUE); +} +// ________________________________________________________________________________________________________ +// Función: envioProgramacion +// +// Descripción: +// Envia un comando de actualización a todos los ordenadores que han sido programados con +// alguna acción para que entren en el bucle de comandos pendientes y las ejecuten +// Parámetros: +// - socket_c: Socket del cliente que envió el mensaje +// - 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 envioProgramacion(SOCKET *socket_c, TRAMA *ptrTrama) +{ + char sqlstr[LONSQL], msglog[LONSTD]; + char *idp,iph[LONIP],mac[LONMAC]; + Database db; + Table tbl; + int idx,idcomando; + char modulo[] = "envioProgramacion()"; + + if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexion + errorLog(modulo, 20, FALSE); + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + + idp = copiaParametro("idp",ptrTrama); // Toma identificador de laprogramación de la tabla acciones + + sprintf(sqlstr, "SELECT ordenadores.ip,ordenadores.mac,acciones.idcomando FROM acciones "\ + " INNER JOIN ordenadores ON ordenadores.ip=acciones.ip"\ + " WHERE acciones.idprogramacion=%s",idp); + if (!db.Execute(sqlstr, tbl)) { // Error al leer + errorLog(modulo, 21, FALSE); + db.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + if(tbl.ISEOF()) + return (TRUE); // No existen registros + + /* Prepara la trama de actualizacion */ + + initParametros(ptrTrama,0); + ptrTrama->tipo=MSG_COMANDO; + sprintf(ptrTrama->parametros, "nfn=Actualizar\r"); + + while (!tbl.ISEOF()) { // Recorre particiones + if (!tbl.Get("ip", iph)) { + tbl.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + if (!tbl.Get("idcomando", idcomando)) { + tbl.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + if(idcomando==1){ // Arrancar + if (!tbl.Get("mac", mac)) { + tbl.GetErrorErrStr(msglog); + errorInfo(modulo, msglog); + return (FALSE); + } + if (!Levanta(mac)) { + sprintf(msglog, "%s:%s", tbErrores[32], modulo); + errorInfo(modulo, msglog); + return (FALSE); + } + } + if (clienteDisponible(iph, &idx)) { // Si el cliente puede recibir comandos + strcpy(tbsockets[idx].estado, CLIENTE_OCUPADO); // Actualiza el estado del cliente + if (!mandaTrama(&tbsockets[idx].sock, ptrTrama)) { + errorLog(modulo, 26, FALSE); + return (FALSE); + } + close(tbsockets[idx].sock); // Cierra el socket del cliente hasta nueva disponibilidad + } + tbl.MoveNext(); + } + return (TRUE); // No existen registros +} + +// ******************************************************************************************************** +// PROGRAMA PRINCIPAL (SERVICIO) +// ******************************************************************************************************** +int main(int argc, char *argv[]) { + int i; + SOCKET socket_s; // Socket donde escucha el servidor + SOCKET socket_c; // Socket de los clientes que se conectan + socklen_t iAddrSize; + struct sockaddr_in local, cliente; + char modulo[] = "main()"; + + /*-------------------------------------------------------------------------------------------------------- + Validación de parámetros de ejecución y lectura del fichero de configuración del servicio + ---------------------------------------------------------------------------------------------------------*/ + if (!validacionParametros(argc, argv, 1)) // Valida parámetros de ejecución + exit(EXIT_FAILURE); + + if (!tomaConfiguracion(szPathFileCfg)) { // Toma parametros de configuracion + exit(EXIT_FAILURE); + } + /*-------------------------------------------------------------------------------------------------------- + Carga del catálogo de funciones que procesan las tramas (referencia directa por puntero a función) + ---------------------------------------------------------------------------------------------------------*/ + int cf = 0; + + strcpy(tbfuncionesServer[cf].nf, "Sondeo"); + tbfuncionesServer[cf++].fptr = &Sondeo; + strcpy(tbfuncionesServer[cf].nf, "respuestaSondeo"); + tbfuncionesServer[cf++].fptr = &respuestaSondeo; + + strcpy(tbfuncionesServer[cf].nf, "ConsolaRemota"); + tbfuncionesServer[cf++].fptr = &ConsolaRemota; + + strcpy(tbfuncionesServer[cf].nf, "EcoConsola"); + tbfuncionesServer[cf++].fptr = &EcoConsola; + + strcpy(tbfuncionesServer[cf].nf, "Actualizar"); + tbfuncionesServer[cf++].fptr = &Actualizar; + + strcpy(tbfuncionesServer[cf].nf, "Purgar"); + tbfuncionesServer[cf++].fptr = &Purgar; + + strcpy(tbfuncionesServer[cf].nf, "InclusionCliente"); + tbfuncionesServer[cf++].fptr = &InclusionCliente; + + strcpy(tbfuncionesServer[cf].nf, "AutoexecCliente"); + tbfuncionesServer[cf++].fptr = &AutoexecCliente; + + strcpy(tbfuncionesServer[cf].nf, "ComandosPendientes"); + tbfuncionesServer[cf++].fptr = &ComandosPendientes; + + strcpy(tbfuncionesServer[cf].nf, "DisponibilidadComandos"); + tbfuncionesServer[cf++].fptr = &DisponibilidadComandos; + + strcpy(tbfuncionesServer[cf].nf, "Arrancar"); + tbfuncionesServer[cf++].fptr = &Arrancar; + strcpy(tbfuncionesServer[cf].nf, "RESPUESTA_Arrancar"); + tbfuncionesServer[cf++].fptr = &RESPUESTA_Arrancar; + + strcpy(tbfuncionesServer[cf].nf, "Apagar"); + tbfuncionesServer[cf++].fptr = &Apagar; + strcpy(tbfuncionesServer[cf].nf, "RESPUESTA_Apagar"); + tbfuncionesServer[cf++].fptr = &RESPUESTA_Apagar; + + strcpy(tbfuncionesServer[cf].nf, "Reiniciar"); + tbfuncionesServer[cf++].fptr = &Reiniciar; + strcpy(tbfuncionesServer[cf].nf, "RESPUESTA_Reiniciar"); + tbfuncionesServer[cf++].fptr = &RESPUESTA_Reiniciar; + + strcpy(tbfuncionesServer[cf].nf, "IniciarSesion"); + tbfuncionesServer[cf++].fptr = &IniciarSesion; + strcpy(tbfuncionesServer[cf].nf, "RESPUESTA_IniciarSesion"); + tbfuncionesServer[cf++].fptr = &RESPUESTA_IniciarSesion; + + strcpy(tbfuncionesServer[cf].nf, "CrearImagen"); + tbfuncionesServer[cf++].fptr = &CrearImagen; + strcpy(tbfuncionesServer[cf].nf, "RESPUESTA_CrearImagen"); + tbfuncionesServer[cf++].fptr = &RESPUESTA_CrearImagen; + + strcpy(tbfuncionesServer[cf].nf, "RestaurarImagen"); + tbfuncionesServer[cf++].fptr = &RestaurarImagen; + strcpy(tbfuncionesServer[cf].nf, "RESPUESTA_RestaurarImagen"); + tbfuncionesServer[cf++].fptr = &RESPUESTA_RestaurarImagen; + + strcpy(tbfuncionesServer[cf].nf, "Configurar"); + tbfuncionesServer[cf++].fptr = &Configurar; + strcpy(tbfuncionesServer[cf].nf, "RESPUESTA_Configurar"); + tbfuncionesServer[cf++].fptr = &RESPUESTA_Configurar; + + strcpy(tbfuncionesServer[cf].nf, "EjecutarScript"); + tbfuncionesServer[cf++].fptr = &EjecutarScript; + strcpy(tbfuncionesServer[cf].nf, "RESPUESTA_EjecutarScript"); + tbfuncionesServer[cf++].fptr = &RESPUESTA_EjecutarScript; + + strcpy(tbfuncionesServer[cf].nf, "InventarioHardware"); + tbfuncionesServer[cf++].fptr = &InventarioHardware; + strcpy(tbfuncionesServer[cf].nf, "RESPUESTA_InventarioHardware"); + tbfuncionesServer[cf++].fptr = &RESPUESTA_InventarioHardware; + + strcpy(tbfuncionesServer[cf].nf, "InventarioSoftware"); + tbfuncionesServer[cf++].fptr = &InventarioSoftware; + strcpy(tbfuncionesServer[cf].nf, "RESPUESTA_InventarioSoftware"); + tbfuncionesServer[cf++].fptr = &RESPUESTA_InventarioSoftware; + + strcpy(tbfuncionesServer[cf].nf, "enviaArchivo"); + tbfuncionesServer[cf++].fptr = &enviaArchivo; + + strcpy(tbfuncionesServer[cf].nf, "recibeArchivo"); + tbfuncionesServer[cf++].fptr = &recibeArchivo; + + strcpy(tbfuncionesServer[cf].nf, "envioProgramacion"); + tbfuncionesServer[cf++].fptr = &envioProgramacion; + + /*-------------------------------------------------------------------------------------------------------- + // Inicializa array de información de los clientes + ---------------------------------------------------------------------------------------------------------*/ + for (i = 0; i < MAXIMOS_CLIENTES; i++) { + tbsockets[i].ip[0] = '\0'; + tbsockets[i].sock = INVALID_SOCKET; + } + /*-------------------------------------------------------------------------------------------------------- + Creación y configuración del socket del servicio + ---------------------------------------------------------------------------------------------------------*/ + socket_s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); // Crea socket del servicio + if (socket_s == SOCKET_ERROR) { // Error al crear el socket del servicio + errorLog(modulo, 13, TRUE); + exit(EXIT_FAILURE); + } + + local.sin_addr.s_addr = htonl(INADDR_ANY); // Configura el socket del servicio + local.sin_family = AF_INET; + local.sin_port = htons(atoi(puerto)); + + if (bind(socket_s, (struct sockaddr *) &local, sizeof(local)) + == SOCKET_ERROR) { // Enlaza socket + errorLog(modulo, 14, TRUE); + exit(EXIT_FAILURE); + } + + listen(socket_s, 250); // Pone a escuchar al socket + iAddrSize = sizeof(cliente); + /*-------------------------------------------------------------------------------------------------------- + Bucle para acceptar conexiones + ---------------------------------------------------------------------------------------------------------*/ + infoLog(1); // Inicio de sesión + while (TRUE) { + socket_c = accept(socket_s, (struct sockaddr *) &cliente, &iAddrSize); + if (socket_c == INVALID_SOCKET) { + errorLog(modulo, 15, TRUE); + exit(EXIT_FAILURE); + } + swcSocket = FALSE; // Por defecto se cerrara el socket de cliente después del anális de la trama + if (!gestionaTrama(&socket_c)) { + errorLog(modulo, 39, TRUE); + //close(socket_c); + //break; + } + if (!swcSocket) // Sólo se cierra cuando el cliente NO espera comandos ineractivos + close(socket_c); + } + /*-------------------------------------------------------------------------------------------------------- + Fin del servicio + ---------------------------------------------------------------------------------------------------------*/ + close(socket_s); + exit(EXIT_SUCCESS); +} diff --git a/sources/ogAdmServer.h b/sources/ogAdmServer.h new file mode 100644 index 0000000..13a5357 --- /dev/null +++ b/sources/ogAdmServer.h @@ -0,0 +1,118 @@ +// ******************************************************************************************************** +// Servicio: ogAdmServer +// Autor: José Manuel Alonso (E.T.S.I.I.) Universidad de Sevilla +// Fecha Creación: Marzo-2010 +// Fecha Última modificación: Marzo-2010 +// Nombre del fichero: ogAdmServer.h +// Descripción: Este fichero implementa el servicio de administración general del sistema +// ******************************************************************************************************** +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <ctype.h> +#include <errno.h> +#include <unistd.h> +#include <time.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <arpa/inet.h> +#include </usr/include/mysql/mysql.h> +#include "Database.h" +#include "ogAdmLib.h" +// ________________________________________________________________________________________________________ +// Variables globales +// ________________________________________________________________________________________________________ +char servidoradm[LONPRM]; // Dirección IP del servidor de administración +char puerto[LONPRM]; // Puerto de comunicación +char usuario[LONPRM]; // Usuario de acceso a la base de datos +char pasguor[LONPRM]; // Password del usuario +char datasource[LONPRM]; // Dirección IP del gestor de base de datos +char catalog[LONPRM]; // Nombre de la base de datos +char aulaup[LONPRM]; // Conmutador para registro automático de clientes + +typedef struct{ // Estructura usada para guardar información de los clientes + char ip[LONIP]; // IP del cliente + char estado[4]; // Tipo de Sistema Operativo en que se encuentra el cliente + SOCKET sock; // Socket por el que se comunica +}SOCKETCL; +SOCKETCL tbsockets[MAXIMOS_CLIENTES]; + +BOOLEAN swcSocket; // Switch para indicar si se debe cerrar el socket del cliente + +typedef struct{ // Estructura usada para referenciar las funciones que procesan las tramas + char nf[LONFUN]; // Nombre de la función + BOOLEAN (*fptr)(SOCKET*,TRAMA*); // Puntero a la función que procesa la trama +}MSGFUN; +MSGFUN tbfuncionesServer[MAXIMAS_FUNCIONES]; +// ________________________________________________________________________________________________________ +// Prototipo de funciones +// ________________________________________________________________________________________________________ + +BOOLEAN tomaConfiguracion(char*); +BOOLEAN gestionaTrama(SOCKET*); +BOOLEAN Sondeo(SOCKET*,TRAMA*); +BOOLEAN respuestaSondeo(SOCKET *,TRAMA*); +BOOLEAN InclusionCliente(SOCKET*,TRAMA*); +BOOLEAN registraCliente(char *); + +BOOLEAN procesoInclusionCliente(SOCKET*,TRAMA*); +BOOLEAN clienteExistente(char *,int *); +BOOLEAN clienteDisponible(char *,int *); +BOOLEAN hayHueco(int *); +BOOLEAN actualizaConfiguracion(Database , Table ,char* ,int); +BOOLEAN AutoexecCliente(SOCKET *, TRAMA *); +BOOLEAN recorreProcedimientos(Database ,char* ,FILE*,char*); + +BOOLEAN tomaRepositorio(Database ,Table ,char*,int*); +BOOLEAN buscaComandos(char *,TRAMA *,int *); +BOOLEAN DisponibilidadComandos(SOCKET*,TRAMA*); +BOOLEAN respuestaEstandar(TRAMA *,char **,char **,char ** ,Database *,Table *); +BOOLEAN respuestaConsola(SOCKET *,TRAMA *,int); +BOOLEAN enviaComando(TRAMA *ptrTrama,const char*); + +BOOLEAN Actualizar(SOCKET *, TRAMA* ); +BOOLEAN Purgar(SOCKET *, TRAMA* ); + +BOOLEAN ConsolaRemota(SOCKET *,TRAMA*); +BOOLEAN RESPUESTA_ConsolaRemota(SOCKET *,TRAMA*); +BOOLEAN EcoConsola(SOCKET *,TRAMA*); + +BOOLEAN Comando(SOCKET *,TRAMA *); +BOOLEAN RESPUESTA_Comando(SOCKET *,TRAMA *); + +BOOLEAN Arrancar(SOCKET *,TRAMA *); +BOOLEAN Levanta(char*); +BOOLEAN WakeUp(SOCKET *,char *); +void PasaHexBin(char *,char *); +BOOLEAN RESPUESTA_Arrancar(SOCKET *,TRAMA*); +BOOLEAN Apagar(SOCKET *,TRAMA *); +BOOLEAN RESPUESTA_Apagar(SOCKET *,TRAMA *); +BOOLEAN Reiniciar(SOCKET *,TRAMA *); +BOOLEAN RESPUESTA_Reiniciar(SOCKET *,TRAMA *); +BOOLEAN IniciarSesion(SOCKET *,TRAMA *); +BOOLEAN RESPUESTA_IniciarSesion(SOCKET *,TRAMA *); +BOOLEAN CrearImagen(SOCKET *,TRAMA *); +BOOLEAN RESPUESTA_CrearImagen(SOCKET *,TRAMA *); +BOOLEAN actualizaCreacionImagen(Database,Table,char*,char*,char*,char*,char*); +BOOLEAN RestaurarImagen(SOCKET *,TRAMA *); +BOOLEAN RESPUESTA_RestaurarImagen(SOCKET *,TRAMA *); +BOOLEAN actualizaRestauracionImagen(Database,Table,char*,char*,char*,char*); +BOOLEAN Configurar(SOCKET *,TRAMA* ); +BOOLEAN RESPUESTA_Configurar(SOCKET *,TRAMA* ); +BOOLEAN actualizaConfigurar(Database , Table , char* ); +BOOLEAN InventarioHardware(SOCKET *,TRAMA *); +BOOLEAN RESPUESTA_InventarioHardware(SOCKET *,TRAMA *); +BOOLEAN actualizaHardware(Database, Table,char* ,char*,char*,char*); +BOOLEAN cuestionPerfilHardware(Database,Table,char*,char*,int,char*,char*,int *,int); +BOOLEAN actualizaSoftware(Database , Table , char* , char* , char*,char*,char*); +BOOLEAN cuestionPerfilSoftware(Database, Table, char*, char*,int,char*,char*,char*,int *,int); + +BOOLEAN enviaArchivo(SOCKET *, TRAMA *); +BOOLEAN recibeArchivo(SOCKET *, TRAMA *); +BOOLEAN envioProgramacion(SOCKET *, TRAMA *); + +int checkDato(Database,Table,char*,const char*,const char*,const char*); + + + |