/*
 *  linux/fs/open.c
 *
 *  Copyright (C) 1991, 1992  Linus Torvalds
 */

#include <linux/vfs.h>
#include <linux/types.h>
#include <linux/utime.h>
#include <linux/errno.h>
#include <linux/fcntl.h>
#include <linux/stat.h>
#include <linux/string.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/signal.h>
#include <linux/tty.h>
#include <linux/time.h>
#include <linux/mm.h>
#include <linux/file.h>

#include <asm/segment.h>
#include <asm/bitops.h>

asmlinkage int sys_statfs(const char * path, struct statfs * buf)
{
        struct inode * inode;
        int error;

        error = verify_area(VERIFY_WRITE, buf, sizeof(struct statfs));
        if (error)
                return error;
        error = namei(path,&inode);
        if (error)
                return error;
        if (!inode->i_sb->s_op->statfs) {
                iput(inode);
                return -ENOSYS;
        }
        inode->i_sb->s_op->statfs(inode->i_sb, buf, sizeof(struct statfs));
        iput(inode);
        return 0;
}

asmlinkage int sys_fstatfs(unsigned int fd, struct statfs * buf)
{
        struct inode * inode;
        struct file * file;
        int error;

        error = verify_area(VERIFY_WRITE, buf, sizeof(struct statfs));
        if (error)
                return error;
        if (fd >= NR_OPEN || !(file = current->files->fd[fd]))
                return -EBADF;
        if (!(inode = file->f_inode))
                return -ENOENT;
        if (!inode->i_sb)
                return -ENODEV;
        if (!inode->i_sb->s_op->statfs)
                return -ENOSYS;
        inode->i_sb->s_op->statfs(inode->i_sb, buf, sizeof(struct statfs));
        return 0;
}

int do_truncate(struct inode *inode, unsigned long length)
{
        int error;
        struct iattr newattrs;

        down(&inode->i_sem);
        newattrs.ia_size = length;
        newattrs.ia_valid = ATTR_SIZE | ATTR_CTIME;
        error = notify_change(inode, &newattrs);
        if (!error) {
                /* truncate virtual mappings of this file */
                vmtruncate(inode, length);
                if (inode->i_op && inode->i_op->truncate)
                        inode->i_op->truncate(inode);
        }
        up(&inode->i_sem);
        return error;
}

asmlinkage int sys_truncate(const char * path, unsigned long length)
{
        struct inode * inode;
        int error;

        error = namei(path,&inode);
        if (error)
                return error;

        error = -EACCES;
        if (S_ISDIR(inode->i_mode))
                goto out;

        error = permission(inode,MAY_WRITE);
        if (error)
                goto out;

        error = -EROFS;
        if (IS_RDONLY(inode))
                goto out;

        error = -EPERM;
        if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
                goto out;

        error = get_write_access(inode);
        if (error)
                goto out;

        error = locks_verify_area(FLOCK_VERIFY_WRITE, inode, NULL,
                                  length < inode->i_size ? length : inode->i_size,
                                  abs(inode->i_size - length));
        if (!error) {
                if (inode->i_sb && inode->i_sb->dq_op)
                        inode->i_sb->dq_op->initialize(inode, -1);
                error = do_truncate(inode, length);
        }
        put_write_access(inode);
out:
        iput(inode);
        return error;
}

asmlinkage int sys_ftruncate(unsigned int fd, unsigned long length)
{
        struct inode * inode;
        struct file * file;
        int error;

        if (fd >= NR_OPEN || !(file = current->files->fd[fd]))
                return -EBADF;
        if (!(inode = file->f_inode))
                return -ENOENT;
        if (S_ISDIR(inode->i_mode) || !(file->f_mode & FMODE_WRITE))
                return -EACCES;
        if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
                return -EPERM;
        error = locks_verify_area(FLOCK_VERIFY_WRITE, inode, file,
                                  length < inode->i_size ? length : inode->i_size,
                                  abs(inode->i_size - length));
        if (!error)
                error = do_truncate(inode, length);
        return error;
}

#ifndef __alpha__

/*
 * sys_utime() can be implemented in user-level using sys_utimes().
 * Is this for backwards compatibility?  If so, why not move it
 * into the appropriate arch directory (for those architectures that
 * need it).
 */

