Ejemplo n.º 1
0
int testKeys() {
	int result, size, num_keys, num_keys_conv;
	short opcode, c_type;
	char *msg_str = NULL;
	struct message_t *msg;
	char *keys[] = {"ul2015", "SD", "teste", "123", NULL};
	short sizes_conv[] = {htons(6), htons(2), htons(5), htons(3)};

	printf("Módulo mensagem -> teste - Keys:");

	msg = (struct message_t *) malloc(sizeof(struct message_t));
	msg->opcode = OC_PUT;
	msg->c_type = CT_KEYS;
	msg->content.keys = (char **) malloc(5 * sizeof(char *));
	msg->content.keys[0] = strdup("ul2015");
	msg->content.keys[1] = strdup("SD");
	msg->content.keys[2] = strdup("teste");
	msg->content.keys[3] = strdup("123");
	msg->content.keys[4] = NULL;

	size = message_to_buffer(msg, &msg_str);

	opcode = htons(msg->opcode);
	c_type = htons(msg->c_type);
	num_keys = 4;
	num_keys_conv = htonl(num_keys);

	result = memcmp(msg_str, &opcode, 2) == 0 &&
	  	 memcmp(msg_str + 2, &c_type, 2) == 0 &&
	 	 memcmp(msg_str + 4, &num_keys_conv, 4) == 0 &&
		 memcmp(msg_str + 8, &sizes_conv[0], 2) == 0 &&
		 memcmp(msg_str + 10, keys[0], strlen(keys[0])) == 0 &&
		 memcmp(msg_str + 16, &sizes_conv[1], 2) == 0 &&
		 memcmp(msg_str + 18, keys[1], strlen(keys[1])) == 0 &&
		 memcmp(msg_str + 20, &sizes_conv[2], 2) == 0 &&
		 memcmp(msg_str + 22, keys[2], strlen(keys[2])) == 0 &&
		 memcmp(msg_str + 27, &sizes_conv[3], 2) == 0 &&
		 memcmp(msg_str + 29, keys[3], strlen(keys[3])) == 0;

	free_message(msg);

	msg = buffer_to_message(msg_str, size);

	result = result && msg->opcode == OC_PUT &&
			   msg->c_type == CT_KEYS &&
			   strcmp(msg->content.keys[0], keys[0]) == 0 &&
			   strcmp(msg->content.keys[1], keys[1]) == 0 &&
			   strcmp(msg->content.keys[2], keys[2]) == 0 &&
			   strcmp(msg->content.keys[3], keys[3]) == 0 &&
			   msg->content.keys[4] == NULL;

	free(msg_str);
	//print_message(msg);
	free_message(msg);

	printf(" %s\n", result ? "passou" : "não passou");
	return result;
}
Ejemplo n.º 2
0
int testValue() {
	int result, size, datasize, datasize_conv;
	short opcode, c_type;
	char *msg_str = NULL;
	char *datastr;
	struct message_t *msg;

	printf("Módulo mensagem -> teste - Value:");

	msg = (struct message_t *) malloc(sizeof(struct message_t));
	msg->opcode = OC_PUT;
	msg->c_type = CT_VALUE;
	datastr = strdup("abc");
	msg->content.data = data_create2(strlen("abc") + 1, datastr);
	size = message_to_buffer(msg, &msg_str);

	opcode = htons(msg->opcode);
	c_type = htons(msg->c_type);
	datasize = msg->content.data->datasize;
	datasize_conv = htonl(datasize);

	char comp_data[datasize];

	memcpy(comp_data, msg_str + 8, datasize);
	result = memcmp(msg_str, &opcode, 2) == 0 &&
		 memcmp(msg_str + 2, &c_type, 2) == 0 &&
		 memcmp(msg_str + 4, &datasize_conv, 4) == 0 &&
		 memcmp(msg_str + 8, &comp_data, datasize) == 0;

	free_message(msg);

	msg = buffer_to_message(msg_str, size);

	result = result && msg->opcode == OC_PUT &&
			   msg->c_type == CT_VALUE &&
			   msg->content.data->datasize == strlen("abc")+1 &&
			   strcmp(msg->content.data->data,"abc") == 0;

	free(msg_str);
	free(datastr);
	//print_message(msg);
	free_message(msg);

	printf(" %s\n", result ? "passou" : "não passou");
	return result;
}
Ejemplo n.º 3
0
int testKey() {
	int result, size, keysize;
        short keysize_conv, opcode, c_type;
	char *msg_str = NULL;
	struct message_t *msg;

	printf("Modulo mensagem -> teste - Key:");

	msg = (struct message_t *)malloc(sizeof(struct message_t));
	msg->opcode = OC_PUT;
	msg->c_type = CT_KEY;
	msg->content.key = strdup("abcdef");
	size = message_to_buffer(msg,&msg_str);

	opcode = htons(msg->opcode);
	c_type = htons(msg->c_type);
	keysize = strlen(msg->content.key);
	keysize_conv = htons((short) keysize);

	char comp_key[keysize];

	memcpy(comp_key, msg_str + 6, keysize);
	result = memcmp(msg_str, &opcode, 2) == 0 &&
		 memcmp(msg_str + 2, &c_type, 2) == 0 &&
		 memcmp(msg_str + 4, &keysize_conv, 2) == 0 &&
		 memcmp(msg_str + 6, &comp_key, keysize) == 0;

	free_message(msg);

	msg = buffer_to_message(msg_str, size);

	result = result && msg->opcode == OC_PUT &&
			   msg->c_type == CT_KEY &&
			   strcmp(msg->content.key, "abcdef") == 0;

	free(msg_str);
	//print_message(msg);
	free_message(msg);

	printf(" %s\n", result ? "passou" : "não passou");
	return result;
}
Ejemplo n.º 4
0
/* Função para adicionar um par chave valor na tabela.
 * Devolve 0 (ok) ou -1 (problemas).
 */
