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;
}