/* If times==NULL, set access and modification to current time,
 * must be owner or have write permission.
 * Else, update from *times, must be owner or super user.
 */
asmlinkage int sys_utime(char * filename, struct utimbuf * times)
{
        int error;
        struct inode * inode;
        struct iattr newattrs;

        error = namei(filename,&inode);
        if (error)
                return error;
        if (IS_RDONLY(inode)) {
                iput(inode);
                return -EROFS;
        }
        /* Don't worry, the checks are done in inode_change_ok() */
        newattrs.ia_valid = ATTR_CTIME | ATTR_MTIME | ATTR_ATIME;
        if (times) {
                error = verify_area(VERIFY_READ, times, sizeof(*times));
                if (error) {
                        iput(inode);
                        return error;
                }
                newattrs.ia_atime = get_user(×->actime);
                newattrs.ia_mtime = get_user(×->modtime);
                newattrs.ia_valid |= ATTR_ATIME_SET | ATTR_MTIME_SET;
        } else {
                if (current->fsuid != inode->i_uid &&
                    (error = permission(inode,MAY_WRITE)) != 0) {
                        iput(inode);
                        return error;
                }
        }
        error = notify_change(inode, &newattrs);
        iput(inode);
        return error;
}

#endif

/* If times==NULL, set access and modification to current time,
 * must be owner or have write permission.
 * Else, update from *times, must be owner or super user.
 */
asmlinkage int sys_utimes(char * filename, struct timeval * utimes)
{
        int error;
        struct inode * inode;
        struct iattr newattrs;

        error = namei(filename,&inode);
        if (error)
                return error;
        if (IS_RDONLY(inode)) {
                iput(inode);
                return -EROFS;
        }
        /* Don't worry, the checks are done in inode_change_ok() */
        newattrs.ia_valid = ATTR_CTIME | ATTR_MTIME | ATTR_ATIME;
        if (utimes) {
                struct timeval times[2];
                error = verify_area(VERIFY_READ, utimes, sizeof(times));
                if (error) {
                        iput(inode);
                        return error;
                }
                memcpy_fromfs(×, utimes, sizeof(times));
                newattrs.ia_atime = times[0].tv_sec;
                newattrs.ia_mtime = times[1].tv_sec;
                newattrs.ia_valid |= ATTR_ATIME_SET | ATTR_MTIME_SET;
        } else {
                if ((error = permission(inode,MAY_WRITE)) != 0) {
                        iput(inode);
                        return error;
                }
        }
        error = notify_change(inode, &newattrs);
        iput(inode);
        return error;
}

/*
 * access() needs to use the real uid/gid, not the effective uid/gid.
 * We do this by temporarily setting fsuid/fsgid to the wanted values
 */
asmlinkage int sys_access(const char * filename, int mode)
{
        struct inode * inode;
        int old_fsuid, old_fsgid;
        int res;

        if (mode != (mode & S_IRWXO))   /* where's F_OK, X_OK, W_OK, R_OK? */
                return -EINVAL;
        old_fsuid = current->fsuid;
        old_fsgid = current->fsgid;
        current->fsuid = current->uid;
        current->fsgid = current->gid;
        res = namei(filename,&inode);
        if (!res) {
                res = permission(inode, mode);
                iput(inode);
        }
        current->fsuid = old_fsuid;
        current->fsgid = old_fsgid;
        return res;
}

asmlinkage int sys_chdir(const char * filename)
{
        struct inode * inode;
        int error;

        error = namei(filename,&inode);
        if (error)
                return error;
        if (!S_ISDIR(inode->i_mode)) {
                iput(inode);
                return -ENOTDIR;
        }
        if ((error = permission(inode,MAY_EXEC)) != 0) {
                iput(inode);
                return error;
        }
        iput(current->fs->pwd);
        current->fs->pwd = inode;
        return (0);
}

asmlinkage int sys_fchdir(unsigned int fd)
{
        struct inode * inode;
        struct file * file;
        int error;

        if (fd >= NR_OPEN || !(file = current->files->fd[fd]))
                return -EBADF;
        if (!(inode = file->f_inode))
                return -ENOENT;
        if (!S_ISDIR(inode->i_mode))
                return -ENOTDIR;
        if ((error = permission(inode,MAY_EXEC)) != 0)
                return error;
        iput(current->fs->pwd);
        current->fs->pwd = inode;
        inode->i_count++;
        return (0);
}