int ptable_put(struct ptable_t *ptable, char *key, struct data_t *value)
{
	uint16_t result,size;
	result = -1;
	if(ptable->isOpen)
	{
		struct message_t *msg;
		char *msg_buffer, *buffer;
		result = table_put(ptable->table,key,value);
	 	if(result==0)
		{	
			msg = (struct message_t*) malloc(sizeof(struct message_t));
			msg->opcode = OC_PUT;
			msg->c_type = CT_ENTRY;
			msg->content.entry = entry_create(key,value);
			//
			size = message_to_buffer(msg,&msg_buffer);
			//Alocar memoria
			buffer = (char *) malloc(size+sizeof(uint16_t));
			if(buffer == NULL)
			{
				perror("Out of memory");
				return -1;
			}
			//Copiar o tamanho da mensagem
			memcpy(buffer,&size,sizeof(uint16_t));
			//Copiar a mensagem
			memcpy(buffer+sizeof(uint16_t),msg_buffer,size);
			//Escrever mensagem
			if(pmanager_log(ptable->pmanager,buffer)==-1)
			{
				printf("Falha na escrita\n");
			}
			//Free(s)
			free(buffer);
			free(msg_buffer);
			free_message(msg);
		}
	}
	return result;
}
Ejemplo n.º 5
0
/* Função para remover um par chave valor da tabela, especificado pela
 * chave key.
 * Devolve: 0 (OK) ou -1 em caso de erros
 */
