void handler_seniales(int s) {
desconectar();
liberar_recursos();
kill(getpid(), SIGKILL);
}
void terminar ()
{ int i;
desconectar(fdlisten);
for(i=bots;i<jugadores;i++)
desconectar(fdclientes[i]);
printf("Cierre del servidor!\n");fflush(stdout);
shmctl (id_mem, IPC_RMID, (struct shmid_ds *)NULL);
shmctl (id_memd, IPC_RMID, (struct shmid_ds *)NULL);
shmctl (id_memdx, IPC_RMID, (struct shmid_ds *)NULL);
shmctl (id_memdy, IPC_RMID, (struct shmid_ds *)NULL);
printf("Matando procesos hijos...");fflush(stdout);
for(i=0;i<bots;i++)
{ kill(botpid[i],SIGKILL) ;
wait(NULL); }
printf("Ok\nTerminando proceso...\n");fflush(stdout);
raise(9);
}
Tuntorialsqlite::Tuntorialsqlite(QWidget *parent) :
QDialog(parent),
ui(new Ui::Tuntorialsqlite)
{
ui->setupUi(this);
this->setWindowTitle("Tutorial SQLITE");
habilitar_query(false);
valoresIniciais();
connect(ui->btn_conectar, SIGNAL(clicked()), this, SLOT(validarCampos()))
connect(ui->btn_desconectar,SIGNAL(clicked()), this,SLOT(desconectar()))
connect(ui->btn_executar, SIGNAL(clicked(),this, SLOT (enviarQuery)))
txt_query = new QSqlQueryModel;
}
int MainCliente::salir(){
mapMensajes.clear(); // chequear si se liberan los string
desconectar();
return 0;
}
int MainCliente::conectarYEjecutar(){
//----------------------CONECTAR-BEGIN------------------
#ifdef FAKE_DEBUG_CLIENTE
VistaJuego::getInstance()->getJugador()->nombreDeUsuario.assign("Cliente-A");
#else
VistaJuego * visJue = VistaJuego::getInstance();
VistaInicio * visIni = VistaInicio::getInstance();
this->ip = visIni->getIP();
this->port = visIni->getPuerto();
visJue->getJugador()->nombreDeUsuario.assign(visIni->getUsuario());
#endif
inicializarConexion();
if(conectado == true){
Log::getInstance()->warn(" el cliente ya se encuentra conectado.");
printf("ya se encuentra conectado \n");
}
else{
//Intentamos establecer la conexión
int conex=connect(sock,(sockaddr *)&direc, sizeof(sockaddr));
if (conex==-1) //si no se ha podido conectar porque no se ha encontrado el host o no está el puerto abierto
{
Log::getInstance()->error(" no se ha podido conectar.");
printf("No se ha podido conectar\n");
printf("%i", conex);
return -1;
}
else{
// Se envia un mensaje al servidor para que valide el nombre de usuario
MensajeXml mensajeUsuario;
mensajeUsuario.setValor((char*)VistaJuego::getInstance()->getJugador()->nombreDeUsuario.c_str(), strlen(VistaJuego::getInstance()->getJugador()->nombreDeUsuario.c_str()));
mensajeUsuario.setTipo(TIPO_STRING);
mensajeUsuario.calculateSizeBytes();
char bufferSalida [MAX_BUFFER];
int size = Protocolo::codificar(mensajeUsuario, bufferSalida);
MensajeSeguro::enviar(sock, bufferSalida, size);
char bufferEntrada[MAX_BUFFER];
// Se recibe la confirmación de la validación del nombre de usuario
int len2 = MensajeSeguro::recibir(sock,bufferEntrada);
if (len2 <= 0){// Es un error
chequearConexion(len2);
}
else{
//decodificar el mensaje
MensajeXml mensaXmlRespuestaUsuario;
int offset = Protocolo::decodificar(bufferEntrada,&mensaXmlRespuestaUsuario);
char * respuesta = mensaXmlRespuestaUsuario.getValor();
if (strcmp(respuesta,MSJ_CONEX_ACEPT) == 0){
char* idUsuario;
Posicion posicion;
Posicion posicionMapa;
// Si el server nos envia respuesta, es que la conexion ha sido satisfactoria
Log::getInstance()->info("El cliente se ha conectado correctamente.");
conectado = true;
MainCliente::serverDesconectado = false;
MainCliente::cerrarConexion = false;
// Decodifica cómo se juega
MensajeXml mensaXmlModoDeJuego;
offset += Protocolo::decodificar(bufferEntrada + offset,&mensaXmlModoDeJuego);
char * modoDeJuego = mensaXmlModoDeJuego.getValor();
if (strcmp(modoDeJuego, MODO_EQUIPO) == 0) {
// Decodifica si hay equipos libres
MensajeXml mensaXmlDisponibilidadEquipos;
offset += Protocolo::decodificar(bufferEntrada + offset,&mensaXmlDisponibilidadEquipos);
char * disponibilidadEquipos = mensaXmlDisponibilidadEquipos.getValor();
if (strcmp(disponibilidadEquipos, HAY_DISPONIBILIDAD) == 0) {
VistaInicio::getInstance()->mostrarSeleccionDeEquipos();
string equipo = VistaInicio::getInstance()->getEquipo();
// Envio qué equipo se seleccionó
MensajeXml mensajeEquipo;
mensajeEquipo.setValor((char*)equipo.c_str(), strlen(equipo.c_str()));
mensajeEquipo.setTipo(TIPO_STRING);
mensajeEquipo.calculateSizeBytes();
char bufferSalida [MAX_BUFFER];
int size = Protocolo::codificar(mensajeEquipo, bufferSalida);
MensajeSeguro::enviar(sock, bufferSalida, size);
}
MensajeXml mensaXml;
offset += Protocolo::decodificar(bufferEntrada + offset,&mensaXml);
char* idUsuarioXml = mensaXml.getValor();
idUsuario= new char[strlen(idUsuarioXml) + 1];
std::copy(idUsuarioXml, idUsuarioXml + strlen(idUsuarioXml), idUsuario);
// Se decodifica la posicion inicial desde donde arranca el avión
offset += Protocolo::decodificar(bufferEntrada + offset, &posicion);
// Se decodifica la posicion del mapa, que tiene solo una componente: Y
offset += Protocolo::decodificar(bufferEntrada + offset, &posicionMapa);
//se procede a decodificar el resto del mensaje
//se decodifica el escenario completo
offset += Protocolo::decodificar(bufferEntrada + offset,this->servidorXml);
}
else {
// Se juega sin equipos
MensajeXml mensaXml;
offset += Protocolo::decodificar(bufferEntrada + offset,&mensaXml);
char* idUsuarioXml = mensaXml.getValor();
idUsuario= new char[strlen(idUsuarioXml) + 1];
std::copy(idUsuarioXml, idUsuarioXml + strlen(idUsuarioXml), idUsuario);
// Se decodifica la posicion inicial desde donde arranca el avión
offset += Protocolo::decodificar(bufferEntrada + offset, &posicion);
// Se decodifica la posicion del mapa, que tiene solo una componente: Y
offset += Protocolo::decodificar(bufferEntrada + offset, &posicionMapa);
//se procede a decodificar el resto del mensaje
//se decodifica el escenario completo
offset += Protocolo::decodificar(bufferEntrada + offset,this->servidorXml);
}
// Se cierra la ventana del menu de inicio
VistaInicio::getInstance()->close();
// Creo un hilo para escuchar los mensajes
receptor=SDL_CreateThread(fun_recibirMensajes, "recibirMensajes", &sock);
//----------------------CONECTAR-END------------------
VistaJuego *visJuego = VistaJuego::getInstance();
visJuego->getJugador()->nombreDeUsuario.assign(VistaInicio::getInstance()->getUsuario());
visJuego->getJugador()->setIdCliente(atoi(idUsuario));
visJuego->getJugador()->setPosicionAvion(posicion);
visJuego->readServidorXml(this->servidorXml);
visJuego->agregarObservador(this);
//----------------------EJECUTAR-BEGIN------------------
visJuego->inicializar();
visJuego->ejecutar(this->servidorXml, posicionMapa.getPosY());
// se termina el programa cuando el usuario hace click en x del SDL_window
//----------------------EJECUTAR-END------------------
terminarElCliente();
}
else if (strcmp(respuesta,MSJ_SUPERO_MAX) == 0){
// El server envia un mensaje al superar la cantidad de clientes
Log::getInstance()->error(bufferEntrada);
#ifndef FAKE_DEBUG_CLIENTE
VistaInicio::getInstance()->mostrarMensajeInformacion(MSJ_SUPERO_MAX);
#endif
shutdown(sock,2);
closesocket(sock);
terminarElCliente();
}
else if (strcmp(respuesta, MSJ_USR_YA_CONECT) == 0) {
// El server ya tiene un usuario igual y está conectado
Log::getInstance()->error(bufferEntrada);
#ifndef FAKE_DEBUG_CLIENTE
VistaInicio::getInstance()->mostrarMensajeInformacion(MSJ_USR_YA_CONECT);
#endif
desconectar();
terminarElCliente();
}
}
}
}
return 0;
}
int main(int argc, char * argv[]) {
int s, r;
struct sockaddr_in dest;
char buffer[MAXBUF];
struct Mensaje mensaje;
if (argc < 3) {
puts("Usage ./cliente [nombre] [pos1] ...");
return EXIT_FAILURE;
}
signal(SIGKILL, handler_seniales);
signal(SIGTERM, handler_seniales);
cantidad_barcos_hundidos = 0;
// Validacion de las posiciones de la matriz
cantidad_barcos = argc - 2; // Le resto los primeros 2 argumentos: ejecutable y nombre de jugador
//char * posiciones[cantidad_barcos];
if (validarPosiciones(argv, posiciones_barcos) == -1) {
return EXIT_FAILURE;
}
//posiciones_barcos = posiciones;
// Leo ip y puerto del servidor del archivo de configuracion
struct Conexion conexion = leerConfiguracion();
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
perror("Socket");
return EXIT_FAILURE;
}
/*---Initialize server address/port struct---*/
bzero(&dest, sizeof(dest));
dest.sin_family = AF_INET;
dest.sin_port = htons(conexion.puerto);
if (inet_aton(conexion.ip, &dest.sin_addr.s_addr) == 0) {
perror(conexion.ip);
return EXIT_FAILURE;
}
/*---Connect to server---*/
if (connect(sockfd, &dest, sizeof(dest)) != 0) {
perror("Connect ");
return EXIT_FAILURE;
}
bzero(buffer, MAXBUF);
// Enviar nombre jugador
mensaje.tipo = Registra_Nombre;
strcpy(mensaje.contenido, argv[1]);
sleep(2);
s = send(sockfd, &mensaje, sizeof(mensaje), 0);
if (s == -1) {
perror("Error al enviar el nombre del jugador");
return EXIT_FAILURE;
}
// Recibo la estructura del jugador registrado.
r = recv(sockfd, buffer, sizeof(struct MensajeNIPC), 0);
memcpy(&jugador, buffer + sizeof(TIPO_MENSAJE) + sizeof(int),
sizeof(struct Jugador));
printf("Se ha registrado en el servidor como el jugador %s.\n",
jugador.nombre);
if (mostrar_lista() == -1) {
return EXIT_FAILURE;
}
desconectar();
liberar_recursos();
return EXIT_SUCCESS;
}
/*
* PLANIFICADOR
*/
void *planificador(void * pvNivel) {
// Armo el nivel que planifico con los parametros que recibe el hilo
tNivel *pNivel;
pNivel = (tNivel*) pvNivel;
//Para multiplexar
int iSocketConexion;
fd_set readfds;
FD_ZERO(&readfds);
tMensaje tipoMensaje = NADA;
tPersonaje* pPersonajeActual;
char* sPayload;
pPersonajeActual = NULL;
// Ciclo donde se multiplexa para escuchar personajes que se conectan
while (1) {
if(tipoMensaje!=N_MUERTO_POR_ENEMIGO){
waitPersonajes(pNivel, &pPersonajeActual);
}
iSocketConexion = multiplexar(&pNivel->masterfds, &readfds, &pNivel->maxSock, &tipoMensaje, &sPayload, logger);
if (iSocketConexion != -1) {
switch (tipoMensaje) {
/* Mensajes que puede mandar el personaje */
case(P_POS_RECURSO):
personajeSolicitaPosicionRecurso(pNivel, pPersonajeActual, iSocketConexion, sPayload, logger);
break;
case(P_MOVIMIENTO):
movimientoPersonaje(iSocketConexion, sPayload, pNivel, &pPersonajeActual);
break;
case(P_SOLICITUD_RECURSO):
solicitudRecursoPersonaje(iSocketConexion, sPayload, pNivel, &pPersonajeActual);
break;
// //Cuando llega al recurso y aún
// case(P_FIN_TURNO):
// seleccionarJugador(&pPersonajeActual, pNivel);
// break;
/* Mensajes que puede mandar el nivel */
case(N_POS_RECURSO):
entregoPosicionRecursoAlPersonaje(pNivel, pPersonajeActual, iSocketConexion, sPayload, logger);
seleccionarJugador(&pPersonajeActual, pNivel);
break;
case(N_ACTUALIZACION_CRITERIOS):
actualizacionCriteriosNivel(iSocketConexion, sPayload, pNivel, pPersonajeActual);
break;
case(N_MUERTO_POR_ENEMIGO):
muertePorEnemigoPersonaje(pNivel, &pPersonajeActual, iSocketConexion, sPayload);
break;
case(N_MUERTO_POR_DEADLOCK):
muertePorDeadlockPersonaje(pNivel, sPayload);
break;
case(N_ENTREGA_RECURSO):
recepcionRecurso(pNivel, &pPersonajeActual, sPayload);
seleccionarJugador(&pPersonajeActual, pNivel);
break;
case(N_BLOQUEADO_RECURSO):
recepcionBloqueado(pNivel, &pPersonajeActual, sPayload);
seleccionarJugador(&pPersonajeActual, pNivel);
break;
case(N_CONFIRMACION_MOV):
confirmarMovimiento(pNivel, pPersonajeActual);
seleccionarJugador(&pPersonajeActual, pNivel);
break;
case(DESCONEXION):
desconectar(pNivel, &pPersonajeActual, iSocketConexion);
if(pPersonajeActual == NULL)
seleccionarJugador(&pPersonajeActual, pNivel);
break;
default:
log_error(logger, "Mensaje no esperado");
break;
} //Fin de switch
} //Fin del if
} //Fin del while
pthread_exit(NULL);
}