asmlinkage int sys_chroot(const char * filename)
{
        struct inode * inode;
        int error;

        error = namei(filename,&inode);
        if (error)
                return error;
        if (!S_ISDIR(inode->i_mode)) {
                iput(inode);
                return -ENOTDIR;

        }
        if (!fsuser()) {
                iput(inode);
                return -EPERM;
        }
        iput(current->fs->root);
        current->fs->root = inode;
        return (0);
}

asmlinkage int sys_fchmod(unsigned int fd, mode_t mode)
{
        struct inode * inode;
        struct file * file;
        struct iattr newattrs;

        if (fd >= NR_OPEN || !(file = current->files->fd[fd]))
                return -EBADF;
        if (!(inode = file->f_inode))
                return -ENOENT;
        if (IS_RDONLY(inode))
                return -EROFS;
        if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
                return -EPERM;
        if (mode == (mode_t) -1)
                mode = inode->i_mode;
        newattrs.ia_mode = (mode & S_IALLUGO) | (inode->i_mode & ~S_IALLUGO);
        newattrs.ia_valid = ATTR_MODE | ATTR_CTIME;
        inode->i_dirt = 1;
        return notify_change(inode, &newattrs);
}

asmlinkage int sys_chmod(const char * filename, mode_t mode)
{
        struct inode * inode;
        int error;
        struct iattr newattrs;

        error = namei(filename,&inode);
        if (error)
                return error;
        if (IS_RDONLY(inode)) {
                iput(inode);
                return -EROFS;
        }
        if (IS_IMMUTABLE(inode) || IS_APPEND(inode)) {
                iput(inode);
                return -EPERM;
        }
        if (mode == (mode_t) -1)
                mode = inode->i_mode;
        newattrs.ia_mode = (mode & S_IALLUGO) | (inode->i_mode & ~S_IALLUGO);
        newattrs.ia_valid = ATTR_MODE | ATTR_CTIME;
        inode->i_dirt = 1;
        error = notify_change(inode, &newattrs);
        iput(inode);
        return error;
}

asmlinkage int sys_fchown(unsigned int fd, uid_t user, gid_t group)
{
        struct inode * inode;
        struct file * file;
        struct iattr newattrs;
        int error;

        if (fd >= NR_OPEN || !(file = current->files->fd[fd]))
                return -EBADF;
        if (!(inode = file->f_inode))
                return -ENOENT;
        if (IS_RDONLY(inode))
                return -EROFS;
        if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
                return -EPERM;
        if (user == (uid_t) -1)
                user = inode->i_uid;
        if (group == (gid_t) -1)
                group = inode->i_gid;
        newattrs.ia_mode = inode->i_mode;
        newattrs.ia_uid = user;
        newattrs.ia_gid = group;
        newattrs.ia_valid =  ATTR_UID | ATTR_GID | ATTR_CTIME;
        /*
         * If the owner has been changed, remove the setuid bit
         */
        if (inode->i_mode & S_ISUID) {
                newattrs.ia_mode &= ~S_ISUID;
                newattrs.ia_valid |= ATTR_MODE;
        }
        /*
         * If the group has been changed, remove the setgid bit
         *
         * Don't remove the setgid bit if no group execute bit.
         * This is a file marked for mandatory locking.
         */
        if (((inode->i_mode & (S_ISGID | S_IXGRP)) == (S_ISGID | S_IXGRP))) {
                newattrs.ia_mode &= ~S_ISGID;
                newattrs.ia_valid |= ATTR_MODE;
        }
        inode->i_dirt = 1;
        if (inode->i_sb && inode->i_sb->dq_op) {
                inode->i_sb->dq_op->initialize(inode, -1);
                if (inode->i_sb->dq_op->transfer(inode, &newattrs, 0))
                        return -EDQUOT;
                error = notify_change(inode, &newattrs);
                if (error)
                        inode->i_sb->dq_op->transfer(inode, &newattrs, 1);
        } else
                error = notify_change(inode, &newattrs);
        return error;
}

