int get_reply(int skt) {
struct sbpfs_head head;
char* rec_buf;
u64_t rec_len;
if (sbp_recv(skt, &rec_buf, &rec_len) == -1) {
printf("failed to receive data\n");
return -1;
}
if (strlen(rec_buf) == 0) {
return -1;
}
if (decode_head(rec_buf, rec_len, &head) == -1) {
printf("decode head failed\n");
return -1;
}/*head need free*/
if (strcmp(head.title, REQUEST_OK) == 0) {
free_head(&head);
return 0;
} else {
free_head(&head);
return -1;
}
}
void* serve(void* arg) {
struct list_entry* ent = (struct list_entry*) arg;
struct sbpfs_head head;
char* rec_buf;
u64_t rec_len;
//printf("start receive\n");
if (sbp_recv(ent->skt, &rec_buf, &rec_len) == -1) {
printf("failed to receive data\n");
return NULL;
}
if (strlen(rec_buf) == 0) {
goto err_exit;
}
if (decode_head(rec_buf, rec_len, &head) == -1) {
printf("decode head failed\n");
goto err_exit;
}/*head need free*/
char* method;
if ((method = get_head_entry_value(&head, METHOD)) == NULL) {
printf("get head entry failed\n");
goto err_exit2;
}
if (strcmp(method, "READ") == 0) {
ent->req = 1;
} else if (strcmp(method, "WRITE") == 0) {
ent->req = 2;
} else if (strcmp(method, "Copy") == 0) {
ent->req = 3;
} else {
printf("invalid request\n");
goto err_exit2;
}
char* block_num_s;
char* offset_s;
char* length_s;
char* content_len_s;
if ((block_num_s = get_head_entry_value(&head, "Arg0")) == NULL) {
printf("get head entry Arg0 failed\n");
goto err_exit2;
}
if ((offset_s = get_head_entry_value(&head, "Arg1")) == NULL) {
printf("get head entry Arg1 failed\n");
goto err_exit2;
}
if ((length_s = get_head_entry_value(&head, "Arg2")) == NULL) {
printf("get head entry Arg2 failed\n");
goto err_exit2;
}
if ((content_len_s = get_head_entry_value(&head, "Content-Length")) == NULL) {
printf("get head entry Content-Length failed\n");
goto err_exit2;
}
ent->block_num = atoll(block_num_s);
ent->offset = atoi(offset_s);
ent->length = atoi(length_s);
if (ent->req == 2 || ent->req == 3) {
ent->data_length = atoll(content_len_s);
ent->data = rec_buf + head.head_len;
}
//send_err(ent->skt, "a", "b");
process_req(ent);
err_exit2: free_head(&head);
err_exit: free(rec_buf);
close(ent->skt);
free(ent);
return NULL;
}
static s64_t write_block(struct block_entry* ents, int offset_in_ent_dnode,
char* buf, char* auth_code) {
s64_t ret = 0;
struct sbpfs_head head;
char* usr;
char* pass;
char* data;
char* rec_data;
char tran_usr[TRAN_USERNAME_LEN];
char tran_blocknum[32];
char tran_offset[32];
char tran_len[32];
if (sbp_getUandP(&usr, &pass) == -1) {
printf("Can not get username and password\n");
return -1;
}
sprintf(tran_usr, "Client_%s", usr);
s64_t sockfd;
u64_t rec_len = 0;
int data_len = 0;
head.data = NULL;
head.title = PROTOCOL;
head.entry_num = 0;
mkent(head,USER,tran_usr);
mkent(head,PASS,pass);
mkent(head,AUTH_CODE,auth_code);
mkent(head,METHOD,"WRITE");
mkent(head,ARGC,"3");
bzero(tran_blocknum, 32);
bzero(tran_offset, 32);
bzero(tran_len, 32);
sprintf(tran_blocknum, "%lld", ents->block_id);
sprintf(tran_offset, "%d", ents->offset_in_block);
sprintf(tran_len, "%d", ents->length_in_block);
mkent(head,"Arg0",tran_blocknum);
mkent(head,"Arg1",tran_offset);
mkent(head,"Arg2",tran_len);
mkent(head,CONTENT_LEN,tran_len);
if (make_head(&data, &data_len, &head) == -1) {
seterr(HEAD_ERR,MAKE_HEAD);
goto err_exit;
}/*data need free*/
if ((sockfd = sbp_connect(get_dnode_hostname(
ents->d_nodes[offset_in_ent_dnode]), DNODE_SERVICE_PORT)) < 0) {
printf("connect ip: %s err\n", get_dnode_hostname(
ents->d_nodes[offset_in_ent_dnode]));
seterr(SOCKET_ERR, EST_SOCK);
goto err_exit1;
}
if (sbp_send(sockfd, data, data_len) < 0) {
printf("send head to ip: %s err\n", get_dnode_hostname(
ents->d_nodes[offset_in_ent_dnode]));
seterr(SOCKET_ERR, SEND);
goto err_exit1;
}
if (sbp_send(sockfd, buf, ents->length_in_block) < 0) {
printf("send data to ip: %s err\n", get_dnode_hostname(
ents->d_nodes[offset_in_ent_dnode]));
seterr(SOCKET_ERR, SEND);
goto err_exit1;
}
if ((sbp_recv(sockfd, &rec_data, &rec_len)) < 0) {
printf("receive from ip: %s err\n", get_dnode_hostname(
ents->d_nodes[offset_in_ent_dnode]));
seterr(SOCKET_ERR, RECV);
goto err_exit1;
}
if (strlen(rec_data) == 0) {
seterr(SOCKET_ERR,RECV);
goto err_exit2;
}
if (decode_head(rec_data, rec_len, &head) == -1) {
seterr("Data Error", "Can not decode SBPFS_HEAD");
goto err_exit2;
}/*head need free*/
if (strncmp(head.title, REQUEST_OK, strlen(REQUEST_OK)) == 0) {
ret = ents->length_in_block;
free(data);
free(rec_data);
free_head(&head);
// printf("succeeded write to %s block: %lld length:%d \n",
// get_dnode_hostname(ents->d_nodes[offset_in_ent_dnode]),
// ents->block_id, ents->length_in_block);
} else if (strncmp(head.title, REQUEST_ERR, strlen(REQUEST_ERR)) == 0) {
sbp_update_err(&head);
goto err_exit3;
} else {
seterr(HEAD_ERR, UNKNOWN_HEAD);
}
goto ok_exit;
err_exit3:
free_head(&head);
err_exit2:
free(rec_data);
err_exit1:
free(data);
err_exit:
free(usr);
free(pass);
return -1;
ok_exit: free(usr);
free(pass);
return ret;
}