int ptable_del(struct ptable_t *ptable, char *key)
{
    int result,size;
    result = -1;
	if(ptable->isOpen)
	{
		struct message_t *msg;
		char *msg_buffer,*pmanager_buffer;
		result = table_del(ptable->table,key);
	    if(result == 0)
		{	
			msg = (struct message_t*) malloc(sizeof(struct message_t));
			if(msg == NULL)
			{
				perror("Out of memory");
				return -1;
			}
			msg->opcode = OC_DEL;
			msg->c_type = CT_KEY;
			msg->content.key = strdup(key);
			size = message_to_buffer(msg,&msg_buffer);
			//Alocar memoria
			pmanager_buffer = (char *) malloc(size+sizeof(uint16_t));
			//Copiar o tamanho da mensagem
			memcpy(pmanager_buffer,&size,sizeof(uint16_t));
			//Copiar a mensagem
			memcpy(pmanager_buffer+sizeof(uint16_t),msg_buffer,size);
			//Escrever mensagem
			if(pmanager_log(ptable->pmanager,pmanager_buffer)==-1)
			{
				printf("Falha na escrita\n");
			}
			//Free
			free(pmanager_buffer);
			free_message(msg);
			free(msg_buffer);
		}
	}
	return result;
}
Ejemplo n.º 6
0
int testResult() {
	int result, size, res;
	short opcode, c_type;
	char *msg_str = NULL;
	struct message_t *msg;

	printf("Módulo mensagem -> teste - Result:");

	msg = (struct message_t *) malloc(sizeof(struct message_t));

	msg->opcode = OC_PUT;
	msg->c_type = CT_RESULT;
	msg->content.result = 1;
	size = message_to_buffer(msg, &msg_str);
	
	opcode = htons(msg->opcode);
	c_type = htons(msg->c_type);
	res = htonl(msg->content.result);
	result = memcmp(msg_str, &opcode, 2) == 0 &&
		 memcmp(msg_str + 2, &c_type, 2) == 0 && 
		 memcmp(msg_str + 4, &res, 4) == 0;

	free_message(msg);

	msg = buffer_to_message(msg_str, size);

	result = result && msg->opcode == OC_PUT &&
			   msg->c_type == CT_RESULT &&
			   msg->content.result == 1;

	free(msg_str);
	//print_message(msg);
	free_message(msg);

	printf(" %s\n", result ? "passou":"não passou");
	return result;
}
Ejemplo n.º 7
0
int testEntry() {
	int result, size, keysize, datasize, datasize_conv;
	short opcode, c_type, keysize_conv;
	char *msg_str = NULL;
	char *datastr = strdup("abc");
	struct message_t *msg;
	struct data_t *d;

	printf("Módulo mensagem -> teste - Entry");

	d = data_create2(strlen(datastr) + 1, datastr);

	msg = (struct message_t *) malloc(sizeof(struct message_t));
	msg->opcode = OC_PUT;
	msg->c_type = CT_ENTRY;
	msg->content.entry = entry_create(datastr, d);
	data_destroy(d);

	size = message_to_buffer(msg, &msg_str);

	opcode = htons(msg->opcode);
	c_type = htons(msg->c_type);
	keysize = strlen(msg->content.entry->key);
	keysize_conv = htons(keysize);

	char comp_key[keysize];

	memcpy(comp_key, msg_str + 6, keysize);
	datasize = msg->content.entry->value->datasize;
	datasize_conv = htonl(datasize);

	char comp_data[datasize];

	memcpy(comp_data, msg_str + 4 + 2 + keysize + 4, datasize);

	result = memcmp(msg_str, &opcode, 2) == 0 &&
		 memcmp(msg_str + 2, &c_type, 2) == 0 &&
		 memcmp(msg_str + 4, &keysize_conv, 2) == 0 &&
		 memcmp(msg_str + 6, &comp_key, keysize) == 0 &&
		 memcmp(msg_str + 6 + keysize, &datasize_conv, 4) == 0 &&
		 memcmp(msg_str + 6 + keysize + 4, &comp_data, datasize) == 0;

	free_message(msg);

	msg = buffer_to_message(msg_str, size);

	result = result && msg->opcode == OC_PUT &&
			   msg->c_type == CT_ENTRY &&
			   strcmp(msg->content.entry->key, datastr) == 0 &&
			   msg->content.entry->value->datasize == strlen(datastr) + 1 &&
			   strcmp(msg->content.entry->value->data, datastr) == 0;

	free(msg_str);
	free(datastr);

	//print_message(msg);
	
	free_message(msg);

	printf(" %s\n", result ? "passou" : "não passou");
	return result;
}
Ejemplo n.º 8
0
int main(int argc, char **argv){

   int sockfd, connsockfd, cont = 2, i, socketsecundario;
   struct sockaddr_in server, client;
   struct pollfd desc_set[MAX_CLIENT];//Definido para 10 utilizadores em max_client
   struct table_t *table=(struct table_t*)malloc(sizeof(struct table_t));
   char *terminal = malloc(sizeof(char));
   int nbytes, msg_size, count;
   socklen_t size_client;
   // Verifica se foi passado algum argumento
   if (argc != 3 && argc != 5){
      printf("Servidor sem replicação: Uso: ./table_server <porto_servidor> <size_table>\n");
      printf("Servidor com replicação: Uso: ./table_server <porto_servidor> <porto2_servidor> <size_table> <ip_serverSecundario>\n");
      return -1;
   }

   //Ligar servidor replicado
   if(argc == 5){
      socketsecundario = ligarBackup(argv[4], argv[2]);
   }

   // Cria socket TCP
   if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0 ) {
      perror("Erro ao criar socket");
      return -1;
   }
   
   // Preenche estrutura server para bind
   server.sin_family = AF_INET;
   server.sin_addr.s_addr = htonl(INADDR_ANY);
   server.sin_port = htons(atoi(argv[1]));
   // Faz bind
   if (bind(sockfd, (struct sockaddr *) &server, sizeof(server)) < 0){
      perror("Erro ao fazer bind");
      close(sockfd);
      return -1;
   };
   // Faz listen
   if(listen(sockfd, 20) < 0){
      perror("Erro ao executar listen");
      close(sockfd);
      return -1;
   };

   //cria table
   table=table_skel_init(atoi(argv[2])); 

   desc_set[0].fd=fileno(stdin);
   desc_set[0].events=POLLIN;
   desc_set[0].revents=0;
   desc_set[1].fd=sockfd; //Listen socket
   desc_set[1].events=POLLIN;
   desc_set[1].revents=0;
   
   for(i=2; i< MAX_CLIENT; i++){
      desc_set[i].fd=-1;
      desc_set[i].events=0;
      desc_set[i].revents=0;
   }
   
   printf("**Estrutura de dados criada**\n**Servidor 'a espera de dados**\n");	

   //Espera por dados nos sockets abertos
   while(poll(desc_set, MAX_CLIENT, -1) >= 0){ 
      /*Tentativa de nova ligacao*/
      if(desc_set[1].revents & POLLIN){
         connsockfd = accept( desc_set[1].fd, ( struct sockaddr * )&client, &size_client);
         //adiciona connsockfd a desc_set
         desc_set[cont].fd=connsockfd;
         desc_set[cont].events=POLLIN;
         cont++;
      }
      /*Testar se ha algum evento extra por exemplo o pedido de informaçao
      do conteudo actual do server*/
      if(desc_set[0].revents & POLLIN){
         fgets(terminal, MAX_MSG, stdin);
         terminal=strtok(terminal, "\n");
         if(strcmp(terminal, "print")== 0){
            int conta=0;				
            char **tabela;
            tabela = table_get_keys(table);
            printf("A tabela actual e': \n");
            while(tabela[conta]!=NULL){
               printf("Key na posição [%d]: %s", conta, tabela[conta]);
               conta++;
            }
         }else{
            printf("erro! escreva print para apresentar o conteudo actual do server\n");
         }
      }

      for(i=2; i<cont; i++){
         if (desc_set[i].revents & POLLIN) {
            // Lê string enviada pelo cliente do socket referente a conexão
            if((nbytes = read(desc_set[i].fd,&msg_size,sizeof(int))) <= 0){
               //perror("Erro ao receber dados do cliente1");

               close(desc_set[i].fd);
               continue;
            }

            msg_size=ntohl(msg_size);
            char *msg_buf=(char *)malloc(msg_size+1);
            if((nbytes = read_all(desc_set[i].fd,msg_buf,msg_size)) < 0){
               perror("Erro ao receber dados do cliente2");
               close(desc_set[i].fd);
               continue;
            }		

            struct message_t *msg_recebida = buffer_to_message(msg_buf, msg_size);
            free(msg_buf);
	
	    if(argc==5){
            //actualizar o backup de acordo com o tipo de escrita
		
               if((msg_recebida->opcode)==OC_PUT){
                  if(actualizarBackup(msg_recebida->content.entry->key, msg_recebida->content.entry->value,1)==-1)
                     perror("Erro a receber OK do servidor secundario\n");
               }
               if((msg_recebida->opcode)==OC_COND_PUT){
                  if(actualizarBackup(msg_recebida->content.entry->key, msg_recebida->content.entry->value,1)==-1)
                     perror("Erro a receber OK do servidor secundario\n");
               }
               if((msg_recebida->opcode)==OC_DEL){
                  if(actualizarBackup(msg_recebida->content.key, msg_recebida->content.entry->value,0)==-1)
                     perror("Erro a receber OK do servidor secundario\n");
               }
	    }
            
            int res=invoke(msg_recebida);

            //Envia resposta ao cliente depois de converter para formato de rede
            msg_size = message_to_buffer(msg_recebida,&msg_buf);
            msg_size = htonl(msg_size);	
            free_message(msg_recebida);
            // Envia tamanho do buffer ao cliente através do socket referente a conexão
            if((nbytes = write(desc_set[i].fd,(char*)&msg_size,sizeof(int))) != sizeof(int)){
               perror("Erro ao enviar resposta ao cliente");
               close(desc_set[i].fd);
               continue;
            }
            msg_size=ntohl(msg_size);
            if((nbytes = write_all(desc_set[i].fd,msg_buf,msg_size) != msg_size)){
               perror("Erro ao enviar resposta ao cliente");
               close(desc_set[i].fd);
               continue;
            }	  
            //Verifica-se se a ligaçao foi desligada
            if (desc_set[i].revents & POLLHUP){
               close(desc_set[i].fd);
               desc_set[i].fd = -1;
               desc_set[i].events = 0;
            }
         }
      }
   }
   //elimina table
   table_skel_destroy();
   // Fecha socket
   close(connsockfd);
   close(sockfd);
   return 0;
}