void init() { check_owner(); if(this_player()==environment()) add_action("do_open", "open"); return ::init(); }
/*! \brief Check for user mapset permission \param mapset mapset name \return 1 mapset exists, and user has permission \return 0 mapset exists, BUT user denied permission \return -1 mapset does not exist */ int G__mapset_permissions(const char *mapset) { char path[GPATH_MAX]; struct stat info; G_file_name(path, "", "", mapset); if (G_stat(path, &info) != 0) return -1; if (!S_ISDIR(info.st_mode)) return -1; if (!check_owner(&info)) return 0; return 1; }
/*! \brief Check for user mapset permission \param gisdbase full path to GISDBASE \param location location name \param mapset mapset name \return 1 mapset exists, and user has permission \return 0 mapset exists, BUT user denied permission \return -1 mapset does not exist */ int G__mapset_permissions2(const char *gisdbase, const char *location, const char *mapset) { char path[GPATH_MAX]; struct stat info; sprintf(path, "%s/%s/%s", gisdbase, location, mapset); if (G_stat(path, &info) != 0) return -1; if (!S_ISDIR(info.st_mode)) return -1; if (!check_owner(&info)) return 0; return 1; }
/* * Regenerate the set of PID directories in the root directory of the file * system. Add new directories and delete old directories as appropriate; * leave unchanged those that should remain the same. */ static void construct_pid_dirs(void) { /* * We have to make two passes. Otherwise, we would trigger a vtreefs * assert when we add an entry for a PID before deleting the previous * entry for that PID. While rare, such rapid PID reuse does occur in * practice. */ struct inode *root, *node; struct inode_stat stat; char name[PNAME_MAX+1]; pid_t pid; int i; root = get_root_inode(); /* First pass: delete old entries. */ for (i = 0; i < NR_PROCS + NR_TASKS; i++) { /* Do we already have an inode associated with this slot? */ node = get_inode_by_index(root, i); if (node == NULL) continue; /* * If the process slot is not in use, delete the associated * inode. */ if (!slot_in_use(i)) { delete_inode(node); continue; } /* Otherwise, get the process ID. */ if (i < NR_TASKS) pid = (pid_t)(i - NR_TASKS); else pid = mproc[i - NR_TASKS].mp_pid; /* * If there is an old entry, see if the pid matches the current * entry, and the owner is still the same. Otherwise, delete * the old entry first. We reconstruct the entire subtree even * if only the owner changed, for security reasons: if a * process could keep open a file or directory across the owner * change, it might be able to access information it shouldn't. */ if (pid != (pid_t)get_inode_cbdata(node) || !check_owner(node, i)) delete_inode(node); } /* Second pass: add new entries. */ for (i = 0; i < NR_PROCS + NR_TASKS; i++) { /* If the process slot is not in use, skip this slot. */ if (!slot_in_use(i)) continue; /* * If we have an inode associated with this slot, we have * already checked it to be up-to-date above. */ if (get_inode_by_index(root, i) != NULL) continue; /* Get the process ID. */ if (i < NR_TASKS) pid = (pid_t)(i - NR_TASKS); else pid = mproc[i - NR_TASKS].mp_pid; /* Add the entry for the process slot. */ snprintf(name, PNAME_MAX + 1, "%d", pid); make_stat(&stat, i, NO_INDEX); node = add_inode(root, name, i, &stat, nr_pid_entries, (cbdata_t)pid); if (node == NULL) out_of_inodes(); } }
void __svgalib_open_devconsole(void) { struct vt_mode vtm; struct vt_stat vts; struct stat sbuf; char fname[30]; if(__svgalib_novccontrol) { return; } if (__svgalib_tty_fd >= 0) return; /* The code below assumes file descriptors 0, 1, and 2 * are already open; make sure that's true. */ if ((fcntl(0,F_GETFD) == -1) && (open("/dev/null", O_RDONLY) == -1)) { perror("/dev/null"); exit(1); } if ((fcntl(1,F_GETFD) == -1) && (open("/dev/null", O_WRONLY) == -1)) { perror("/dev/null"); exit(1); } if ((fcntl(2,F_GETFD) == -1) && (open("/dev/null", O_WRONLY) == -1)) { perror("/dev/null"); exit(1); } /* * Now, it would be great if we could use /dev/tty and see what it is connected to. * Alas, we cannot find out reliably what VC /dev/tty is bound to. Thus we parse * stdin through stderr for a reliable VC */ for (__svgalib_tty_fd = 0; __svgalib_tty_fd < 3; __svgalib_tty_fd++) { if (fstat(__svgalib_tty_fd, &sbuf) < 0) continue; if (ioctl(__svgalib_tty_fd, VT_GETMODE, &vtm) < 0) continue; if ((sbuf.st_rdev & 0xff00) != 0x400) continue; if (!(sbuf.st_rdev & 0xff)) continue; __svgalib_vc = sbuf.st_rdev & 0xff; return; /* perfect */ } if ((__svgalib_tty_fd = open("/dev/console", O_RDWR)) < 0) { fprintf(stderr,"svgalib: can't open /dev/console \n"); exit(1); } if (ioctl(__svgalib_tty_fd, VT_OPENQRY, &__svgalib_vc) < 0) goto error; if (__svgalib_vc <= 0) goto error; sprintf(fname, "/dev/tty%d", __svgalib_vc); close(__svgalib_tty_fd); /* change our control terminal: */ setpgid(0,getppid()); setsid(); /* We must use RDWR to allow for output... */ if (((__svgalib_tty_fd = open(fname, O_RDWR)) >= 0) && (ioctl(__svgalib_tty_fd, VT_GETSTATE, &vts) >= 0)) { if (!check_owner(vts.v_active)) { goto error; } /* success, redirect all stdios */ if (DREP) fprintf(stderr,"[svgalib: allocated virtual console #%d]\n", __svgalib_vc); fflush(stdin); fflush(stdout); fflush(stderr); close(0); close(1); close(2); dup(__svgalib_tty_fd); dup(__svgalib_tty_fd); dup(__svgalib_tty_fd); /* clear screen and switch to it */ fwrite("\e[H\e[J", 6, 1, stderr); fflush(stderr); if (__svgalib_vc != vts.v_active) { __svgalib_startup_vc = vts.v_active; ioctl(__svgalib_tty_fd, VT_ACTIVATE, __svgalib_vc); __svgalib_waitvtactive(); } } else {