390 lines
9.5 KiB
C++
390 lines
9.5 KiB
C++
/* fhandler_procsysvipc.cc: fhandler for /proc/sysvipc virtual filesystem
|
|
|
|
This file is part of Cygwin.
|
|
|
|
This software is a copyrighted work licensed under the terms of the
|
|
Cygwin license. Please consult the file "CYGWIN_LICENSE" for
|
|
details. */
|
|
|
|
#include "winsup.h"
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <sys/cygwin.h>
|
|
#include "cygerrno.h"
|
|
#include "cygserver.h"
|
|
#include "security.h"
|
|
#include "path.h"
|
|
#include "fhandler.h"
|
|
#include "fhandler_virtual.h"
|
|
#include "pinfo.h"
|
|
#include "shared_info.h"
|
|
#include "dtable.h"
|
|
#include "cygheap.h"
|
|
#include "ntdll.h"
|
|
#include "cygtls.h"
|
|
#include "tls_pbuf.h"
|
|
#include <sys/param.h>
|
|
#include <ctype.h>
|
|
|
|
#define _COMPILING_NEWLIB
|
|
#include <dirent.h>
|
|
|
|
#define _KERNEL
|
|
#include <sys/ipc.h>
|
|
#include <sys/msg.h>
|
|
#include <sys/sem.h>
|
|
#include <sys/shm.h>
|
|
|
|
static off_t format_procsysvipc_msg (void *, char *&);
|
|
static off_t format_procsysvipc_sem (void *, char *&);
|
|
static off_t format_procsysvipc_shm (void *, char *&);
|
|
|
|
static const virt_tab_t procsysvipc_tab[] =
|
|
{
|
|
{ _VN ("."), FH_PROCSYSVIPC, virt_directory, NULL },
|
|
{ _VN (".."), FH_PROCSYSVIPC, virt_directory, NULL },
|
|
{ _VN ("msg"), FH_PROCSYSVIPC, virt_file, format_procsysvipc_msg },
|
|
{ _VN ("sem"), FH_PROCSYSVIPC, virt_file, format_procsysvipc_sem },
|
|
{ _VN ("shm"), FH_PROCSYSVIPC, virt_file, format_procsysvipc_shm },
|
|
{ NULL, 0, FH_NADA, virt_none, NULL }
|
|
};
|
|
|
|
static const int PROCSYSVIPC_LINK_COUNT =
|
|
(sizeof (procsysvipc_tab) / sizeof (virt_tab_t)) - 1;
|
|
|
|
virtual_ftype_t
|
|
fhandler_procsysvipc::exists ()
|
|
{
|
|
const char *path = get_name ();
|
|
debug_printf ("exists (%s)", path);
|
|
path += proc_len + 1;
|
|
while (*path != 0 && !isdirsep (*path))
|
|
path++;
|
|
if (*path == 0)
|
|
return virt_rootdir;
|
|
|
|
virt_tab_t *entry = virt_tab_search (path + 1, true, procsysvipc_tab,
|
|
PROCSYSVIPC_LINK_COUNT);
|
|
|
|
cygserver_init ();
|
|
|
|
if (entry)
|
|
{
|
|
if (entry->type == virt_file)
|
|
{
|
|
if (cygserver_running != CYGSERVER_OK)
|
|
return virt_none;
|
|
}
|
|
fileid = entry - procsysvipc_tab;
|
|
return entry->type;
|
|
}
|
|
return virt_none;
|
|
}
|
|
|
|
fhandler_procsysvipc::fhandler_procsysvipc ():
|
|
fhandler_proc ()
|
|
{
|
|
}
|
|
|
|
int __reg2
|
|
fhandler_procsysvipc::fstat (struct stat *buf)
|
|
{
|
|
fhandler_base::fstat (buf);
|
|
buf->st_mode &= ~_IFMT & NO_W;
|
|
int file_type = exists ();
|
|
switch (file_type)
|
|
{
|
|
case virt_none:
|
|
set_errno (ENOENT);
|
|
return -1;
|
|
case virt_directory:
|
|
case virt_rootdir:
|
|
buf->st_mode |= S_IFDIR | S_IXUSR | S_IXGRP | S_IXOTH;
|
|
buf->st_nlink = 2;
|
|
return 0;
|
|
case virt_file:
|
|
default:
|
|
buf->st_mode |= S_IFREG | S_IRUSR | S_IRGRP | S_IROTH;
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
int
|
|
fhandler_procsysvipc::readdir (DIR *dir, dirent *de)
|
|
{
|
|
int res = ENMFILE;
|
|
if (dir->__d_position >= PROCSYSVIPC_LINK_COUNT)
|
|
goto out;
|
|
{
|
|
cygserver_init ();
|
|
if (cygserver_running != CYGSERVER_OK)
|
|
goto out;
|
|
}
|
|
strcpy (de->d_name, procsysvipc_tab[dir->__d_position].name);
|
|
de->d_type = virt_ftype_to_dtype (procsysvipc_tab[dir->__d_position].type);
|
|
dir->__d_position++;
|
|
dir->__flags |= dirent_saw_dot | dirent_saw_dot_dot;
|
|
res = 0;
|
|
out:
|
|
syscall_printf ("%d = readdir(%p, %p) (%s)", res, dir, de, de->d_name);
|
|
return res;
|
|
}
|
|
|
|
int
|
|
fhandler_procsysvipc::open (int flags, mode_t mode)
|
|
{
|
|
int res = fhandler_virtual::open (flags, mode);
|
|
if (!res)
|
|
goto out;
|
|
|
|
nohandle (true);
|
|
|
|
const char *path;
|
|
path = get_name () + proc_len + 1;
|
|
pid = atoi (path);
|
|
while (*path != 0 && !isdirsep (*path))
|
|
path++;
|
|
|
|
if (*path == 0)
|
|
{
|
|
if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
|
|
{
|
|
set_errno (EEXIST);
|
|
res = 0;
|
|
goto out;
|
|
}
|
|
else if (flags & O_WRONLY)
|
|
{
|
|
set_errno (EISDIR);
|
|
res = 0;
|
|
goto out;
|
|
}
|
|
else
|
|
{
|
|
flags |= O_DIROPEN;
|
|
goto success;
|
|
}
|
|
}
|
|
|
|
virt_tab_t *entry;
|
|
entry = virt_tab_search (path + 1, true, procsysvipc_tab, PROCSYSVIPC_LINK_COUNT);
|
|
if (!entry)
|
|
{
|
|
set_errno ((flags & O_CREAT) ? EROFS : ENOENT);
|
|
res = 0;
|
|
goto out;
|
|
}
|
|
if (flags & O_WRONLY)
|
|
{
|
|
set_errno (EROFS);
|
|
res = 0;
|
|
goto out;
|
|
}
|
|
|
|
fileid = entry - procsysvipc_tab;
|
|
if (!fill_filebuf ())
|
|
{
|
|
res = 0;
|
|
goto out;
|
|
}
|
|
|
|
if (flags & O_APPEND)
|
|
position = filesize;
|
|
else
|
|
position = 0;
|
|
|
|
success:
|
|
res = 1;
|
|
set_flags ((flags & ~O_TEXT) | O_BINARY);
|
|
set_open_status ();
|
|
out:
|
|
syscall_printf ("%d = fhandler_proc::open(%p, 0%o)", res, flags, mode);
|
|
return res;
|
|
}
|
|
|
|
bool
|
|
fhandler_procsysvipc::fill_filebuf ()
|
|
{
|
|
if (procsysvipc_tab[fileid].format_func)
|
|
{
|
|
filesize = procsysvipc_tab[fileid].format_func (NULL, filebuf);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
#define MSG_HEADLINE " key msqid perms cbytes qnum lspid lrpid uid gid cuid cgid stime rtime ctime\n"
|
|
|
|
static off_t
|
|
format_procsysvipc_msg (void *, char *&destbuf)
|
|
{
|
|
char *buf;
|
|
struct msginfo msginfo;
|
|
struct msqid_ds *xmsqids;
|
|
|
|
msgctl (0, IPC_INFO, (struct msqid_ds *) &msginfo);
|
|
/* Don't use tmp_pathbuf. The required buffer sizes can be up to 128K! */
|
|
xmsqids = (struct msqid_ds *) malloc (sizeof (struct msqid_ds)
|
|
* msginfo.msgmni);
|
|
if (!xmsqids)
|
|
return 0;
|
|
/* buf size = sizeof headline + 128 bytes per msg queue entry. */
|
|
buf = (char *) malloc (sizeof (MSG_HEADLINE) + msginfo.msgmni * 128);
|
|
if (!buf)
|
|
{
|
|
free (xmsqids);
|
|
return 0;
|
|
}
|
|
|
|
char *bufptr = stpcpy (buf, MSG_HEADLINE);
|
|
msgctl (msginfo.msgmni, IPC_INFO, (struct msqid_ds *) xmsqids);
|
|
for (int i = 0; i < msginfo.msgmni; i++)
|
|
{
|
|
if (xmsqids[i].msg_qbytes != 0)
|
|
{
|
|
bufptr += sprintf (bufptr,
|
|
"%10llu %10u %5o %11u %10u %5d %5d %5u %5u %5u %5u "
|
|
"%10ld %10ld %10ld\n",
|
|
xmsqids[i].msg_perm.key,
|
|
IXSEQ_TO_IPCID(i, xmsqids[i].msg_perm),
|
|
xmsqids[i].msg_perm.mode,
|
|
xmsqids[i].msg_cbytes,
|
|
xmsqids[i].msg_qnum,
|
|
xmsqids[i].msg_lspid,
|
|
xmsqids[i].msg_lrpid,
|
|
(unsigned) xmsqids[i].msg_perm.uid,
|
|
(unsigned) xmsqids[i].msg_perm.gid,
|
|
(unsigned) xmsqids[i].msg_perm.cuid,
|
|
(unsigned) xmsqids[i].msg_perm.cgid,
|
|
xmsqids[i].msg_stime,
|
|
xmsqids[i].msg_rtime,
|
|
xmsqids[i].msg_ctime);
|
|
}
|
|
}
|
|
|
|
off_t size = bufptr - buf;
|
|
destbuf = (char *) crealloc_abort (destbuf, size);
|
|
memcpy (destbuf, buf, size);
|
|
free (buf);
|
|
free (xmsqids);
|
|
return size;
|
|
}
|
|
|
|
#undef MSG_HEADLINE
|
|
|
|
#define SEM_HEADLINE " key semid perms nsems uid gid cuid cgid otime ctime\n"
|
|
|
|
static off_t
|
|
format_procsysvipc_sem (void *, char *&destbuf)
|
|
{
|
|
char *buf;
|
|
union semun semun;
|
|
struct seminfo seminfo;
|
|
struct semid_ds *xsemids;
|
|
|
|
semun.buf = (struct semid_ds *) &seminfo;
|
|
semctl (0, 0, IPC_INFO, semun);
|
|
/* Don't use tmp_pathbuf. The required buffer sizes can be up to 96K! */
|
|
xsemids = (struct semid_ds *) malloc (sizeof (struct semid_ds)
|
|
* seminfo.semmni);
|
|
if (!xsemids)
|
|
return 0;
|
|
/* buf size = sizeof headline + 96 bytes per semaphore entry. */
|
|
buf = (char *) malloc (sizeof (SEM_HEADLINE) + seminfo.semmni * 96);
|
|
if (!buf)
|
|
{
|
|
free (xsemids);
|
|
return 0;
|
|
}
|
|
|
|
char *bufptr = stpcpy (buf, SEM_HEADLINE);
|
|
semun.buf = xsemids;
|
|
semctl (seminfo.semmni, 0, IPC_INFO, semun);
|
|
for (int i = 0; i < seminfo.semmni; i++)
|
|
{
|
|
if ((xsemids[i].sem_perm.mode & SEM_ALLOC) != 0)
|
|
{
|
|
bufptr += sprintf (bufptr,
|
|
"%10llu %10u %5o %10d %5u %5u %5u %5u %10ld %10ld\n",
|
|
xsemids[i].sem_perm.key,
|
|
IXSEQ_TO_IPCID(i, xsemids[i].sem_perm),
|
|
xsemids[i].sem_perm.mode,
|
|
xsemids[i].sem_nsems,
|
|
(unsigned) xsemids[i].sem_perm.uid,
|
|
(unsigned) xsemids[i].sem_perm.gid,
|
|
(unsigned) xsemids[i].sem_perm.cuid,
|
|
(unsigned) xsemids[i].sem_perm.cgid,
|
|
xsemids[i].sem_otime,
|
|
xsemids[i].sem_ctime);
|
|
}
|
|
}
|
|
|
|
off_t size = bufptr - buf;
|
|
destbuf = (char *) crealloc_abort (destbuf, size);
|
|
memcpy (destbuf, buf, size);
|
|
free (buf);
|
|
free (xsemids);
|
|
return size;
|
|
}
|
|
|
|
#undef SEM_HEADLINE
|
|
|
|
#define SHM_HEADLINE " key shmid perms size cpid lpid nattch uid gid cuid cgid atime dtime ctime\n"
|
|
|
|
static off_t
|
|
format_procsysvipc_shm (void *, char *&destbuf)
|
|
{
|
|
char *buf;
|
|
struct shminfo shminfo;
|
|
struct shmid_ds *xshmids;
|
|
|
|
shmctl (0, IPC_INFO, (struct shmid_ds *) &shminfo);
|
|
/* Don't use tmp_pathbuf. The required buffer sizes can be up to 120K! */
|
|
xshmids = (struct shmid_ds *) malloc (sizeof (struct shmid_ds)
|
|
* shminfo.shmmni);
|
|
if (!xshmids)
|
|
return 0;
|
|
/* buf size = sizeof headline + 120 bytes per shmem entry. */
|
|
buf = (char *) malloc (sizeof (SHM_HEADLINE) + shminfo.shmmni * 120);
|
|
if (!buf)
|
|
{
|
|
free (xshmids);
|
|
return 0;
|
|
}
|
|
|
|
char *bufptr = stpcpy (buf, SHM_HEADLINE);
|
|
shmctl (shminfo.shmmni, IPC_INFO, (struct shmid_ds *) xshmids);
|
|
for (int i = 0; i < shminfo.shmmni; i++)
|
|
{
|
|
if (xshmids[i].shm_perm.mode & 0x0800)
|
|
{
|
|
bufptr += sprintf (bufptr,
|
|
"%10llu %10u %5o %10u %5d %5d %6u %5u %5u %5u %5u "
|
|
"%10ld %10ld %10ld\n",
|
|
xshmids[i].shm_perm.key,
|
|
IXSEQ_TO_IPCID(i, xshmids[i].shm_perm),
|
|
xshmids[i].shm_perm.mode,
|
|
xshmids[i].shm_segsz,
|
|
xshmids[i].shm_cpid,
|
|
xshmids[i].shm_lpid,
|
|
xshmids[i].shm_nattch,
|
|
(unsigned) xshmids[i].shm_perm.uid,
|
|
(unsigned) xshmids[i].shm_perm.gid,
|
|
(unsigned) xshmids[i].shm_perm.cuid,
|
|
(unsigned) xshmids[i].shm_perm.cgid,
|
|
xshmids[i].shm_atime,
|
|
xshmids[i].shm_dtime,
|
|
xshmids[i].shm_ctime);
|
|
}
|
|
}
|
|
|
|
off_t size = bufptr - buf;
|
|
destbuf = (char *) crealloc_abort (destbuf, size);
|
|
memcpy (destbuf, buf, size);
|
|
free (buf);
|
|
free (xshmids);
|
|
return size;
|
|
}
|
|
|
|
#undef SHM_HEADLINE
|