struct data_t *data_dup(struct data_t *data){
if (data == NULL || data->datasize < 0 || data->data == NULL)
return NULL;
return data_create2(data->datasize, data->data);
}
int testCreate2() {
int result, data_size = strlen("1234567890abc")+1;
char *data_s = strdup("1234567890abc");
struct data_t *data = data_create2(data_size,data_s);
result = (data->data == data_s) &&
(data->datasize == data_size);
data_destroy(data);
printf("Modulo data -> teste data_create2: %s\n",result?"passou":"nao passou");
return result;
}
int testCreate() {
char *key = strdup("123abc");
struct data_t *value = data_create2(strlen("1234567890abc")+1,strdup("1234567890abc"));
struct entry_t *entry = entry_create(key,value);
int result = (entry->key == key) &&
(entry->value == value);
entry_destroy(entry);
printf("Modulo entry -> teste entry_create: %s\n",result?"passou":"nao passou");
return result;
}
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;
}
int rtable_put(struct rtable_t *rtable, char *key, struct data_t *data){
int result;
struct data_t *NovaData=(struct data_t*)malloc(sizeof(struct data_t));
NovaData=data_create2(strlen(data),data);
struct entry_t *entry=(struct entry_t*)malloc(sizeof(struct entry_t));
entry = entry_create(key, NovaData);
struct message_t *msg = (struct message_t*)malloc(sizeof(struct message_t));
msg->opcode = OC_PUT;
msg->c_type = CT_ENTRY;
msg->content.entry=entry;
//network_send_receive(rtable->server, msg);
if( network_send_receive(rtable->server, msg)->opcode==OC_PUT+1){ //testar se foi colocado efectivamente no servidor
result=1;
} else {
result = -1;
}
return result;
}
int testDup() {
char *key = strdup("123abc");
struct data_t *value = data_create2(strlen("1234567890abc")+1,strdup("1234567890abc"));
struct entry_t *entry = entry_create(key,value);
struct entry_t *entry2 = entry_dup(entry);
int result = (entry->key != entry2->key) &&
(strcmp(entry->key,entry2->key) == 0) &&
(entry->value != entry2->value) &&
(entry->value->datasize == entry2->value->datasize) &&
(memcmp(entry->value->data, entry2->value->data, entry->value->datasize) == 0);
entry_destroy(entry);
entry_destroy(entry2);
printf("Modulo entry -> teste entry_dup: %s\n",result?"passou":"não passou");
return result;
}
int main(int argc, char**argv){
//verifica se tem no argumento o adress_port
if(argc < 2)
{
perror("Poucos ou muitos argumentos");
return -1;
}
char ** outKeys;
char *input = malloc(100 * sizeof(char));
struct data_t *inData, *outData;
struct rtable_t *rtable;
char *instruction;
char *inKeyData;
char *inKey;
int numSpace,i;
if((rtable = rtable_bind(argv[1])) == NULL)
{
perror("Erro ao conectar-se ao servidor");
return -1;
}
while(1){
printf("Enter an instruction: ");
fgets(input, 100, stdin);
//Numero de Espaços
for(i=0,numSpace=0;input[i]!='\0';i++)
if(input[i] == ' ')
numSpace++;
switch(numSpace)
{
case 0:
instruction = strtok(input,"\n");
break;
case 1:
instruction = strtok(input," ");
inKey = strtok(NULL,"\n");
break;
case 2:
instruction = strtok(input," ");
inKey = strtok(NULL," ");
inKeyData = strtok(NULL,"\n");
if(inKey != NULL && inKeyData != NULL)
inData = data_create2(strlen(inKeyData),inKeyData);
break;
default:
instruction = "";
break;
}
if(strcmp(instruction,"put") == 0 && numSpace == 2)
{
if(rtable_put(rtable,inKey,inData)==0)
{
printf("Operação executada com sucesso\n");
}
else
{
printf("Operação executa com insucesso\n");
}
data_destroy(inData);
}
else if(strcmp(instruction,"get") == 0 && numSpace == 1)
{
if(strcmp(inKey,"!") == 0)
{
outKeys = rtable_get_keys(rtable);
if(outKeys != NULL)
{
printf("Operação executada com sucesso\n");
for(i = 0; outKeys[i] != NULL ; i++)
{
printf("A tabela remota tem a key: %s\n", outKeys[i]);
}
rtable_free_keys(outKeys);
}
else
{
printf("Operação executa com insucesso\n");
}
}
else
{
outData = rtable_get(rtable,inKey);
if(outData != NULL)
{
printf("Operação executada com sucesso\n");
printf("Data recebida com tamanho %d\n",outData->datasize);
data_destroy(outData);
}
else
{
printf("Operação executa com insucesso\n");
}
}
}
else if(strcmp(instruction,"update" ) == 0 && numSpace == 2)
{
if(rtable_update(rtable,inKey,inData)==0)
{
printf("Operação executada com sucesso\n");
}
else
{
printf("Operação executa com insucesso\n");
}
data_destroy(inData);
}
else if(strcmp(instruction,"del") == 0 && numSpace == 1)
{
if(rtable_del(rtable,inKey)==0)
{
printf("Operação executada com sucesso\n");
}
else
{
printf("Operação executa com insucesso\n");
}
}
else if(strcmp(instruction,"size") == 0 && numSpace == 0)
{
printf("Numero de elementos da tabela remota: %d\n",rtable_size(rtable));
}
else if(strcmp(instruction,"quit") == 0 && numSpace == 0)
{
free(input);
if(rtable_unbind(rtable)<0)
{
perror("rtable_unbind");
return -1;
}
printf("Adeus humano!\n");
return 0;
}
else
{
printf("Non-valid instruction\n");
}
}
}
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;
}
