int main(void)
{
CURL *curl;
char *buffer = malloc(10000);
time_t curtime;
char *date = malloc(100);
char url[1000];
jsmntok_t tokens[MAX_TOK];
t_calendar *lst = NULL;
t_conf *conf = malloc(sizeof(t_conf));
t_serv udp_serv;
/* INIT */
time(&curtime);
bzero(&udp_serv, sizeof(t_serv));
curl = curl_easy_init();
get_time(&date, curtime);
conf_update(conf, url, date);
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writer);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, &buffer);
init_serveur_udp(&udp_serv);
if(!curl)
exit(0);
while(1)
{
if (check_notif(&udp_serv))
{
if (udp_serv.mesg[0] == 'U')
printf("i'll update calendar\n");
else if (udp_serv.mesg[0] == 'P')
printf("Someone is looking for me PING MODE on\n");
printf("{%s}\n",udp_serv.mesg);
curl_easy_perform(curl); /* getting info from webservice with curl */
json_parse(buffer, tokens); /* parsing data from curl's buffer in the tokken's struct */
//clean_calendar(lst);
lst = update_calendar(buffer, tokens); /* on clean l'ancien calendar et on update un nouveau */
break ;
}
usleep(500000);
}
printf("%s\n\n",buffer);
print_lst(lst);
printf(" %lu\n", curtime);
curl_easy_cleanup(curl);
return 0;
}
int main(int argc, char **argv)
{
/* Parse command line arguments. */
int c = 0, li = 0;
int daemonize = 0;
const char *config_fn = CONF_DEFAULT_FILE;
const char *config_db = NULL;
const char *daemon_root = "/";
/* Long options. */
struct option opts[] = {
{"config", required_argument, 0, 'c' },
{"confdb", required_argument, 0, 'C' },
{"daemonize", optional_argument, 0, 'd'},
{"version", no_argument, 0, 'V'},
{"help", no_argument, 0, 'h'},
{0, 0, 0, 0}
};
while ((c = getopt_long(argc, argv, "c:C:dVh", opts, &li)) != -1) {
switch (c) {
case 'c':
config_fn = optarg;
break;
case 'C':
config_db = optarg;
break;
case 'd':
daemonize = 1;
if (optarg) {
daemon_root = optarg;
}
break;
case 'V':
printf("%s, version %s\n", "Knot DNS", PACKAGE_VERSION);
return EXIT_SUCCESS;
case 'h':
case '?':
help();
return EXIT_SUCCESS;
default:
help();
return EXIT_FAILURE;
}
}
/* Check for non-option parameters. */
if (argc - optind > 0) {
help();
return EXIT_FAILURE;
}
/* Now check if we want to daemonize. */
if (daemonize) {
if (make_daemon(1, 0) != 0) {
fprintf(stderr, "Daemonization failed, shutting down...\n");
return EXIT_FAILURE;
}
}
/* Clear file creation mask. */
umask(0);
/* Setup base signal handling. */
setup_signals();
/* Initialize cryptographic backend. */
dnssec_crypto_init();
atexit(dnssec_crypto_cleanup);
/* Initialize pseudorandom number generator. */
srand(time(NULL));
/* POSIX 1003.1e capabilities. */
setup_capabilities();
/* Default logging to std out/err. */
log_init();
/* Open configuration. */
conf_t *new_conf = NULL;
if (config_db == NULL) {
int ret = conf_new(&new_conf, conf_scheme, NULL);
if (ret != KNOT_EOK) {
log_fatal("failed to initialize configuration database "
"(%s)", knot_strerror(ret));
log_close();
return EXIT_FAILURE;
}
/* Import the configuration file. */
ret = conf_import(new_conf, config_fn, true);
if (ret != KNOT_EOK) {
log_fatal("failed to load configuration file (%s)",
knot_strerror(ret));
conf_free(new_conf, false);
log_close();
return EXIT_FAILURE;
}
new_conf->filename = strdup(config_fn);
} else {
/* Open configuration database. */
int ret = conf_new(&new_conf, conf_scheme, config_db);
if (ret != KNOT_EOK) {
log_fatal("failed to open configuration database '%s' "
"(%s)", config_db, knot_strerror(ret));
log_close();
return EXIT_FAILURE;
}
}
/* Run post-open config operations. */
int res = conf_post_open(new_conf);
if (res != KNOT_EOK) {
log_fatal("failed to use configuration (%s)", knot_strerror(res));
conf_free(new_conf, false);
log_close();
return EXIT_FAILURE;
}
conf_update(new_conf);
/* Initialize logging subsystem. */
log_reconfigure(conf(), NULL);
/* Initialize server. */
server_t server;
res = server_init(&server, conf_bg_threads(conf()));
if (res != KNOT_EOK) {
log_fatal("failed to initialize server (%s)", knot_strerror(res));
conf_free(conf(), false);
log_close();
return EXIT_FAILURE;
}
/* Reconfigure server interfaces.
* @note This MUST be done before we drop privileges. */
server_reconfigure(conf(), &server);
log_info("configured %zu zones", conf_id_count(conf(), C_ZONE));
/* Alter privileges. */
int uid, gid;
if (conf_user(conf(), &uid, &gid) != KNOT_EOK ||
log_update_privileges(uid, gid) != KNOT_EOK ||
proc_update_privileges(uid, gid) != KNOT_EOK) {
log_fatal("failed to drop privileges");
server_deinit(&server);
conf_free(conf(), false);
log_close();
return EXIT_FAILURE;
}
/* Check and create PID file. */
long pid = (long)getpid();
char *pidfile = NULL;
if (daemonize) {
pidfile = pid_check_and_create();
if (pidfile == NULL) {
server_deinit(&server);
conf_free(conf(), false);
log_close();
return EXIT_FAILURE;
}
log_info("PID stored in '%s'", pidfile);
if (chdir(daemon_root) != 0) {
log_warning("failed to change working directory to %s",
daemon_root);
} else {
log_info("changed directory to %s", daemon_root);
}
}
/* Now we're going multithreaded. */
rcu_register_thread();
/* Populate zone database. */
log_info("loading zones");
server_update_zones(conf(), &server);
/* Check number of loaded zones. */
if (knot_zonedb_size(server.zone_db) == 0) {
log_warning("no zones loaded");
}
/* Start it up. */
log_info("starting server");
conf_val_t async_val = conf_get(conf(), C_SRV, C_ASYNC_START);
res = server_start(&server, conf_bool(&async_val));
if (res != KNOT_EOK) {
log_fatal("failed to start server (%s)", knot_strerror(res));
server_deinit(&server);
rcu_unregister_thread();
pid_cleanup(pidfile);
log_close();
conf_free(conf(), false);
return EXIT_FAILURE;
}
if (daemonize) {
log_info("server started as a daemon, PID %ld", pid);
} else {
log_info("server started in the foreground, PID %ld", pid);
init_signal_started();
}
/* Start the event loop. */
event_loop(&server);
/* Teardown server and configuration. */
server_deinit(&server);
/* Free configuration. */
conf_free(conf(), false);
/* Unhook from RCU. */
rcu_unregister_thread();
/* Cleanup PID file. */
pid_cleanup(pidfile);
log_info("shutting down");
log_close();
return EXIT_SUCCESS;
}
int main (int argc, char **argv) {
// variables
SDL_Surface *screen; // pantalla
SDL_Event event; // para los eventos de SDL (teclado y/o mouse)
Uint8 *keystates = SDL_GetKeyState(NULL); // para detectar teclas mantenidas presionadas
Uint8 salir = 0; // para determinar cuando se cierra la ventana
int mouse_x=0, mouse_y=0; // coordenadas del mouse
char info1[100]; // texto para mostrar informacion variada linea 1
char info2[100]; // texto para mostrar informacion variada linea 2
short int time; // variable para la hora
short int ticks; // variable para mover elementos independiente de los FPS
// cargar configuracion
struct conf *conf = conf_load();
if (!conf)
return EXIT_FAILURE;
// verificar a donde nos queremos conectar
// se indicó el servidor como 1er parametro
if(argc>=2) {
free(conf->SERVER);
conf->SERVER = malloc(strlen(argv[1]));
strcpy(conf->SERVER, argv[1]);
}
// se indicó el puerto como 2do parametro
if(argc>=3) {
conf->PORT = atoi(argv[2]);
}
// conectar al servidor
int connection = client_init(conf);
if (!connection)
return EXIT_FAILURE;
// buffer para transferencia entre servidor y cliente
char buffer[BUFFER_SIZE];
// obtener id del jugador
int playerID = atoi(query("get;id", connection));
// recibir y actualizar configuraciones desde el servidor
conf_update(conf, query("get;conf", connection));
// inicializar sistema
sdl_init(&screen);
// cargar fuente
TTF_Font *fuente = ttf_load(FONT_NAME, FONT_SIZE, FONT_STYLE);
// cargar todos los posibles objetos de un mapa
MapObject *mapobjects = mapobjects_load(screen);
if (!mapobjects)
return EXIT_FAILURE;
// cargar mapa
char **map = map_open(conf->MAP);
if (!map)
return EXIT_FAILURE;
// cargar armas
Weapon *weapons = weapons_load();
if (!weapons)
return EXIT_FAILURE;
// crear personaje jugador
Player *pj = player_create(playerID, conf->PLAYER_NAME, conf->PLAYER_CHARACTER, screen, weapons, conf);
// asignar armas al personaje
player_change_weapon(&pj, conf->WEAPON_PRIMARY, 1);
player_change_weapon(&pj, conf->WEAPON_SECONDARY, 2);
// ubicar personaje en el mapa
player_set_position(&pj, map, -1, -1, mapobjects);
// informar estado del usuario
bzero(buffer, sizeof(buffer));
sprintf(buffer, "info;%s;%s", conf->PLAYER_CHARACTER, conf->PLAYER_NAME);
write(connection, buffer, strlen(buffer));
// crear bots y ubicar en el mapa
Player *bots = bots_create(screen, weapons, conf);
int i;
for(i=0; i<conf->BOTS; ++i) {
Player *aux = &bots[i];
player_set_position(&aux, map, -1, -1, mapobjects);
}
// guardar ticks
ticks = SDL_GetTicks();
// ciclo infinito para refrescar la imagen de la pantalla
while (!salir) {
// solicitar informacion de todos los jugadores (menos el mio)
char *enemies = query("get;players", connection);
// enviar posicion del jugador al servidor
sprintf(buffer, "position;%d;%d", (int)(pj->y), (int)(pj->x));
write(connection, buffer, strlen(buffer));
// time
time = SDL_GetTicks()/1000;
// dibujar mapa
map_draw(screen, map, mapobjects, conf->BACKGROUND);
// revisar si existen eventos de SDL
while (SDL_PollEvent(&event)) {
// salir del programa
if(event.type==SDL_QUIT) salir = 1;
// si se presiona una tecla
else if(event.type==SDL_KEYDOWN) {
// cambiar a pantalla completa
if(event.key.keysym.sym==SDLK_f) SDL_WM_ToggleFullScreen(screen);
// salir del juego
else if(event.key.keysym.sym==SDLK_ESCAPE) salir = 1;
// cambiar arma primaria
else if(event.key.keysym.sym>=48&&event.key.keysym.sym<=57) player_change_weapon(&pj, event.key.keysym.sym-48, 1);
}
// si se mueve el mouse
else if(event.type==SDL_MOUSEMOTION) {
// guardar coordenadas del mouse
mouse_x = event.motion.x;
mouse_y = event.motion.y;
}
// si se presiona el mouse
else if(event.type == SDL_MOUSEBUTTONDOWN ) {
// guardar coordenadas del mouse
mouse_x = event.button.x;
mouse_y = event.button.y;
// resetear flag de armas disparadas
pj->primary->fired = 0;
pj->secondary->fired = 0;
// si se presiono el boton izquierdo
if(event.button.button==SDL_BUTTON_LEFT && pj->primary->ammo) {
Mix_PlayChannel(-1, pj->primary->sound, 0);
pj->primary->fired = pj->primary->ammo--;
}
// si se presiono el boton derecho
else if(event.button.button==SDL_BUTTON_RIGHT && pj->secondary->ammo) {
Mix_PlayChannel(-1, pj->secondary->sound, 0);
pj->secondary->fired = pj->secondary->ammo--;
}
// si se mueve el scroll se cambia el arma principal
else if (event.button.button==SDL_BUTTON_WHEELUP) {
player_change_weapon(&pj, WEAPON_PREV, 1);
}
else if (event.button.button==SDL_BUTTON_WHEELDOWN) {
player_change_weapon(&pj, WEAPON_NEXT, 1);
}
// determinar si personaje fue herido
if(mouse_x >= pj->x && mouse_x <= pj->x+SPRITE_SIZE && mouse_y >= pj->y && mouse_y <= pj->y+SPRITE_SIZE) {
// hacer daño al personaje
if(event.button.button==SDL_BUTTON_LEFT && pj->primary->fired) {
pj->health -= pj->primary->damage;
// reproducir sonido de dolor
Mix_PlayChannel(-1, pj->sounds[PLAYER_SOUND_DAMAGED], 0);
}
else if(event.button.button==SDL_BUTTON_RIGHT && pj->secondary->fired) {
pj->health -= pj->secondary->damage;
// reproducir sonido de dolor
Mix_PlayChannel(-1, pj->sounds[PLAYER_SOUND_DAMAGED], 0);
}
// si la salud quedo menor o igual a 0 el personaje muere
if(pj->health<1) {
// incrementar contador de muerte
++pj->dead;
pj->health = conf->PLAYER_HEALTH;
// descontar vida
if(conf->PLAYER_LIFE!=0) {
--pj->life;
if(pj->life==0) {
// GAME OVER
}
}
// reposicionar personaje muerto
player_set_position(&pj, map, -1, -1, mapobjects);
}
}
}
// si se suelta el mouse
else if(event.type==SDL_MOUSEBUTTONUP) {
// guardar coordenadas del mouse
mouse_x = event.button.x;
mouse_y = event.button.y;
// si se solto el boton izquierdo
if(event.button.button==SDL_BUTTON_LEFT) {
}
// si se solto el boton derecho
else if(event.button.button==SDL_BUTTON_RIGHT) {
}
}
}
// mover jugador
player_move(&pj, keystates, map, mapobjects, conf, SDL_GetTicks()-ticks);
player_get_object(&pj, map, conf);
// primera linea informacion
sprintf(info1, "time: %02d:%02d, mouse: (%04d,%04d)", time/60, time%60, mouse_x, mouse_y);
SDL_Surface *s_info1 = TTF_RenderText_Blended(fuente, info1, (SDL_Color) {255,255,255,255});
SDL_Rect rect = (SDL_Rect) { 10, 0, 100, 20 };
SDL_BlitSurface(s_info1, NULL, screen, &rect);
SDL_FreeSurface(s_info1);
// segunda linea informacion
sprintf(info2, "[%s] +%03d, life: %02d, dead: %02d, weapon: [%d/%03d/%03d] [%d/%03d/%03d]", conf->PLAYER_NAME, pj->health, pj->life, pj->dead, pj->primary->id, pj->primary->damage, pj->primary->ammo, pj->secondary->id, pj->secondary->damage, pj->secondary->ammo);
SDL_Surface *s_info2 = TTF_RenderText_Blended(fuente, info2, (SDL_Color) {255,255,255,255});
rect.y += 12;
SDL_BlitSurface(s_info2, NULL, screen, &rect);
SDL_FreeSurface(s_info2);
// dibujar enemigos
enemies_draw(screen, enemies);
// dibujar bots
/*for(i=0; i<conf->BOTS; ++i) {
Player *aux = &bots[i];
SDL_BlitSurface(aux->images[PLAYER_IMAGE_SPRITE], &aux->src, screen, &aux->sprite);
}*/
// dibujar jugador
SDL_BlitSurface(pj->images[PLAYER_IMAGE_SPRITE], &pj->src, screen, &pj->sprite);
// actualizar screen sdl
SDL_Flip(screen);
SDL_Delay(1000/FPS);
// resetear ticks
ticks = SDL_GetTicks();
}
// cerrar conexion al servidor
close(connection);
// liberar jugador
player_free(&pj);
// liberar armas
weapons_free(&weapons);
// libear objetos del mapa
mapobjects_free(&mapobjects);
// cerrar fuentes
TTF_CloseFont(fuente);
TTF_Quit();
// cerrar SDL
SDL_FreeSurface(screen);
SDL_Quit();
// retorno del sistema
return EXIT_SUCCESS;
}
