int is_room(char *line)
{
char **info_room;
info_room = NULL;
if (!(ft_strchr(line, ' ')) || nb_space(line) != 1)
return (0);
info_room = ft_strsplit(line, ' ');
if (!(check_nb_data(info_room)))
{
free_split(info_room);
return (0);
}
if (!(check_name(info_room[0])))
{
free_split(info_room);
return (0);
}
if (!(check_coord(info_room[1])) || !(check_coord(info_room[2])))
{
free_split(info_room);
return (0);
}
free_split(info_room);
return (1);
}
void do_in4_in8(t_list **a, t_list **b, t_list **in)
{
char **patterns;
int count;
int *abcd;
int *ops;
int j;
patterns = load_file("patterns/IN4");
count = lstlen(*a);
abcd = make_sequence(count, 1, 1, 4);
while (count)
{
ops = make_instr_arr(recognize_4pat(patterns, \
grab_next_n(*a, 4), abcd));
while (*ops != -1)
make_move(a, b, in, *ops++);
j = -1;
while (++j < 4)
abcd[j] = abcd[j] + 4;
count -= 4;
}
free(abcd);
free_split(patterns);
}
char *find_path_exec(char *exec, t_gen *envp)
{
char *path;
char **split;
int i;
i = -1;
if ((path = get_var_env("PATH=", envp->env)) == NULL)
return (NULL);
split = ft_strsplit(path, ':');
while (split[++i])
{
path = concat_path(split[i], exec);
if ((access(path, F_OK) != -1) &&
((envp->ret = check_access(path)) == 0))
break ;
else
{
envp->ret = check_access(path);
ft_strdel(&path);
if (envp->ret == ENPERM)
break ;
}
}
free_split(&split);
return (path);
}
void quit(char *str, int status)
{
if (str)
ft_putstr(str);
clean_lines();
free_split(*data()->envp);
free(data());
exit(status);
}
void destroy_gen_term(t_gen *gen)
{
if (gen->term)
{
gen->term->fd = 0;
gen->term->wait = 0;
if (gen->term->key)
free_split(&(gen->term->key));
free(gen->term);
gen->term = NULL;
}
}
void action_delfirst(t_alist **alist)
{
t_alist *tmp;
if (*alist)
{
tmp = *alist;
*alist = (*alist)->next;
if (tmp->cmd)
free_split(tmp->cmd);
if (tmp->timer)
free(tmp->timer);
free(tmp);
}
}
void do_tr4_in8(t_list **a, t_list **b, t_list **in)
{
char **patterns;
int *abcd;
t_kit *k;
patterns = load_file("patterns/IN8");
abcd = make_sequence(lstlen(*a) / 4 + 1, -1, 1, 4);
while (lstlen(*a) != lstlen(*b))
{
k = new_kit(a, b, in, abcd);
do_ops_kit(make_instr_arr(recognize_8pat(patterns, \
grab_next_n(*a, 8), abcd)), k, 8, 0);
add_vec(abcd, make_sequence(2, -4, 2, 4), 4);
}
free(abcd);
free_split(patterns);
}
int op_unlink (const char *path)
{
int rt;
errcode_t rc;
char *p_path;
char *r_path;
ext2_ino_t p_ino;
struct ext2_inode p_inode;
ext2_ino_t r_ino;
struct ext2_vnode *r_vnode;
struct ext2_inode *r_inode;
ext2_filsys e2fs;
FUSE_EXT2_LOCK;
e2fs = current_ext2fs();
debugf("enter");
debugf("path = %s", path);
rt=do_check_split(path, &p_path, &r_path);
if (rt != 0) {
debugf("do_check_split: failed");
goto err;
}
debugf("parent: %s, child: %s", p_path, r_path);
rt = do_readinode(e2fs, p_path, &p_ino, &p_inode);
if (rt) {
debugf("do_readinode(%s, &p_ino, &p_inode); failed", p_path);
goto err_free_split;
}
rt = do_readvnode(e2fs, path, &r_ino, &r_vnode, DONT_OPEN_FILE);
if (rt) {
debugf("do_readvnode(%s, &r_ino, &r_vnode); failed", path);
goto err_free_split;
}
r_inode = vnode2inode(r_vnode);
if(LINUX_S_ISDIR(r_inode->i_mode)) {
debugf("%s is a directory", path);
vnode_put(r_vnode,0);
rt = -EISDIR;
goto err_free_split;
}
rc = ext2fs_unlink(e2fs, p_ino, r_path, r_ino, 0);
if (rc) {
debugf("ext2fs_unlink(e2fs, %d, %s, %d, 0); failed", p_ino, r_path, r_ino);
vnode_put(r_vnode,0);
rt = -EIO;
goto err_free_split;
}
if (r_inode->i_links_count > 0) {
r_inode->i_links_count -= 1;
}
p_inode.i_ctime = p_inode.i_mtime = e2fs->now ? e2fs->now : time(NULL);
rc = ext2fs_write_inode(e2fs, p_ino, &p_inode);
if (rc) {
debugf("ext2fs_write_inode(e2fs, p_ino, &p_inode); failed");
vnode_put(r_vnode,1);
rt = -EIO;
goto err_free_split;
}
r_inode->i_ctime = e2fs->now ? e2fs->now : time(NULL);
rc = vnode_put(r_vnode,1);
if (rc) {
debugf("vnode_put(r_vnode,1); failed");
rt = -EIO;
goto err_free_split;
}
free_split(p_path, r_path);
debugf("leave");
FUSE_EXT2_UNLOCK;
return 0;
err_free_split:
free_split(p_path, r_path);
err:
FUSE_EXT2_UNLOCK;
return rt;
}
/**********************************************************************
* delete_split
*
* Remove this split from existance. Take if off the display list and
* deallocate its memory.
**********************************************************************/
void delete_split(SPLIT *split) {
if (split) {
free_split(split);
}
}
int op_mkdir (const char *path, mode_t mode)
{
int rt;
time_t tm;
char *p_path;
char *r_path;
ino_t ino;
struct ufs_vnode *vnode;
struct ufs_vnode *child_vnode;
struct inode *inode;
struct fuse_context *ctx;
uufsd_t *ufs = current_ufs();
RETURN_IF_RDONLY(ufs);
debugf("enter");
debugf("path = %s, mode: 0%o, dir:0%o", path, mode, S_IFDIR);
rt=do_check_split(path, &p_path ,&r_path);
if (rt != 0) {
debugf("do_check(%s); failed", path);
return rt;
}
debugf("parent: %s, child: %s, pathmax: %d", p_path, r_path, PATH_MAX);
rt = do_readvnode(ufs, p_path, &ino, &vnode);
if (!vnode) {
debugf("do_readvnode(%s, &ino, &vnode); failed", p_path);
free_split(p_path, r_path);
return rt;
}
debugf("calling ufs_mkdir(ufs, %d, 0, %s);", ino, r_path);
rt = ufs_mkdir(ufs, ino, 0, r_path);
if (rt) {
debugf("ufs_mkdir(ufs, %d, 0, %s); failed (%d)", ino, r_path, rt);
free_split(p_path, r_path);
return rt;
}
rt = do_readvnode(ufs, path, &ino, &child_vnode);
if (rt) {
debugf("do_readvnode(%s, &ino, &child_vnode); failed", path);
return -EIO;
}
tm = ufs->now ? ufs->now : time(NULL);
inode = vnode2inode(child_vnode);
inode->i_mode = S_IFDIR | mode;
inode->i_ctime = inode->i_atime = inode->i_mtime = tm;
ctx = fuse_get_context();
if (ctx) {
inode->i_uid = ctx->uid;
inode->i_gid = ctx->gid;
}
vnode_put(child_vnode, 1);
inode = vnode2inode(vnode);
inode->i_ctime = inode->i_mtime = tm;
vnode_put(vnode, 1);
free_split(p_path, r_path);
debugf("leave");
return 0;
}
int do_create (ext2_filsys e2fs, const char *path, mode_t mode, dev_t dev, const char *fastsymlink)
{
int rt;
time_t tm;
errcode_t rc;
char *p_path;
char *r_path;
ext2_ino_t ino;
struct ext2_inode inode;
ext2_ino_t n_ino;
struct fuse_context *ctx;
debugf("enter");
debugf("path = %s, mode: 0%o", path, mode);
rt=do_check_split(path, &p_path, &r_path);
debugf("parent: %s, child: %s", p_path, r_path);
rt = do_readinode(e2fs, p_path, &ino, &inode);
if (rt) {
debugf("do_readinode(%s, &ino, &inode); failed", p_path);
free_split(p_path, r_path);
return rt;
}
rc = ext2fs_new_inode(e2fs, ino, mode, 0, &n_ino);
if (rc) {
debugf("ext2fs_new_inode(ep.fs, ino, mode, 0, &n_ino); failed");
return -ENOMEM;
}
do {
debugf("calling ext2fs_link(e2fs, %d, %s, %d, %d);", ino, r_path, n_ino, do_modetoext2lag(mode));
rc = ext2fs_link(e2fs, ino, r_path, n_ino, do_modetoext2lag(mode));
if (rc == EXT2_ET_DIR_NO_SPACE) {
debugf("calling ext2fs_expand_dir(e2fs, &d)", ino);
if (ext2fs_expand_dir(e2fs, ino)) {
debugf("error while expanding directory %s (%d)", p_path, ino);
free_split(p_path, r_path);
return -ENOSPC;
}
}
} while (rc == EXT2_ET_DIR_NO_SPACE);
if (rc) {
debugf("ext2fs_link(e2fs, %d, %s, %d, %d); failed", ino, r_path, n_ino, do_modetoext2lag(mode));
free_split(p_path, r_path);
return -EIO;
}
if (ext2fs_test_inode_bitmap(e2fs->inode_map, n_ino)) {
debugf("inode already set");
}
ext2fs_inode_alloc_stats2(e2fs, n_ino, +1, 0);
memset(&inode, 0, sizeof(inode));
tm = e2fs->now ? e2fs->now : time(NULL);
inode.i_mode = mode;
inode.i_atime = inode.i_ctime = inode.i_mtime = tm;
inode.i_links_count = 1;
inode.i_size = 0;
ctx = fuse_get_context();
if (ctx) {
inode.i_uid = ctx->uid;
inode.i_gid = ctx->gid;
}
if (S_ISCHR(mode) || S_ISBLK(mode)) {
if (old_valid_dev(dev))
inode.i_block[0]= ext2fs_cpu_to_le32(old_encode_dev(dev));
else
inode.i_block[1]= ext2fs_cpu_to_le32(new_encode_dev(dev));
}
if (S_ISLNK(mode) && fastsymlink != NULL) {
inode.i_size = strlen(fastsymlink);
strncpy((char *)&(inode.i_block[0]),fastsymlink,
(EXT2_N_BLOCKS * sizeof(inode.i_block[0])));
}
rc = ext2fs_write_new_inode(e2fs, n_ino, &inode);
if (rc) {
debugf("ext2fs_write_new_inode(e2fs, n_ino, &inode);");
free_split(p_path, r_path);
return -EIO;
}
/* update parent dir */
rt = do_readinode(e2fs, p_path, &ino, &inode);
if (rt) {
debugf("do_readinode(%s, &ino, &inode); dailed", p_path);
free_split(p_path, r_path);
return -EIO;
}
inode.i_ctime = inode.i_mtime = tm;
rc = ext2fs_write_inode(e2fs, ino, &inode);
if (rc) {
debugf("ext2fs_write_inode(e2fs, ino, &inode); failed");
free_split(p_path, r_path);
return -EIO;
}
free_split(p_path, r_path);
debugf("leave");
return 0;
}
int op_link (const char *source, const char *dest)
{
int rc;
char *p_path;
char *r_path;
ino_t d_ino, ino;
struct ufs_vnode *vnode;
struct inode *inode;
uufsd_t *ufs = current_ufs();
RETURN_IF_RDONLY(ufs);
debugf("source: %s, dest: %s", source, dest);
rc = do_check(source);
if (rc != 0) {
debugf("do_check(%s); failed", source);
return rc;
}
rc = do_check_split(dest, &p_path, &r_path);
if (rc != 0) {
debugf("do_check(%s); failed", dest);
return rc;
}
debugf("parent: %s, child: %s", p_path, r_path);
rc = do_readvnode(ufs, p_path, &d_ino, &vnode);
if (rc) {
debugf("do_readvnode(%s, &d_ino, &inode); failed", p_path);
free_split(p_path, r_path);
return rc;
}
vnode_put(vnode, 0);
rc = do_readvnode(ufs, source, &ino, &vnode);
if (rc) {
debugf("do_readvnode(%s, &d_ino, &inode); failed", source);
free_split(p_path, r_path);
return rc;
}
inode = vnode2inode(vnode);
rc = ufs_link(ufs, d_ino, r_path, vnode, inode->i_mode);
if (rc) {
debugf("ufs_link() failed");
vnode_put(vnode, 0);
free_split(p_path, r_path);
return rc;
}
inode->i_mtime = inode->i_atime = inode->i_ctime = ufs->now ? ufs->now : time(NULL);
rc = vnode_put(vnode, 1);
if (rc) {
debugf("vnode_put(vnode,1); failed");
free_split(p_path, r_path);
return -EIO;
}
debugf("done");
return 0;
}
int op_link (const char *source, const char *dest)
{
int rc;
char *p_path;
char *r_path;
ext2_ino_t ino;
ext2_ino_t d_ino;
struct ext2_vnode *vnode;
struct ext2_inode *inode;
struct ext2_inode d_inode;
ext2_filsys e2fs = current_ext2fs();
debugf("source: %s, dest: %s", source, dest);
rc = do_check(source);
if (rc != 0) {
debugf("do_check(%s); failed", source);
return rc;
}
rc = do_check_split(dest, &p_path, &r_path);
if (rc != 0) {
debugf("do_check(%s); failed", dest);
return rc;
}
debugf("parent: %s, child: %s", p_path, r_path);
rc = do_readinode(e2fs, p_path, &d_ino, &d_inode);
if (rc) {
debugf("do_readinode(%s, &ino, &inode); failed", p_path);
free_split(p_path, r_path);
return rc;
}
rc = do_readvnode(e2fs, source, &ino, &vnode);
if (rc) {
debugf("do_readvnode(%s, &ino, &vnode); failed", source);
free_split(p_path, r_path);
return rc;
}
inode = vnode2inode(vnode);
do {
debugf("calling ext2fs_link(e2fs, %d, %s, %d, %d);", d_ino, r_path, ino, do_modetoext2lag(inode->i_mode));
rc = ext2fs_link(e2fs, d_ino, r_path, ino, do_modetoext2lag(inode->i_mode));
if (rc == EXT2_ET_DIR_NO_SPACE) {
debugf("calling ext2fs_expand_dir(e2fs, &d)", d_ino);
if (ext2fs_expand_dir(e2fs, d_ino)) {
debugf("error while expanding directory %s (%d)", p_path, d_ino);
vnode_put(vnode, 0);
free_split(p_path, r_path);
return -ENOSPC;
}
}
} while (rc == EXT2_ET_DIR_NO_SPACE);
if (rc) {
debugf("ext2fs_link(e2fs, %d, %s, %d, %d); failed", d_ino, r_path, ino, do_modetoext2lag(inode->i_mode));
vnode_put(vnode, 0);
free_split(p_path, r_path);
return -EIO;
}
d_inode.i_mtime = d_inode.i_ctime = inode->i_ctime = e2fs->now ? e2fs->now : time(NULL);
inode->i_links_count += 1;
rc=vnode_put(vnode,1);
if (rc) {
debugf("vnode_put(vnode,1); failed");
free_split(p_path, r_path);
return -EIO;
}
rc = ext2fs_write_inode(e2fs, d_ino, &d_inode);
if (rc) {
debugf("ext2fs_write_inode(e2fs, d_ino, &d_inode); failed");
free_split(p_path, r_path);
return -EIO;
}
debugf("done");
return 0;
}
int op_unlink (const char *path)
{
int rt;
char *p_path;
char *r_path;
ino_t p_ino;
struct ufs_vnode *p_vnode;
ino_t r_ino;
struct ufs_vnode *r_vnode;
struct inode *r_inode;
struct inode *p_inode;
uufsd_t *ufs = current_ufs();
RETURN_IF_RDONLY(ufs);
debugf("enter");
debugf("path = %s", path);
rt = do_check_split(path, &p_path, &r_path);
if (rt != 0) {
debugf("do_check_split: failed");
return rt;
}
debugf("parent: %s, child: %s", p_path, r_path);
rt = do_readvnode(ufs, p_path, &p_ino, &p_vnode);
if (rt) {
debugf("do_readinode(%s, &p_ino, &p_inode); failed", p_path);
free_split(p_path, r_path);
return rt;
}
rt = do_readvnode(ufs, path, &r_ino, &r_vnode);
if (rt) {
debugf("do_readvnode(%s, &r_ino, &r_vnode); failed", path);
free_split(p_path, r_path);
return rt;
}
r_inode = vnode2inode(r_vnode);
if(S_ISDIR(r_inode->i_mode)) {
debugf("%s is a directory", path);
vnode_put(r_vnode, 0);
free_split(p_path, r_path);
return -EISDIR;
}
rt = ufs_unlink(ufs, p_ino, r_path, r_ino, 0);
if (rt) {
debugf("ufs_unlink(ufs, %d, %s, %d, 0); failed", p_ino, r_path, r_ino);
vnode_put(r_vnode, 0);
vnode_put(p_vnode, 0);
free_split(p_path, r_path);
return -EIO;
}
if (r_inode->i_nlink > 0) {
r_inode->i_nlink -= 1;
}
p_inode = vnode2inode(p_vnode);
p_inode->i_ctime = p_inode->i_mtime = ufs->now ? ufs->now : time(NULL);
rt = vnode_put(p_vnode, 1);
if (rt) {
debugf("ufs_write_inode(ufs, p_ino, &p_inode); failed");
vnode_put(r_vnode,1);
free_split(p_path, r_path);
return -EIO;
}
r_inode->i_ctime = ufs->now ? ufs->now : time(NULL);
rt = vnode_put(r_vnode, 1);
if (rt) {
debugf("vnode_put(r_vnode, 1); failed");
free_split(p_path, r_path);
return -EIO;
}
free_split(p_path, r_path);
debugf("leave");
return 0;
}
