Exemplo n.º 1
0
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);
}
Exemplo n.º 3
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);
}