asmlinkage int sys_chown(const char * filename, uid_t user, gid_t group)
{
        struct inode * inode;
        int error;
        struct iattr newattrs;

        error = lnamei(filename,&inode);
        if (error)
                return error;
        if (IS_RDONLY(inode)) {
                iput(inode);
                return -EROFS;
        }
        if (IS_IMMUTABLE(inode) || IS_APPEND(inode)) {
                iput(inode);
                return -EPERM;
        }
        if (user == (uid_t) -1)
                user = inode->i_uid;
        if (group == (gid_t) -1)
                group = inode->i_gid;
        newattrs.ia_mode = inode->i_mode;
        newattrs.ia_uid = user;
        newattrs.ia_gid = group;
        newattrs.ia_valid =  ATTR_UID | ATTR_GID | ATTR_CTIME;
        /*
         * If the owner has been changed, remove the setuid bit
         */
        if (inode->i_mode & S_ISUID) {
                newattrs.ia_mode &= ~S_ISUID;
                newattrs.ia_valid |= ATTR_MODE;
        }
        /*
         * If the group has been changed, remove the setgid bit
         *
         * Don't remove the setgid bit if no group execute bit.
         * This is a file marked for mandatory locking.
         */
        if (((inode->i_mode & (S_ISGID | S_IXGRP)) == (S_ISGID | S_IXGRP))) {
                newattrs.ia_mode &= ~S_ISGID;
                newattrs.ia_valid |= ATTR_MODE;
        }
        inode->i_dirt = 1;
        if (inode->i_sb->dq_op) {
                inode->i_sb->dq_op->initialize(inode, -1);
                if (inode->i_sb->dq_op->transfer(inode, &newattrs, 0))
                        return -EDQUOT;
                error = notify_change(inode, &newattrs);
                if (error)
                        inode->i_sb->dq_op->transfer(inode, &newattrs, 1);
        } else
                error = notify_change(inode, &newattrs);
        iput(inode);
        return(error);
}

/*
 * Note that while the flag value (low two bits) for sys_open means:
 *      00 - read-only
 *      01 - write-only
 *      10 - read-write
 *      11 - special
 * it is changed into
 *      00 - no permissions needed
 *      01 - read-permission
 *      10 - write-permission
 *      11 - read-write
 * for the internal routines (ie open_namei()/follow_link() etc). 00 is
 * used by symlinks.
 */
static int do_open(const char * filename,int flags,int mode, int fd)
/*otwiera plik i zwraca jego deskryptor*/
/*KOMENTOWAL: ADAM KIEZUN*/
{
        struct inode * inode;
        struct file * f;
        int flag,error;
        f = get_empty_filp(); /*znajdujemy wolne miejsce w tablicy plików*/
        if (!f)
                return -ENFILE;

       /*tlumaczenie jednych wartosci flag - uzywanych na zewnatrz na inne - uzywane
         wewnatrz jadra*/
        f->f_flags = flag = flags;
        f->f_mode = (flag+1) & O_ACCMODE;
        if (f->f_mode)
                flag++;
        if (flag & O_TRUNC)
                flag |= 2;

        error = open_namei(filename,flag,mode,&inode,NULL);
        if (error)
                goto cleanup_file;

        if (f->f_mode & FMODE_WRITE) { /*jesli chcemy pisac to nalezy uzyskac dostep
                                       do pisania*/
                error = get_write_access(inode);
                if (error)
                        goto cleanup_inode;
        }
        /*wypelnianie kolejnych pól w biezacej pozycji tablicy plików */
        f->f_inode = inode;  /*i-wezel pliku*/
        f->f_pos = 0;        /*pozycja w pliku*/
        f->f_reada = 0;      /*znacznik czytania z wyprzedzeniem*/
        f->f_op = NULL;      /*zestaw dozwolonych operacji - na razie ustawmy na NULL*/
        if (inode->i_op)     /*zestaw operacji dozwolonych na tym pliku - kopiujemy
                               z i-wezla pliku*/
                f->f_op = inode->i_op->default_file_ops;

        if (f->f_op && f->f_op->open) { /*jesli dla tego pliku jest zdefinowana specjalna
                                          funkcja open to jest teraz wykonywana*/
                error = f->f_op->open(inode,f);
                if (error)
                        goto cleanup_all;
        }

        f->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC);
        current->files->fd[fd] = f; /*wpisuje plik do tablicy deskryptorów*/
        return 0;
cleanup_all:/*jesli mamy pozwolenie na pisanie, bo wczesniej prosilismy to zrzekamy sie go*/
        if (f->f_mode & FMODE_WRITE)
                put_write_access(inode);

