/*
 *  linux/kernel/sys.c
 *
 *  (C) 1991  Linus Torvalds
 */

#include <errno.h>

#include <linux/sched.h>
#include <linux/tty.h>
#include <linux/kernel.h>
#include <asm/segment.h>
#include <sys/times.h>
#include <sys/utsname.h>

int sys_ftime()
{
	return -ENOSYS;
}

int sys_break()
{
	return -ENOSYS;
}

int sys_ptrace()
{
	return -ENOSYS;
}

int sys_stty()
{
	return -ENOSYS;
}

int sys_gtty()
{
	return -ENOSYS;
}

int sys_rename()
{
	return -ENOSYS;
}

int sys_prof()
{
	return -ENOSYS;
}

int sys_setregid(int rgid, int egid)
{
	if (rgid>0) {
		if ((current->gid == rgid) || 
		    suser())
			current->gid = rgid;
		else
			return(-EPERM);
	}
	if (egid>0) {
		if ((current->gid == egid) ||
		    (current->egid == egid) ||
		    suser()) {
			current->egid = egid;
			current->sgid = egid;
		} else
			return(-EPERM);
	}
	return 0;
}

int sys_setgid(int gid)
{
/*	return(sys_setregid(gid, gid)); */
	if (suser())
		current->gid = current->egid = current->sgid = gid;
	else if ((gid == current->gid) || (gid == current->sgid))
		current->egid = gid;
	else
		return -EPERM;
	return 0;
}

int sys_acct()
{
	return -ENOSYS;
}

int sys_phys()
{
	return -ENOSYS;
}

int sys_lock()
{
	return -ENOSYS;
}

int sys_mpx()
{
	return -ENOSYS;
}

int sys_ulimit()
{
	return -ENOSYS;
}

int sys_time(long * tloc)
{
	int i;

	i = CURRENT_TIME;
	if (tloc) {
		verify_area(tloc,4);
		put_fs_long(i,(unsigned long *)tloc);
	}
	return i;
}

/*
 * Unprivileged users may change the real user id to the effective uid
 * or vice versa.
 */
int sys_setreuid(int ruid, int euid)
{
	int old_ruid = current->uid;
	
	if (ruid>0) {
		if ((current->euid==ruid) ||
                    (old_ruid == ruid) ||
		    suser())
			current->uid = ruid;
		else
			return(-EPERM);
	}
	if (euid>0) {
		if ((old_ruid == euid) ||
                    (current->euid == euid) ||
		    suser()) {
			current->euid = euid;
			current->suid = euid;
		} else {
			current->uid = old_ruid;
			return(-EPERM);
		}
	}
	return 0;
}

int sys_setuid(int uid)
{
/*	return(sys_setreuid(uid, uid)); */
	if (suser())
		current->uid = current->euid = current->suid = uid;
	else if ((uid == current->uid) || (uid == current->suid))
		current->euid = uid;
	else
		return -EPERM;
	return(0);
}

int sys_stime(long * tptr)
{
	if (!suser())
		return -EPERM;
	startup_time = get_fs_long((unsigned long *)tptr) - jiffies/HZ;
	return 0;
}

int sys_times(struct tms * tbuf)
{
	if (tbuf) {
		verify_area(tbuf,sizeof *tbuf);
		put_fs_long(current->utime,(unsigned long *)&tbuf->tms_utime);
		put_fs_long(current->stime,(unsigned long *)&tbuf->tms_stime);
		put_fs_long(current->cutime,(unsigned long *)&tbuf->tms_cutime);
		put_fs_long(current->cstime,(unsigned long *)&tbuf->tms_cstime);
	}
	return jiffies;
}

int sys_brk(unsigned long end_data_seg)
{
	if (end_data_seg >= current->end_code &&
	    end_data_seg < current->start_stack - 16384)
		current->brk = end_data_seg;
	return current->brk;
}

/*
 * This needs some heave checking ...
 * I just haven't get the stomach for it. I also don't fully
 * understand sessions/pgrp etc. Let somebody who does explain it.
 */
int sys_setpgid(int pid, int pgid)
{
	int i;

	if (!pid)
		pid = current->pid;
	if (!pgid)
		pgid = current->pid;
	for (i=0 ; i<NR_TASKS ; i++)
		if (task[i] && task[i]->pid==pid) {
			if (task[i]->leader)
				return -EPERM;
			if (task[i]->session != current->session)
				return -EPERM;
			task[i]->pgrp = pgid;
			return 0;
		}
	return -ESRCH;
}

int sys_getpgrp(void)
{
	return current->pgrp;
}

int sys_setsid(void)
{
	if (current->leader && !suser())
		return -EPERM;
	current->leader = 1;
	current->session = current->pgrp = current->pid;
	current->tty = -1;
	return current->pgrp;
}

