/********************************************************************** * Copyright (c) Digital Equipment Corporation 1984, 1985, 1986. * * All Rights Reserved. * * Reference "/usr/src/COPYRIGHT" for applicable restrictions. * **********************************************************************/ /* * SCCSID: @(#)fio.c 3.0 4/21/86 */ #include <sys/param.h> #include <sys/systm.h> #include <sys/dir.h> #include <sys/user.h> #include <sys/filsys.h> #include <sys/file.h> #include <sys/conf.h> #include <sys/inode.h> #include <sys/reg.h> #include <sys/acct.h> #include <sys/seg.h> /* * Convert a user supplied * file descriptor into a pointer * to a file structure. * Only task is to check range * of the descriptor. */ struct file * getf(f) register int f; { register struct file *fp; if(0 <= f && f < NOFILE) { fp = u.u_ofile[f]; if(fp != NULL) return(fp); } u.u_error = EBADF; return(NULL); } /* * Internal form of close. * Decrement reference count on * file structure. * Also make sure the pipe protocol * does not constipate. * * Decrement reference count on the inode following * removal to the referencing file structure. * Call device handler on last close. */ #ifdef UCB_NET closef(fp, nouser) #else UCB_NET closef(fp) #endif UCB_NET register struct file *fp; { register struct inode *ip; int flag, fmt; dev_t dev; register int (*cfunc)(); if(fp == NULL) return; cleanlocks(fp); /* clean any file locks */ if (fp->f_count > 1) { fp->f_count--; return; } ip = fp->f_inode; flag = fp->f_flag; #ifdef UCB_NET if (flag & FSOCKET) { u.u_error = 0; soclose(fp->f_socket, nouser); if (nouser == 0 && u.u_error) return; fp->f_socket = 0; fp->f_count = 0; u.u_error = 0; return; } #endif UCB_NET dev = (dev_t)ip->i_rdev; fmt = (ip->i_mode&IFMT); plock(ip); fp->f_count = 0; switch(fmt) { case IFCHR: cfunc = cdevsw[major(dev)].d_close; break; case IFBLK: cfunc = bdevsw[major(dev)].d_close; break; case IFIFO: closep(ip, flag); /* case falls thru to iput and return */ default: iput(ip); return; } for(fp=file; fp < &file[nfile]; fp++) { #ifdef UCB_NET if (fp->f_flag & FSOCKET) continue; #endif UCB_NET if (fp->f_count && fp->f_inode==ip) goto out; } (*cfunc)(dev, flag, NULL); out: iput(ip); } /* * openi called to allow handler * of special files to initialize and * validate before actual IO. */ openi(ip, rw) register struct inode *ip; { dev_t dev; register unsigned int maj; dev = (dev_t)ip->i_rdev; maj = major(dev); switch(ip->i_mode&IFMT) { case IFCHR: if(maj >= nchrdev) goto bad; (*cdevsw[maj].d_open)(dev, rw); break; case IFBLK: if(maj >= nblkdev) goto bad; (*bdevsw[maj].d_open)(dev, rw); break; case IFIFO: openp(ip,rw); break; } return; bad: u.u_error = ENXIO; } /* * Check mode permission on inode pointer. * Mode is READ, WRITE or EXEC. * In the case of WRITE, the * read-only status of the file * system is checked. * Also in WRITE, prototype text * segments cannot be written. * The mode is shifted to select * the owner/group/other fields. * The super user is granted all * permissions. */ access(ip, mode) register struct inode *ip; register mode; { register struct filsys *fp; if(mode == IWRITE) { if ((fp = getfs(ip->i_dev)) == NULL) { u.u_error = ENOENT; return(1); } else if (fp->s_ronly != 0) { normalseg5(); u.u_error = EROFS; return(1); } normalseg5(); if (ip->i_flag&ITEXT) /* try to free text */ xrele(ip); if(ip->i_flag & ITEXT) { u.u_error = ETXTBSY; return(1); } } if(u.u_uid == 0) return(0); if(u.u_uid != ip->i_uid) { mode >>= 3; if(u.u_gid != ip->i_gid) mode >>= 3; } if((ip->i_mode&mode) != 0) return(0); u.u_error = EACCES; return(1); } /* * Look up a pathname and test if * the resultant inode is owned by the * current user. * If not, try for super-user. * If permission is granted, * return inode pointer. */ struct inode * #ifdef UCB_SYMLINKS owner(follow) int follow; #else UCB_SYMLINKS owner() #endif UCB_SYMLINKS { register struct inode *ip; #ifdef UCB_SYMLINKS ip = namei(uchar, LOOKUP, follow); #else UCB_SYMLINKS ip = namei(uchar, LOOKUP); #endif UCB_SYMLINKS if(ip == NULL) return(NULL); if(u.u_uid == ip->i_uid) return(ip); if(suser()) return(ip); iput(ip); return(NULL); } /* * Test if the current user is the * super user. */ suser() { if(u.u_uid == 0) { u.u_acflag |= ASU; return(1); } u.u_error = EPERM; return(0); } /* * Allocate a user file descriptor. * modified to provide for sysIII/V fcntl dup call - Ohms 2/11/85 */ ufalloc(i) register i; { for(; i<NOFILE; i++) if(u.u_ofile[i] == NULL) { u.u_rval1 = i; u.u_pofile[i] = 0; return(i); } u.u_error = EMFILE; return(-1); } /* * Allocate a user file descriptor * and a file structure. * Initialize the descriptor * to point at the file structure. * * no file -- if there are no available * file structures. */ struct file * falloc() { register struct file *fp; register i; i = ufalloc(0); if(i < 0) return(NULL); for(fp = &file[0]; fp < &file[nfile]; fp++) if(fp->f_count == 0) { u.u_ofile[i] = fp; fp->f_count++; fp->f_un.f_offset = 0; return(fp); } printf("no file\n"); u.u_error = ENFILE; return(NULL); }