cleanup_inode: /*trzeba odlozyc pobrany i-wezel*/
        iput(inode);

cleanup_file:
        f->f_count--;
        return error;
}
/*
 * Znajduje nowy, wolny deskryptor i zaznacza wen, ze jest juz zajety
 * KOMENTOWAL: ADAM KIEZUN
 */
int get_unused_fd(void)
{
        int fd;
        struct files_struct * files = current->files;
        fd = find_first_zero_bit(&files->open_fds, NR_OPEN); /*pierwszy zerowy bit w bitmapie
                                                              oznacza najnizszy wolny deskryptor*/
        if (fd < current->rlim[RLIMIT_NOFILE].rlim_cur) {
                FD_SET(fd, &files->open_fds);          /*ustawiamy go*/
                FD_CLR(fd, &files->close_on_exec);
                return fd;
        }
        return -EMFILE;
}

/*
 * Zwalnia podany deskryptor
 * KOMENTOWAL: ADAM KIEZUN
 */
inline void put_unused_fd(int fd)
{
        FD_CLR(fd, &current->files->open_fds);
}
asmlinkage int sys_open(const char * filename,int flags,int mode)
/ * KOMENTOWAL: ADAM KIEZUN */
/*filename - nazwa pliku*/
/*flags    - sposób otwarcia pliku; zbiór flag, które moga byc niezaleznie 
             od siebie ustawiane*/
{
        char * tmp;
        int fd, error;
        fd = get_unused_fd();
        if (fd < 0)
                return fd;
        error = getname(filename, &tmp); /*kopiujemy nazwe do przestrzeni danych jadra
                                           by przyspieszyc */
        if (!error) {
                error = do_open(tmp,flags,mode, fd);
                putname(tmp); /*zwalniamy miejsce zajmowane przez nazwe w pamieci jadra*/
                if (!error)
                        return fd;
        }
        put_unused_fd(fd);
        return error;
}
#ifndef __alpha__
/*
 * Autorzy sugeruja, by umiescic te funkcje w asm/i386/arch, ale mimo to implementuja ja, by
 * zachowac zgodnosc z poprzednimi wersjami.
 * KOMENTOWAL: ADAM KIEZUN
 */
asmlinkage int sys_creat(const char * pathname, int mode)
{
        return sys_open(pathname, O_CREAT | O_WRONLY | O_TRUNC, mode);
}
#endif

void __fput(struct file *filp, struct inode *inode)
{
        if (filp->f_op && filp->f_op->release)
                filp->f_op->release(inode,filp);
    /* zwolnij pozycję w tablicy plików */
        filp->f_inode = NULL;
    /* jeśli zamykany plik był otwarty do pisania,
       to zmniejsz licznik piszących do pliku */
        if (filp->f_mode & FMODE_WRITE)
                put_write_access(inode);
    /* zwolnij i-węzeł z pamięci */
        iput(inode);
}

int close_fp(struct file *filp)
{
        struct inode *inode;

        if (filp->f_count == 0) {
                printk("VFS: Close: file count is 0\n");
                return 0;
        }
        inode = filp->f_inode;
        if (inode)
   /* zdejmij wszystkie blokady na pliku założone przez proces użytkownika */

                locks_remove_locks(current, filp);
        fput(filp, inode);
        return 0;
}

asmlinkage int sys_close(unsigned int fd)
/* fd - deskryptor zamykanego pliku */ 
{
        int error;
        struct file * filp;
        struct files_struct * files;
  /* zapamiętaj wskaźnik do tablicy plików, który zapisany jest w tablicy 
     deskryptorów na pozycji o indeksie równym wartości otrzymanego
     deskryptora */
        files = current->files;
        error = -EBADF;
        if (fd < NR_OPEN && (filp = files->fd[fd]) != NULL) {
                put_unused_fd(fd);
                FD_CLR(fd, &files->close_on_exec);
   /* zwolnij dany deskryptor */
                files->fd[fd] = NULL;
                error = close_fp(filp);
        }
        return error;
}

/*
 * This routine simulates a hangup on the tty, to arrange that users
 * are given clean terminals at login time.
 */
asmlinkage int sys_vhangup(void)
{
        if (!suser())
                return -EPERM;
        /* If there is a controlling tty, hang it up */
        if (current->tty)
                tty_vhangup(current->tty);
        return 0;
}