void manage_clients(int server_socket, client_data * * client_list) { int i, room_number = 0; struct pollfd open_room[max_users + 1]; // create poll field for each client for (i = 0; i < max_users; i += 1) { open_room[i].fd = 0; open_room[i].events = 0; open_room[i].revents = 0; } //create poll field for server open_room[max_users].fd = server_socket; open_room[max_users].events = POLLRDNORM; open_room[max_users].revents = 0; while (1) { // indicates wait 200ms between calls to poll int p = poll(open_room, max_users + 1, 200); if (p < 0) { perror("poll error"); usleep(100000); continue; } if (open_room[max_users].revents && POLLRDNORM) { int room_socket = accept_client_connection(server_socket); if (room_number < max_users) { open_room[room_number].fd = room_socket; open_room[room_number].events = POLLRDNORM || POLLERR; open_room[room_number].revents = 0; print_online_users(room_socket, client_list); get_user_initials(room_socket, room_number, client_list); room_number += 1; } } for (i = 0; i < max_users; i += 1) { if (open_room[i].revents && POLLRDNORM) { printf("\nreceived data from %d\n", i); int s = send_outgoing_message(open_room[i].fd, i, client_list); if (!s) { print_user_logout(open_room[i].fd, i, client_list); close(open_room[i].fd); open_room[i].fd = 0; open_room[i].events = 0; open_room[i].revents = 0; client_list[i]->room_socket = 0; } } } } }
int main (int n_args, char ** args) { cout << "******* Image storage server *******" << endl << endl; if (!check_server_arguments (n_args, args)) { cerr << "#SERVER > ERROR - Invalid argument" << endl; exit(-1); } if (!socket_initialization_server (&listen_socket, SP_port, (int) BACKLOG_QUEUE)) { cerr << "#SERVER > ERROR - Can't create a listen socket correctly" << endl; exit(-1); } // Registering services store_image = new Store_image ("store_image", SP_address, SP_port); get_image = new Get_image ("get_image", SP_address, SP_port); get_list = new Get_list ("get_list", SP_address, SP_port); cout << "#SERVER > Registering image_storage server" << endl; if (!register_service_provider (SP_address, SP_port)) cerr << "#SERVER > " << SPACER << "ERROR - Can't register the server" << endl; else { cout << "#SERVER > Registering store_image service" << endl; if (!register_service (store_image->get_description())) cerr << "#SERVER > " << SPACER << "ERROR - Can't register the store_image service" << endl; cout << "#SERVER > Registering get_image service" << endl; if (!register_service (get_image->get_description())) cerr << "#SERVER > " << SPACER << "ERROR - Can't register the get_image service" << endl; cout << "#SERVER > Registering get_list service" << endl; if (!register_service (get_list->get_description())) cerr << "#SERVER > " << SPACER << "ERROR - Can't register the get_list service" << endl; } // Initializing mutex pthread_mutex_init (&mutex_1, NULL); pthread_mutex_init (&mutex_2, NULL); pthread_mutex_init (&mutex_thread_free, NULL); pthread_cond_init (&cond_thread_free, NULL); readers_count = 0; // Creating threads pthread_t thread_ID; for (int i = 0; i < N_THREADS; i++) { if (pthread_create(&thread_ID, NULL, thread_body, (void*) i) != 0) { cerr << "#SERVER > ERROR - Can't create a service thread" << endl; exit(-1); } thread[i].set_ID (thread_ID); } if (pthread_create(&thread_ID, NULL, control_thread_body, NULL) != 0) { cerr << "#SERVER > ERROR - Can't create the control thread" << endl; exit(-1); } control_thread.set_ID (thread_ID); cout << "\n#SERVER > Waiting for connections" << endl; while (control_thread.is_active()) { int client_socket = accept_client_connection (listen_socket); if (client_socket == -1) { if (control_thread.is_active()) cerr << "#SERVER > ERROR - Can't accept the connection with the client" << endl; continue; } while (!assign_execution_thread (client_socket)) pthread_cond_wait (&cond_thread_free, &mutex_thread_free); } // Closing sockets and threads for (int i = 0; i < N_THREADS; i++) { thread[i].thread_exit(); pthread_join(thread[i].get_ID(), NULL); } pthread_join(control_thread.get_ID(), NULL); shutdown(listen_socket, SHUT_RDWR); close(listen_socket); // Unregistering services - Only unregister_service_provider is needed cout << "#SERVER > Unregistering store_image service" << endl; if (!unregister_service (store_image->get_description())) cerr << "#SERVER > " << SPACER << "ERROR - Can't unregister the store_image service" << endl; delete (store_image); cout << "#SERVER > Unregistering get_image service" << endl; if (!unregister_service (get_image->get_description())) cerr << "#SERVER > " << SPACER << "ERROR - Can't unregister the get_image service" << endl; delete (get_image); cout << "#SERVER > Unregistering get_list service" << endl; if (!unregister_service (get_list->get_description())) cerr << "#SERVER > " << SPACER << "ERROR - Can't unregister the get_list service" << endl; delete (get_list); cout << "#SERVER > Unregistering image_storage server" << endl; if (!unregister_service_provider (SP_address, SP_port)) cerr << "#SERVER > " << SPACER << "ERROR - Can't unregister the server" << endl; cout << endl << "#SERVER > Server closed" << endl; cout << endl << "***********************" << endl; exit(0); }
static void *acceptor_thread_main(void *p) { while (true) accept_client_connection(); return NULL; }
main () { int port; std::vector<Sat*> sat_tracking; /********************************************************************************/ /************************************** PIPE ***********************************/ /********************************************************************************/ int ttt; //PIPE char *pipe = "/tmp/satObPIPE"; mkfifo(pipe,0666); /********************************************************************************/ /********************************** SEMAPHORE CAPTURE **************************/ /********************************************************************************/ key_t key = ftok ("/bin/ls", 1990); if (key == (key_t)-1){ std::cout << "Fatal error in shared memory. Can not create key.\n"; return -1; } int sem_id = semget (key,1,0600 | IPC_CREAT); if (sem_id == -1){ std::cout << "Fatal error in shared memory. Can not create/open semaphore.\n"; return -1; } semctl(sem_id,0,SETVAL,1); /********************************************************************************/ /********************************** SEMAPHORE FREQUENCY ************************/ /********************************************************************************/ key_t keyf = ftok ("/bin/ls", 1995); if (keyf == (key_t)-1) { std::cout << "Fatal error in shared memory. Can not create key.\n"; return -1; } int sem_idf = semget (keyf,1,0600 | IPC_CREAT); if (sem_idf == -1) { std::cout << "Fatal error in shared memory. Can not create/open semaphore.\n"; return -1; } semctl(sem_idf,0,SETVAL,1); /********************************************************************************/ /********************************** SHARED MEMORY ******************************/ /********************************************************************************/ key_t memory_key = ftok ("/bin/ls", 1968); if (memory_key == -1) { std::cout << "Fatal error in shared memory. Can not create key.\n"; return -1; } int memory_id = shmget (memory_key, sizeof(int), 0777 | IPC_CREAT); if (memory_id == -1) { std::cout << "Fatal error in shared memory. Can not create shared memory.\n"; return -1; } int* memory = (int *)shmat(memory_id, (char *)0, 0); if (memory == NULL) { std::cout << "Fatal error in shared memory. Can not create shared memory.\n"; return -1; } *memory=0; /********************************************************************************/ /********************************** CONFIGURATION ******************************/ /********************************************************************************/ char result[PATH_MAX]; ssize_t count = readlink( "/proc/self/exe", result, PATH_MAX ); std::string path( result, (count > 0) ? count : 0 ); path=path.substr(0,path.length()-7); path.insert(path.length(),"/default.ini"); boost::property_tree::ptree conf; boost::property_tree::ini_parser::read_ini(path, conf); port=std::atoi(conf.get<std::string>("CONNECTION.Port").c_str()); /********************************************************************************/ /********************************** CONNECTION *********************************/ /********************************************************************************/ int socket_server; int socket_client; socket_server = open_inet_socket(port); if (socket_server == -1) { printf ("Can not open server socket.\n"); exit (-1); } /********************************************************************************/ /********************************** SATELLITES RECEPTION ***********************/ /********************************************************************************/ while(true){ std::string satellite_number; std::string frequency; char str; time_t timer; socket_client = accept_client_connection (socket_server); if (socket_server == -1) { printf ("Can not open client socket.\n"); exit (-1); } for(int i=1;i>0;++i){ read_socket (socket_client, &str, 1); if(str=='|'){ i=-1; } else{ satellite_number=satellite_number.insert(satellite_number.size(),1,str); } } for(int i=1;i>0;++i){ read_socket (socket_client, &str, 1); if(str=='&'){ i=-1; } else{ frequency=frequency.insert(frequency.size(),1,str); } } close (socket_client); /********************************************************************************/ /********************************** SAVE SATELLITES TRACKED ********************/ /********************************************************************************/ bool exist_sat=false; //If satellite is having tracking only change (or not) the frequency and date for(int i = 0; (i< sat_tracking.size()) && (exist_sat==false); i++) { if(std::atoi(satellite_number.c_str())==sat_tracking[i]->satellite_number ){ exist_sat=true; } } if(exist_sat==false){ Sat* p_sat=new Sat(); p_sat->satellite_number=std::atoi(satellite_number.c_str()); p_sat->frequency=std::atof(frequency.c_str()); std::time(&timer); p_sat->time=timer; /********************************************************************************/ /********************************** SAT-OBSERVER INSTANCE **********************/ /********************************************************************************/ //Create a sat-observer instance. int child = fork(); switch(child){ case -1: std::cout << "Error: Can not create sat-observer instance.\n"; break; //Child process: sat-observer case 0: char result[PATH_MAX]; ssize_t count = readlink( "/proc/self/exe", result, PATH_MAX ); std::string path( result, (count > 0) ? count : 0 ); path=path.substr(0,path.length()-6); path.insert(path.length(),"sat-observer "); path.insert(path.length(),satellite_number); path.insert(path.length()," "); path.insert(path.length(),frequency); system(path.c_str()); break; } p_sat->proccess_id=child; sat_tracking.push_back(p_sat); } for(int i = 0; i < sat_tracking.size(); i++) { char* dt = ctime(&(sat_tracking[i]->time)); std::cout << "Satellite number: " << sat_tracking[i]->satellite_number << " || Frequency: " << sat_tracking[i]->frequency << " || " << dt << "\n"; } std::cout << "\n\n\n"; } close (socket_client); close (socket_server); }