void send_err(int skt, char* err_type, char* err_detail) { struct sbpfs_head head; char* data; int data_len = 0; head.data = NULL; head.title = REQUEST_ERR; head.entry_num = 0; mkent(head,ERR_TYPE,err_type); mkent(head,ERR_DETAIL,err_detail); mkent(head,CONTENT_LEN,"0"); if (make_head(&data, &data_len, &head) == -1) { return; } if (sbp_send(skt, data, data_len) < 0) { printf("send err failed\n"); sbp_perror("a"); perror("a"); goto err_exit; } free(data); return; err_exit: free(data); return; }
s32_t sbp_rmdir(char* filename){ SBP_PREPARE_REQUEST mkent(head,METHOD,"RMDIR"); mkent(head,ARGC,"1"); mkent(head,"Arg0",filename); mkent(head,CONTENT_LEN,"0"); SBP_SEND_AND_PROCESS_REPLY SBP_PROCESS_RESULT SBP_PROCESS_ERR }
void send_list(char* ip) { int skt = sbp_connect(ip, CNODE_SERVICE_PORT); u64_t blnum = getlist(); struct sbpfs_head head; char* head_data; int head_data_len; head.data = NULL; head.entry_num = 0; head.title = PROTOCOL; char block_num_s[32]; sprintf(block_num_s, "%lld", blnum); char c_len[32]; sprintf(c_len, "%lld", blnum * 8); char dnodename[38]; sprintf(dnodename, "%s%s", "DNode_", dname); mkent(head,CONTENT_LEN,c_len); mkent(head,USER,dnodename); mkent(head,"BlockNum",block_num_s); if (make_head(&head_data, &head_data_len, &head) == -1) { printf("mkhead failed\n"); free(head_data); return; } if (sbp_send(skt, head_data, head_data_len) < 0) { printf("send head err failed\n"); sbp_perror("a"); perror("a"); free(head_data); return; } if (sbp_send(skt, (char*) blolist, bnum * 8) < 0) { printf("send head err failed\n"); sbp_perror("a"); perror("a"); free(head_data); return; } printf("sendlist succeed\n"); if (get_reply(skt) < 0) { printf("error sendlist \n"); return; } printf("reply succeed\n"); }
s32_t sbp_closedir(s32_t dirfd){ if(dirfd < 0)return -1; if (fds[dirfd] == NULL) return -1; if (fds[dirfd]->type != T_DIR) return -1; char tran_fd[32]; SBP_PREPARE_REQUEST sprintf(tran_fd, "%lld", fds[dirfd]->server_fd); mkent(head,METHOD,"CLOSEDIR"); mkent(head,ARGC,"1"); mkent(head,"Arg0",tran_fd); //mkent(head,"Arg1",fds[fd]->auth_code); mkent(head,CONTENT_LEN,"0"); SBP_SEND_AND_PROCESS_REPLY SBP_PROCESS_RESULT err_exit3: free_head(&head); err_exit2: free(rec_data); err_exit1: free(data); err_exit: free(usr); free(pass); free_sbpfd(fds[dirfd]); fds[dirfd] = NULL; return -1; ok_exit: free(data); free(rec_data); free_head(&head); free(usr); free(pass); free_sbpfd(fds[dirfd]); fds[dirfd] = NULL; return 0; }
int send_copy(char*ip, u64_t blocknum) { struct sbpfs_head head; char* head_data; int head_data_len; char* data = (char*) malloc(1024 * 1024 * 16); if (data == NULL) { printf("malloc data failed\n"); return -1; } int succeed = readblock(blocknum, 0, 1024 * 1024 * 16, data); printf("succeed: %d\n", succeed); int skt = sbp_connect(ip, DNODE_SERVICE_PORT); printf("%d", skt); if (succeed < 0) send_err(skt, "copy_block", "cannot read block"); else { printf("send start\n"); head.data = NULL; head.entry_num = 0; head.title = REQUEST_OK; mkent(head,METHOD,"Copy"); mkent(head,ARGC,"3"); char blocknum_s[32]; sprintf(blocknum_s, "%lld", blocknum); mkent(head,"Arg0",blocknum_s); mkent(head,"Arg1","0"); char data_len_s[32]; sprintf(data_len_s, "%d", 1024 * 1024 * 16); mkent(head,"Arg2",data_len_s); char data_length_s[32]; sprintf(data_length_s, "%d", 1024 * 1024 * 16); mkent(head,CONTENT_LEN,data_length_s); if (make_head(&head_data, &head_data_len, &head) == -1) { printf("mkhead failed\n"); free(data); free(head_data); return -1; } if (sbp_send(skt, head_data, head_data_len) < 0) { printf("send head err failed\n"); sbp_perror("a"); perror("a"); free(data); free(head_data); return -1; } if (sbp_send(skt, data, 1024 * 1024 * 16) < 0) { printf("send data err failed\n"); sbp_perror("a"); perror("a"); free(data); free(head_data); return -1; } printf("send succeed\n"); free(data); free(head_data); return 0; } return 0; }
void process_req(struct list_entry * ent) { char* head_data; int head_data_len; struct sbpfs_head head; if (ent->req == 1) { char* data = (char*) malloc(ent->length); if (data == NULL) { printf("malloc data failed\n"); return; } int succeed = readblock(ent->block_num, ent->offset, ent->length, data); printf("succeed: %d\n", succeed); if (succeed < 0) send_err(ent->skt, "read_block", "cannot read block"); else { head.data = NULL; head.title = REQUEST_OK; head.entry_num = 0; char data_length_s[32]; sprintf(data_length_s, "%d", ent->length); mkent(head,CONTENT_LEN,data_length_s); if (make_head(&head_data, &head_data_len, &head) == -1) { printf("mkhead failed\n"); free(head_data); free(data); return; } if (sbp_send(ent->skt, head_data, head_data_len) < 0) { printf("send head err failed\n"); sbp_perror("a"); perror("a"); free(data); free(head_data); return; } if (sbp_send(ent->skt, data, ent->length) < 0) { printf("send data err failed\n"); sbp_perror("a"); perror("a"); free(data); free(head_data); return; } free(data); free(head_data); return; } } if (ent->req == 2) { int succeed = writeblock(ent->block_num, ent->offset, ent->length, ent->data); printf("succeed in write : %d\n", succeed); if (succeed < 0) { send_err(ent->skt, "write_block", "cannot write block"); } else { head.data = NULL; head.title = REQUEST_OK; head.entry_num = 0; mkent(head,CONTENT_LEN,"0"); } if (make_head(&head_data, &head_data_len, &head) == -1) { printf("mkhead failed\n"); free(head_data); return; } if (sbp_send(ent->skt, head_data, head_data_len) < 0) { printf("send head err failed\n"); sbp_perror("a"); perror("a"); free(head_data); return; } char*ip = "59.78.15.46"; //send_success(ip,ent->block_num); } if (ent->req == 3) { int succeed = writeblock(ent->block_num, ent->offset, ent->length, ent->data); printf("succeed in copy : %d\n", succeed); } }
static s64_t sbp_read_or_write(s64_t fd, void* buf, u64_t len, char* method) { if (fds[fd] == NULL) return -1; char tran_fd[32]; char tran_offset[32]; char tran_len[32]; s64_t ret = -1; SBP_PREPARE_REQUEST sprintf(tran_fd, "%lld", fds[fd]->server_fd); sprintf(tran_offset, "%lld", fds[fd]->offset); sprintf(tran_len, "%lld", len); mkent(head,METHOD,method); mkent(head,ARGC,"3"); mkent(head,"Arg0",tran_fd); mkent(head,"Arg1",tran_offset); mkent(head,"Arg2",tran_len); mkent(head,CONTENT_LEN,"0"); SBP_SEND_AND_PROCESS_REPLY if (strncmp(head.title, REQUEST_OK, strlen(REQUEST_OK)) == 0) { u64_t content_l = -1; char* value = get_head_entry_value(&head, CONTENT_LEN); if (value == NULL) { seterr(HEAD_ERR,NO_CONTENT_LEN); goto err_exit3; } content_l = atoll(value); if (content_l % sizeof(struct block_entry)) { printf("content l :%lld :%ld\n", content_l, sizeof(struct block_entry)); seterr(DATA_ERR,DATA_LEN); goto err_exit3; } u64_t block_ent_num = content_l / sizeof(struct block_entry); struct block_entry* ents = (struct block_entry*) (rec_data + head.head_len); if (strcmp(method, "WRITE") == 0) { ret = write_blocks(ents, block_ent_num, buf, fds[fd]->auth_code); } else if (strcmp(method, "READ") == 0) { ret = read_blocks(ents, block_ent_num, buf, fds[fd]->auth_code); } if (ret >= 0){ fds[fd]->offset += ret; //printf("fds offset :%lld\n",fds[fd]->offset); } goto ok_exit; } else if (strncmp(head.title, REQUEST_ERR, strlen(REQUEST_ERR)) == 0) { sbp_update_err(&head); goto err_exit3; } else { seterr(HEAD_ERR, UNKNOWN_HEAD); } err_exit3: free_head(&head); err_exit2: free(rec_data); err_exit1: free(data); err_exit: free(usr); free(pass); return ret; ok_exit: free(data); free(rec_data); free_head(&head); free(usr); free(pass); return ret; }
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; }
static s64_t read_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); 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,"READ"); 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,"0"); if (make_head(&data, &data_len, &head) == -1) { seterr(HEAD_ERR,MAKE_HEAD); goto err_exit; }/*data need free*/ if (sendrec_hostname( get_dnode_hostname(ents->d_nodes[offset_in_ent_dnode]), DNODE_SERVICE_PORT, data, data_len, &rec_data, &rec_len) != 0) { goto err_exit1; }/*rec_data need free*/ 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) { u64_t content_l = -1; char* value = get_head_entry_value(&head, CONTENT_LEN); if (value == NULL) { seterr(HEAD_ERR,NO_CONTENT_LEN); goto err_exit3; } content_l = atoll(value); if (content_l != ents->length_in_block) { seterr(DATA_ERR,DATA_LEN); goto err_exit3; } memcpy(buf, rec_data + head.head_len, content_l); ret = content_l; } 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); free(data); free(rec_data); free_head(&head); return ret; }
int main(int argc, char *argv[]) { struct entry *ents; size_t i; ARGBEGIN { case '1': /* ignore */ break; case 'A': Aflag = 1; break; case 'a': aflag = 1; break; case 'c': cflag = 1; uflag = 0; break; case 'd': dflag = 1; break; case 'f': aflag = 1; fflag = 1; Uflag = 1; break; case 'F': Fflag = 1; break; case 'H': Hflag = 1; break; case 'h': hflag = 1; break; case 'i': iflag = 1; break; case 'L': Lflag = 1; break; case 'l': lflag = 1; break; case 'n': lflag = 1; nflag = 1; break; case 'p': pflag = 1; break; case 'q': qflag = 1; break; case 'R': Rflag = 1; break; case 'r': if (!fflag) rflag = 1; break; case 'S': Sflag = 1; tflag = 0; break; case 't': Sflag = 0; tflag = 1; break; case 'U': Uflag = 1; break; case 'u': uflag = 1; cflag = 0; break; default: usage(); } ARGEND; many = (argc > 1); if (argc == 0) *--argv = ".", argc++; ents = ereallocarray(NULL, argc, sizeof(*ents)); for (i = 0; i < argc; i++) mkent(&ents[i], argv[i], 1, Hflag || Lflag); qsort(ents, argc, sizeof(*ents), entcmp); for (i = 0; i < argc; i++) ls(&ents[rflag ? argc-i-1 : i], 1); return fshut(stdout, "<stdout>"); }
static void lsdir(const char *path) { DIR *dp; Rune r; struct entry ent, *ents = NULL; struct dirent *d; size_t i, n = 0, len; char cwd[PATH_MAX], *p, *q, *name; if (!getcwd(cwd, sizeof(cwd))) eprintf("getcwd:"); if (!(dp = opendir(path))) eprintf("opendir %s:", path); if (chdir(path) < 0) eprintf("chdir %s:", path); if (many || Rflag) { if (!first) putchar('\n'); printf("%s:\n", path); } first = 0; while ((d = readdir(dp))) { if (d->d_name[0] == '.' && !aflag && !Aflag) continue; else if (Aflag) if (strcmp(d->d_name, ".") == 0 || strcmp(d->d_name, "..") == 0) continue; if (Uflag){ mkent(&ent, d->d_name, Fflag || lflag || pflag || iflag || Rflag, Lflag); ls(&ent, Rflag); } else { ents = ereallocarray(ents, ++n, sizeof(*ents)); name = p = estrdup(d->d_name); if (qflag) { q = d->d_name; while (*q) { len = chartorune(&r, q); if (isprintrune(r)) { memcpy(p, q, len); p += len, q += len; } else { *p++ = '?'; q += len; } } *p = '\0'; } mkent(&ents[n - 1], name, tflag || Sflag || Fflag || iflag || lflag || pflag || Rflag, Lflag); } } closedir(dp); if (!Uflag){ qsort(ents, n, sizeof(*ents), entcmp); for (i = 0; i < n; i++) { ls(&ents[rflag ? (n - i - 1) : i], Rflag); free(ents[rflag ? (n - i - 1) : i].name); } } if (chdir(cwd) < 0) eprintf("chdir %s:", cwd); free(ents); }
s32_t sbp_opendir(char* filename) { s32_t fd = get_slot(); SBP_PREPARE_REQUEST mkent(head,METHOD,"OPENDIR"); mkent(head,ARGC,"1"); mkent(head,"Arg0",filename); mkent(head,CONTENT_LEN,"0"); SBP_SEND_AND_PROCESS_REPLY if (strncmp(head.title, REQUEST_OK, strlen(REQUEST_OK)) == 0) { if ((fds[fd] = (struct sbp_filedesc *) malloc( sizeof(struct sbp_filedesc))) == NULL) { seterr(MEM_ERR,MALLOC); goto err_exit3; }// need sbp_close(fd) bzero(fds[fd], sizeof(struct sbp_filedesc)); if ((fds[fd]->filename = (char *) malloc(sizeof(strlen(filename) + 1))) == NULL) { seterr(MEM_ERR,MALLOC); goto err_exit4; } memcpy(fds[fd]->filename, filename, strlen(filename)); fds[fd]->filename[strlen(filename)] = 0; fds[fd]->offset = 0; fds[fd]->type = T_DIR; char* fd_s = get_head_entry_value(&head, DIR_FD); if(fd_s == NULL) { seterr(DATA_ERR,"Could not get FD"); goto err_exit4; } fds[fd]->server_fd = atoll(fd_s); // char* auth_code = get_head_entry_value(&head, AUTH_CODE); // if (auth_code == NULL) { // seterr(DATA_ERR,AUTH_LEN); // goto err_exit4; // } char* dir_ent_num = get_head_entry_value(&head, DIR_ENT_NUM); if (dir_ent_num == NULL) { seterr(DATA_ERR,DIR_ENT_LEN); goto err_exit4; } fds[fd]->length = atoll(dir_ent_num); // int auth_len = strlen(auth_code); // if (auth_len > AUTH_CODE_LEN) { // seterr(DATA_ERR,AUTH_LEN); // goto err_exit4; // } // memcpy(fds[fd]->auth_code, auth_code, auth_len); goto ok_exit; } else if (strncmp(head.title, REQUEST_ERR, strlen(REQUEST_ERR)) == 0) { sbp_update_err(&head); goto err_exit3; } else { seterr(HEAD_ERR, UNKNOWN_HEAD); } err_exit4: sbp_closedir(fd); 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(data); free(rec_data); free_head(&head); free(usr); free(pass); return fd; }
struct sbp_dirent* sbp_readdir(s32_t dirfd) { if(dirfd<0)return NULL; if (fds[dirfd] == NULL) { return NULL; } struct sbpfs_head head; char* usr; char* pass; char* data; char* rec_data; char tran_usr[16 + 7]; u64_t rec_len = 0; int data_len = 0; head.data = ((void *)0); head.title = "SBPFS/1.0"; head.entry_num = 0; if (sbp_getUandP(&usr, &pass) == -1) { printf("Can not get username and password\n"); return NULL; } sprintf(tran_usr, "Client_%s", usr); head.entrys[head.entry_num].name = "User"; head.entrys[head.entry_num++].value = tran_usr;; head.entrys[head.entry_num].name = "Password"; head.entrys[head.entry_num++].value = pass;; char tran_fd[32]; char tran_offset[32]; sprintf(tran_fd,"%lld",fds[dirfd]->server_fd); sprintf(tran_offset,"%lld",fds[dirfd]->offset); mkent(head,METHOD,"READDIR"); mkent(head,ARGC,"2"); mkent(head,"Arg0",tran_fd); mkent(head,"Arg1",tran_offset); mkent(head,CONTENT_LEN,"0"); SBP_SEND_AND_PROCESS_REPLY if (strncmp(head.title, REQUEST_OK, strlen(REQUEST_OK)) == 0) { u64_t content_l = -1; char* value = get_head_entry_value(&head,CONTENT_LEN); if(value == NULL) { seterr(HEAD_ERR,NO_CONTENT_LEN); goto err_exit3; } content_l = atoll(value); if(content_l != sizeof(struct sbp_dirent_for_trans)) { goto err_exit3; } memcpy(&dir_ent,rec_data + head.head_len,content_l); dir_ent.offset = fds[dirfd]->offset++; goto ok_exit; } else if (strncmp(head.title, REQUEST_ERR, strlen(REQUEST_ERR)) == 0) { sbp_update_err(&head); goto err_exit3; } else { seterr(HEAD_ERR,UNKNOWN_HEAD); } err_exit3: free_head(&head); err_exit2: free(rec_data); err_exit1: free(data); err_exit: free(usr); free(pass); return NULL; ok_exit: free(data); free(rec_data); free_head(&head); free(usr); free(pass); return &dir_ent; }