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 {
