//***************************************************************************************************************
int main(int argc, char **argv) {
int loop = 0;
int command =0;
fd = open(PORT, O_RDWR | O_NOCTTY | O_NDELAY);
if (fd == -1) {
perror("open_port: Unable to open PORT - "); //opps something bad happened...
return 1;
} else {
fcntl(fd, F_SETFL, 0);
}
initport(fd);
//check to see if commandline arguments are present
if (argc >= 2)
{
for (loop =1; loop < argc; loop++)
{
if ((command = parse_input(argv[loop] )) >=0 )
send_command( command );
usleep(1000000/4);
}
printf("\n");
return 0; //exit
}
show_commands();
return 0;
}
int interface_help(const char *pProgram)
{
fprintf(stderr, "%s: command help\n", pProgram);
fprintf(stderr, "\n");
fprintf(stderr, "CALLING METHODS\n");
fprintf(stderr, "%s = show active daemons\n", pProgram);
fprintf(stderr, "%s -h = show help\n", pProgram);
fprintf(stderr, "%s -d(gxr) ([max pri]:[max perm]) = run as rservr client\n", pProgram);
fprintf(stderr, " (g = group-accessible, x = kill server on exit, r = await registration)\n");
fprintf(stderr, "%s [server] = see if you have access to a daemon\n", pProgram);
fprintf(stderr, "%s [server] ([command]...) = execute a command on an rservr system\n", pProgram);
fprintf(stderr, "\n");
return show_commands();
}
void redis_commands::init(const char* cmds_file)
{
set_commands();
if (cmds_file && *cmds_file)
{
acl::ifstream in;
if (in.open_read(cmds_file) == false)
{
logger_error("load file %s error: %s",
cmds_file, acl::last_serror());
return;
}
load_commands(in);
}
show_commands();
}
void commands(char *name) {
char select[64];
int option;
while(1) {
show_commands();
fgets(select, 64, stdin);
option = atoi(select);
switch(option){
case 1:
get_address(name); // print the buffer base address
break;
case 2:
printf("The flag located at /opt/flag \n");
break;
case 3:
return;
default:
break;
}
}
}
int main(int argc, char* argv[]){
//variabili
fd_set read_temp_set;
fd_set write_temp_set;
int error;
int max_fd_set;
timeout.tv_sec=60;
timeout.tv_usec=0;
char port[6];
char command [30];
int right=0;
int max_try=3;
// fase iniziale : connessione al server
if(argc!=3){
printf("Errore nell'inserimento dei parametri, chiusura in corso...\n");
exit(1);
}
printf("Connessione in corso al server (indirizzo di ascolto %s, porta di ascolto %s)\n",argv[1],argv[2]);
tcp_socket=socket(AF_INET,SOCK_STREAM,0);
if(tcp_socket==-1){
perror("Errore creazione socket tcp");
exit(1);
}
udp_socket=socket(AF_INET,SOCK_DGRAM,0);
if(udp_socket==-1){
perror("Errore creazione socket udp");
close(tcp_socket);
exit(1);
}
max_fd_set=(tcp_socket>udp_socket)?tcp_socket:udp_socket;
memset(&server,0, sizeof(server));
memset(&client,0, sizeof(client));
memset(&enemy, 0, sizeof(enemy));
memset(&work, 0, sizeof(work));
enemy.sin_family=AF_INET;
work.sin_family=AF_INET;
client.sin_family=AF_INET;
server.sin_family=AF_INET;
// per il server
server.sin_port=htons(atoi(argv[2]));
inet_pton(AF_INET, argv[1], &server.sin_addr.s_addr);
error=connect(tcp_socket,(struct sockaddr*)&server,addrlen);
if(error==-1){
perror("Impossibile connettersi al server");
close(tcp_socket);
close(udp_socket);
exit(1);
}
printf("Connessione con il server %s sulla porta %s avvenuta con successo.\n", argv[1], argv[2]);
// segue l'inserimento del nome e della porta di ascolto udp
error=record_name(client_name);
while(error==-1){
if(max_try!=0){
printf("Riproviamo...\n");
error=record_name(client_name);
max_try--;
}
else if(max_try==0){
printf("Problemi nell'inserimento del nome.Disconnessione...\n");
close(tcp_socket);
close(udp_socket);
exit(1);
}
}
do{
printf("Per favore inserisci il numero di porta udp per il gioco:\n");
fgets(port,6,stdin);
if(port[strlen(port)-1]!='\n')
fflush(stdin);
udp_port=atoi(port);
if(udp_port<1024 || udp_port>=65535)
printf("Porta upd inserita non valida...\n");
else right=1;
}while(right==0);
udp_port=htons(udp_port);
error=record_udp_port(udp_port);
if(error==-1){
printf("Problemi nell'inserimento della porta udp.Disconnessione...\n");
close(tcp_socket);
close(udp_socket);
exit(1);
}
// bind() per socket udp
client.sin_port=udp_port;
client.sin_addr.s_addr = INADDR_ANY; // usa il mio indirizzo IP
error=bind(udp_socket, (struct sockaddr*)&client, addrlen);
if(error==-1){
perror("Errore nella bind della socket udp in ricezione(porta occupata)");
printf("Server in chiusura...\n");
close(tcp_socket);
close(udp_socket);
exit(1);
}
else
printf("Porta udp registrata correttamente presso il server.\n");
// il client deve inserire le varie navi
set_match();
show_commands();
// inizializzo i descrittori
FD_ZERO(&master_read_set);
FD_ZERO(&master_write_set);
FD_SET(0, &master_read_set);//stdin
FD_SET(tcp_socket, &master_read_set);
FD_SET(udp_socket, &master_read_set);
// comincia il corpo del client
do{
read_temp_set=master_read_set;
write_temp_set=master_write_set;
if(shell==0){
if(started_match==0)
printf(">");
else
printf("#");
shell=1;
}
fflush(stdout);
error=select(max_fd_set+1, &read_temp_set, &write_temp_set, NULL, &timeout);
if(error==-1){
perror("Errore nella select");
close(tcp_socket);
close(udp_socket);
exit(1);
}
else if((error==0) && (started_match!=0)){ // non e' successo niente per 60s durante una partita
printf("Inattivita' durante una partita.\n");
printf("Chiudo la partita con %s. \n",enemy_name);
busy=0;
started_match=0;
tcp_senddim=4;
tcp_message=malloc(4);
*(int*)tcp_message=4;
udp_message[0]=7;//TIPO messaggio
FD_SET(tcp_socket, &master_write_set);
FD_SET(udp_socket, &master_write_set);
FD_CLR(tcp_socket, &master_read_set);
}
// altrimenti controlliamo i socket in lettura
if(FD_ISSET(0, &read_temp_set)){
// leggo un comando da tastiera
shell = 0;
fgets(command,30, stdin);
if(command[strlen(command)-1]!='\n') fflush(stdin);
else command[strlen(command)-1]='\0';
manage_stdin_command(command);
}
if(FD_ISSET(tcp_socket, &read_temp_set)){
if(tcp_recv1==1){
msg_buffer=malloc(INTEGER);
error=recv(tcp_socket,msg_buffer,INTEGER,0);
if(error==0){
printf("Il server ha chiuso la connessione");
close_conn=1;
break;
}
if(error==-1 || error<INTEGER){
perror("Errore nella recive");
close_conn=1;
break;
}
tcp_recvdim=*(int*)msg_buffer;
free(msg_buffer);
tcp_recv1=0;
}
else{
msg_buffer=malloc(tcp_recvdim);
error=recv(tcp_socket,msg_buffer,tcp_recvdim,0);
if(error==0){
printf("Il server ha chiuso la connessione");
close_conn=1;
break;
}
if(error==-1 || error<tcp_recvdim){
perror("Errore nella recive");
close_conn=1;
break;
}
error=manage_tcp_command(msg_buffer);
free(msg_buffer);
if(error==-1){
printf("Errore nella recive");
close_conn=1;
break;
}
tcp_recv1=1;
shell=0;
}
}
if(FD_ISSET(udp_socket, &read_temp_set)){
msg_buffer=malloc(12);
error=recvfrom(udp_socket,msg_buffer,12,0,(struct sockaddr*)&work,&addrlen);
if(error==-1){
perror("Errore nella recvfrom");
close_conn=1;
break;
}
if((busy==1) && work.sin_addr.s_addr==enemy.sin_addr.s_addr){
shell=0;
error=manage_udp_command((int*)msg_buffer);
if(error==-1){
printf("Errore nella gestione del comando ricevuto dall'altro giocatore.\n");
close_conn=1;
break;
}
free(msg_buffer); /***************************************************************/
}
// altrimenti ho ricevuto un pacchetto da qualcun'altro
}
// controlliamo i socket in scrittura
if(FD_ISSET(tcp_socket,&write_temp_set)){
if(tcp_send1==1){
msg_buffer=malloc(INTEGER);
*(int*)msg_buffer=tcp_senddim;
error=send(tcp_socket,msg_buffer,INTEGER,0);
if(error==-1){
perror("Errore nella send");
close_conn=1;
break;
}
free(msg_buffer);
tcp_send1=0;
}
else{
error=send(tcp_socket,tcp_message,tcp_senddim,0);
if(error==-1){
perror("Errore nella send");
close_conn=1;
break;
}
if(*(int*)tcp_message==5)
close_conn=1;
free(tcp_message);
tcp_send1=1;
FD_CLR(tcp_socket, &master_write_set);
FD_SET(tcp_socket, &master_read_set);
}
}
if(FD_ISSET(udp_socket,&write_temp_set)){
error=sendto(udp_socket,(void*)&udp_message,12,0,(struct sockaddr*)&enemy,addrlen);
if(error==-1){
perror("Errore nella sendto");
close_conn=1;
break;
}
FD_CLR(udp_socket, &master_write_set);
}
}while(close_conn==0);
close(tcp_socket);
close(udp_socket);
printf("\nBye bye!\n");
return 0;
}
void
do_play_ascii(Gameinfo *gameinfo)
{
int m, num;
float fnum;
int passes = 0; /* two passes and its over */
int tmp;
char line[80];
char *line_ptr = line;
char *command;
char *tmpstring;
int state = 1;
if (have_time_settings())
clock_on = 1;
while (state == 1) {
state = 0;
/* No score is estimated yet. */
current_score_estimate = NO_SCORE;
/* Allow resignation at interface level (the engine may still be not
* allowed to resign.
*/
resignation_allowed = 1;
printf("\nBeginning ASCII mode game.\n\n");
gameinfo_print(gameinfo);
/* Does the computer play first? If so, make a move. */
if (gameinfo->computer_player == gameinfo->to_move)
state = computer_move(gameinfo, &passes);
/* main ASCII Play loop */
while (state == 0) {
/* Display game board. */
if (opt_showboard)
ascii_showboard();
#if !READLINE
/* Print the prompt */
mprintf("%s(%d): ", color_to_string(gameinfo->to_move), movenum + 1);
/* Read a line of input. */
line_ptr = line;
if (!fgets(line, 80, stdin))
return;
#else
snprintf(line, 79, "%s(%d): ",
color_to_string(gameinfo->to_move), movenum + 1);
if (!(line_ptr = readline(line)))
return;
add_history(line_ptr);
#endif
while (state == 0
&& (command = strtok(line_ptr, ";"), line_ptr = 0, command)) {
/* Get the command or move. */
switch (get_command(command)) {
case RESIGN:
state = ascii_endgame(gameinfo, 1);
break;
case END:
case EXIT:
case QUIT:
return;
case HELP:
show_commands();
break;
case CMD_HELPDEBUG:
printf(DEBUG_COMMANDS);
break;
case SHOWBOARD:
opt_showboard = !opt_showboard;
break;
case INFO:
printf("\n");
gameinfo_print(gameinfo);
break;
case SETBOARDSIZE:
if (sgf_initialized) {
printf("Boardsize cannot be changed after record is started!\n");
break;
}
command += 10;
if (sscanf(command, "%d", &num) != 1) {
printf("\nInvalid command syntax!\n");
break;
}
if (!check_boardsize(num, stdout))
break;
/* Init board. */
board_size = num;
clear_board();
/* In case max handicap changes on smaller board. */
gameinfo->handicap = place_fixed_handicap(gameinfo->handicap);
sgfOverwritePropertyInt(sgftree.root, "SZ", board_size);
sgfOverwritePropertyInt(sgftree.root, "HA", gameinfo->handicap);
break;
case SETHANDICAP:
if (sgf_initialized) {
printf("Handicap cannot be changed after game is started!\n");
break;
}
command += 9;
if (sscanf(command, "%d", &num) != 1) {
printf("\nInvalid command syntax!\n");
break;
}
if (num < 0 || num > MAX_HANDICAP) {
printf("\nInvalid handicap: %d\n", num);
break;
}
/* Init board. */
clear_board();
/* Place stones on board but don't record sgf
* in case we change more info. */
gameinfo->handicap = place_fixed_handicap(num);
printf("\nSet handicap to %d\n", gameinfo->handicap);
gameinfo->to_move = (gameinfo->handicap ? WHITE : BLACK);
break;
case FREEHANDICAP:
if (sgf_initialized) {
printf("Handicap cannot be changed after game is started!\n");
break;
}
while (*command && *command != ' ')
command++;
ascii_free_handicap(gameinfo, command);
break;
case SETKOMI:
if (sgf_initialized) {
printf("Komi cannot be modified after game record is started!\n");
break;
}
command += 5;
if (sscanf(command, "%f", &fnum) != 1) {
printf("\nInvalid command syntax!\n");
break;
}
komi = fnum;
printf("\nSet Komi to %.1f\n", komi);
break;
case SETDEPTH:
command += 6;
if (sscanf(command, "%d", &num) != 1) {
printf("\nInvalid command syntax!\n");
break;
}
mandated_depth = num;
printf("\nSet depth to %d\n", mandated_depth);
break;
case SETLEVEL:
command += 6;
if (sscanf(command, "%d", &num) != 1) {
printf("\nInvalid command syntax!\n");
break;
}
set_level(num);
printf("\nSet level to %d\n", num);
break;
case DISPLAY:
if (!opt_showboard)
ascii_showboard();
break;
case FORCE:
command += 6; /* skip the force part... */
switch (get_command(command)) {
case MOVE:
state = do_move(gameinfo, command, &passes, 1);
break;
case PASS:
state = do_pass(gameinfo, &passes, 1);
break;
default:
printf("Illegal forced move: %s %d\n", command,
get_command(command));
break;
}
break;
case MOVE:
state = do_move(gameinfo, command, &passes, 0);
break;
case PASS:
state = do_pass(gameinfo, &passes, 0);
break;
case PLAY:
command += 5;
if (sscanf(command, "%d", &num) != 1) {
printf("\nInvalid command syntax!\n");
break;
}
if (num >= 0)
for (m = 0; m < num; m++) {
gameinfo->computer_player
= OTHER_COLOR(gameinfo->computer_player);
state = computer_move(gameinfo, &passes);
if (state)
break;
if (passes >= 2)
break;
}
else {
printf("\nInvalid number of moves specified: %d\n", num);
break;
}
break;
case PLAYBLACK:
if (gameinfo->computer_player == WHITE)
gameinfo->computer_player = BLACK;
if (gameinfo->computer_player == gameinfo->to_move)
state = computer_move(gameinfo, &passes);
break;
case PLAYWHITE:
if (gameinfo->computer_player == BLACK)
gameinfo->computer_player = WHITE;
if (gameinfo->computer_player == gameinfo->to_move)
state = computer_move(gameinfo, &passes);
break;
case SWITCH:
gameinfo->computer_player = OTHER_COLOR(gameinfo->computer_player);
state = computer_move(gameinfo, &passes);
break;
case UNDO:
case CMD_BACK:
if (undo_move(1)) {
sgftreeAddComment(&sgftree, "undone");
sgftreeBack(&sgftree);
gameinfo->to_move = OTHER_COLOR(gameinfo->to_move);
}
else
printf("\nCan't undo.\n");
break;
case CMD_FORWARD:
if (sgftreeForward(&sgftree))
gameinfo->to_move = gnugo_play_sgfnode(sgftree.lastnode,
gameinfo->to_move);
else
printf("\nEnd of game tree.\n");
break;
case CMD_LAST:
while (sgftreeForward(&sgftree))
gameinfo->to_move = gnugo_play_sgfnode(sgftree.lastnode,
gameinfo->to_move);
break;
case COMMENT:
printf("\nEnter comment. Press ENTER when ready.\n");
fgets(line, 80, stdin);
sgftreeAddComment(&sgftree, line);
break;
case SCORE:
showscore = !showscore;
if (!showscore)
current_score_estimate = NO_SCORE;
break;
case CMD_DEAD:
silent_examine_position(FULL_EXAMINE_DRAGONS);
showdead = !showdead;
break;
case CMD_CAPTURE:
strtok(command, " ");
showcapture(strtok(NULL, " "));
break;
case CMD_DEFEND:
strtok(command, " ");
showdefense(strtok(NULL, " "));
break;
case CMD_SHOWMOYO:
tmp = printmoyo;
printmoyo = PRINTMOYO_MOYO;
silent_examine_position(EXAMINE_DRAGONS);
printmoyo = tmp;
break;
case CMD_SHOWTERRI:
tmp = printmoyo;
printmoyo = PRINTMOYO_TERRITORY;
silent_examine_position(EXAMINE_DRAGONS);
printmoyo = tmp;
break;
case CMD_SHOWAREA:
tmp = printmoyo;
printmoyo = PRINTMOYO_AREA;
silent_examine_position(EXAMINE_DRAGONS);
printmoyo = tmp;
break;
case CMD_SHOWDRAGONS:
silent_examine_position(EXAMINE_DRAGONS);
showboard(1);
break;
case CMD_GOTO:
strtok(command, " ");
ascii_goto(gameinfo, strtok(NULL, " "));
break;
case CMD_SAVE:
strtok(command, " ");
tmpstring = strtok(NULL, " ");
if (tmpstring) {
/* discard newline */
tmpstring[strlen(tmpstring) - 1] = 0;
/* make sure we are saving proper handicap */
init_sgf(gameinfo);
writesgf(sgftree.root, tmpstring);
printf("You may resume the game");
printf(" with -l %s --mode ascii\n", tmpstring);
printf("or load %s\n", tmpstring);
}
else
printf("Please specify filename\n");
break;
case CMD_LOAD:
strtok(command, " ");
tmpstring = strtok(NULL, " ");
if (tmpstring) {
/* discard newline */
tmpstring[strlen(tmpstring) - 1] = 0;
if (!sgftree_readfile(&sgftree, tmpstring)) {
fprintf(stderr, "Cannot open or parse '%s'\n", tmpstring);
break;
}
/* to avoid changing handicap etc. */
if (gameinfo_play_sgftree(gameinfo, &sgftree, NULL) == EMPTY)
fprintf(stderr, "Cannot load '%s'\n", tmpstring);
else {
sgf_initialized = 1;
sgfOverwritePropertyInt(sgftree.root, "HA", gameinfo->handicap);
}
}
else
printf("Please specify a filename\n");
break;
case CMD_LISTDRAGONS:
silent_examine_position(EXAMINE_DRAGONS);
show_dragons();
break;
default:
printf("\nInvalid command: %s", command);
break;
}
if (passes >= 2)
state = ascii_endgame(gameinfo, 0);
}
#if READLINE
free(line_ptr);
#endif
}
sgffile_output(&sgftree);
passes = 0;
/* Play a different game next time. */
update_random_seed();
/* Free the sgf tree and prepare for a new game. */
sgfFreeNode(sgftree.root);
sgftree_clear(&sgftree);
sgftreeCreateHeaderNode(&sgftree, board_size, komi, gameinfo->handicap);
sgf_initialized = 0;
gameinfo_clear(gameinfo);
}
}