int sys_getgroups()
{
	return -ENOSYS;
}

int sys_setgroups()
{
	return -ENOSYS;
}

int sys_uname(struct utsname * name)
{
	static struct utsname thisname = {
		"linux .0","nodename","release ","version ","machine "
	};
	int i;

	if (!name) return -ERROR;
	verify_area(name,sizeof *name);
	for(i=0;i<sizeof *name;i++)
		put_fs_byte(((char *) &thisname)[i],i+(char *) name);
	return 0;
}

int sys_sethostname()
{
	return -ENOSYS;
}

int sys_getrlimit()
{
	return -ENOSYS;
}

int sys_setrlimit()
{
	return -ENOSYS;
}

int sys_getrusage()
{
	return -ENOSYS;
}

int sys_gettimeofday()
{
	return -ENOSYS;
}

int sys_settimeofday()
{
	return -ENOSYS;
}


int sys_umask(int mask)
{
	int old = current->umask;

	current->umask = mask & 0777;
	return (old);
}

//getdents
struct linux_dirent {
	long           d_ino;
	off_t          d_off;
	unsigned short d_reclen;
	char        d_name[14];
};
/*int sys_getdents(unsigned int fd, struct linux_dirent * dirp, unsigned int count)
{
	struct buffer_head *  bh;
	struct dir_entry * de;
	struct dir_entry * tmp1;
	struct dir_entry * tmp2;
	unsigned long bmp = 0;
	int i;
	bh = bread(current->filp[fd]->f_inode->i_dev,current->filp[fd]->f_inode->i_zone[0]);
	for(tmp1 = tmp2 = bh->b_data; (tmp1 - tmp2)*24 <= count-24 && tmp1->inode ; tmp1++)
	{
		de = tmp1;
		printk("%d\n",de->inode);
		put_fs_long( de->inode,(unsigned long *)& (dirp+bmp)->d_ino); 
		for(i = 0; i < 14; i++)
			put_fs_byte(de->name[i] , (char *)& (dirp+bmp)->d_name[i]);
		put_fs_word( 24,(unsigned short *)& dirp->d_reclen);
		
		printk("%d\n",get_fs_word((unsigned short *)&(dirp+bmp)->d_ino));
		put_fs_long( 24,(unsigned long *)& dirp->d_off);
		bmp ++;
		printk("%d\n",bmp);
	}
	
	return bmp*24;
	
}*/
int sys_getdents(unsigned int fd, struct linux_dirent *dir_rt, unsigned int count)
{
    int i;
    int size;
    int width;
    int count_n;
    struct file *f;
    struct m_inode *inode;
    struct buffer_head *b_h;
    struct dir_entry *d_e;
    struct linux_dirent tmp;
    
    f = current->filp[fd];
    inode = f->f_inode;
    width = sizeof(struct linux_dirent);
    b_h = bread(inode->i_dev,inode->i_zone[0]);
    d_e = (struct dir_entry*) b_h->b_data;

    for(count_n = 0,size = 0; d_e[count_n].inode>0; count_n++){
        if(size+width>count)
            return 0;
        tmp.d_reclen = width;
        tmp.d_off = width;
        tmp.d_ino = d_e[count_n].inode;
        for(i = 0 ;i<NAME_LEN ;i++)
        {
            tmp.d_name[i] = d_e[count_n].name[i];
        }
        char * ptr;
        ptr = &tmp;
        for(i = 0 ;i<width ;i++)
        {
            put_fs_byte(*(ptr+i),(char*)dir_rt+size);
            size++;
        }
    }
    return size;
}
  
//getdents

//sys_sleep
void handler(int signo)
{}
unsigned int sys_sleep(unsigned int sec)
{
	   /*struct sigaction action,oldaction;
	   sigset_t newmask,oldmask,suspmask;
	   action.sa_handler = handler;
	   action.sa_flags = 0;
	   sigemptyset(&action.sa_mask);
	   sys_sigaction(SIGALRM,&action,&oldaction);

	   sigemptyset(&newmask);
	   sigaddset(&newmask,SIGALRM);
	   sigprocmask(SIG_BLOCK,&newmask,&oldmask);

	   alarm(sec);
	   suspmask = oldmask;
	   sigdelset(&suspmask,SIGALRM);
	   sigsuspend(&suspmask);

	   int ret = alarm(0);
	   sys_sigaction(SIGALRM,&oldaction,NULL);
	   sigprocmask(SIG_SETMASK,&oldmask,NULL);
	   return ret;*/
	   sys_signal(SIGALRM,SIG_IGN,NULL);
	   sys_alarm(sec);
	   sys_pause();
	   int ret = sys_alarm(0);
	   return ret;
}