[thirdparty/glibc.git] / sysdeps / unix / sysv / linux / msgctl.c

/* Copyright (C) 1995-2025 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, see
   <https://www.gnu.org/licenses/>.  */

#include <sys/msg.h>
#include <ipc_priv.h>
#include <sysdep.h>
#include <shlib-compat.h>
#include <errno.h>
#include <linux/posix_types.h>  /* For __kernel_mode_t.  */

/* POSIX states ipc_perm mode should have type of mode_t.  */
_Static_assert (sizeof ((struct msqid_ds){0}.msg_perm.mode)
		== sizeof (mode_t),
		"sizeof (msqid_ds.msg_perm.mode) != sizeof (mode_t)");

#if __IPC_TIME64 == 0
typedef struct msqid_ds msgctl_arg_t;
#else
# include <struct_kernel_msqid64_ds.h>

static void
msqid64_to_kmsqid64 (const struct __msqid64_ds *msqid64,
		     struct kernel_msqid64_ds *kmsqid)
{
  kmsqid->msg_perm       = msqid64->msg_perm;
  kmsqid->msg_stime      = msqid64->msg_stime;
  kmsqid->msg_stime_high = msqid64->msg_stime >> 32;
  kmsqid->msg_rtime      = msqid64->msg_rtime;
  kmsqid->msg_rtime_high = msqid64->msg_rtime >> 32;
  kmsqid->msg_ctime      = msqid64->msg_ctime;
  kmsqid->msg_ctime_high = msqid64->msg_ctime >> 32;
  kmsqid->msg_cbytes     = msqid64->msg_cbytes;
  kmsqid->msg_qnum       = msqid64->msg_qnum;
  kmsqid->msg_qbytes     = msqid64->msg_qbytes;
  kmsqid->msg_lspid      = msqid64->msg_lspid;
  kmsqid->msg_lrpid      = msqid64->msg_lrpid;
}

static void
kmsqid64_to_msqid64 (const struct kernel_msqid64_ds *kmsqid,
		     struct __msqid64_ds *msqid64)
{
  msqid64->msg_perm   = kmsqid->msg_perm;
  msqid64->msg_stime  = kmsqid->msg_stime
		        | ((__time64_t) kmsqid->msg_stime_high << 32);
  msqid64->msg_rtime  = kmsqid->msg_rtime
		        | ((__time64_t) kmsqid->msg_rtime_high << 32);
  msqid64->msg_ctime  = kmsqid->msg_ctime
		        | ((__time64_t) kmsqid->msg_ctime_high << 32);
  msqid64->msg_cbytes = kmsqid->msg_cbytes;
  msqid64->msg_qnum   = kmsqid->msg_qnum;
  msqid64->msg_qbytes = kmsqid->msg_qbytes;
  msqid64->msg_lspid  = kmsqid->msg_lspid;
  msqid64->msg_lrpid  = kmsqid->msg_lrpid;
}

typedef struct kernel_msqid64_ds msgctl_arg_t;
#endif

static int
msgctl_syscall (int msqid, int cmd, msgctl_arg_t *buf)
{
#ifdef __ASSUME_DIRECT_SYSVIPC_SYSCALLS
  return INLINE_SYSCALL_CALL (msgctl, msqid, cmd | __IPC_64, buf);
#else
  return INLINE_SYSCALL_CALL (ipc, IPCOP_msgctl, msqid, cmd | __IPC_64, 0,
			      buf);
#endif
}

int
__msgctl64 (int msqid, int cmd, struct __msqid64_ds *buf)
{
#if IPC_CTL_NEED_TRANSLATION
# if __IPC_TIME64
  struct kernel_msqid64_ds ksemid, *arg = NULL;
# else
  msgctl_arg_t *arg;
# endif

  /* Some applications pass the __IPC_64 flag in cmd, to invoke
     previously unsupported commands back when there was no EINVAL
     error checking in glibc.  Mask the flag for the switch statements
     below.  msgctl_syscall adds back the __IPC_64 flag for the actual
     system call.  */
  cmd &= ~__IPC_64;

  switch (cmd)
    {
    case IPC_RMID:
      arg = NULL;
      break;

    case IPC_SET:
    case IPC_STAT:
    case MSG_STAT:
    case MSG_STAT_ANY:
# if __IPC_TIME64
      if (buf != NULL)
	{
	  msqid64_to_kmsqid64 (buf, &ksemid);
	  arg = &ksemid;
	}
#  ifdef __ASSUME_SYSVIPC_BROKEN_MODE_T
      if (cmd == IPC_SET)
	arg->msg_perm.mode *= 0x10000U;
#  endif
# else
      arg = buf;
# endif
      break;

    case IPC_INFO:
    case MSG_INFO:
      /* This is a Linux extension where kernel returns a 'struct msginfo'
	 instead.  */
      arg = (__typeof__ (arg)) buf;
      break;

    default:
      __set_errno (EINVAL);
      return -1;
    }

  int ret = msgctl_syscall (msqid, cmd, arg);
  if (ret < 0)
    return ret;

  switch (cmd)
    {
    case IPC_STAT:
    case MSG_STAT:
    case MSG_STAT_ANY:
# ifdef __ASSUME_SYSVIPC_BROKEN_MODE_T
      arg->msg_perm.mode >>= 16;
# else
      /* Old Linux kernel versions might not clear the mode padding.  */
      if (sizeof ((struct msqid_ds){0}.msg_perm.mode)
          != sizeof (__kernel_mode_t))
	arg->msg_perm.mode &= 0xFFFF;
# endif

# if __IPC_TIME64
      kmsqid64_to_msqid64 (arg, buf);
# endif
    }

  return ret;

#else /* !IPC_CTL_NEED_TRANSLATION */
  return msgctl_syscall (msqid, cmd, buf);
#endif
}
#if __TIMESIZE != 64
libc_hidden_def (__msgctl64)

static void
msqid_to_msqid64 (struct __msqid64_ds *mq64, const struct msqid_ds *mq)
{
  mq64->msg_perm   = mq->msg_perm;
  mq64->msg_stime  = mq->msg_stime
		     | ((__time64_t) mq->__msg_stime_high << 32);
  mq64->msg_rtime  = mq->msg_rtime
		     | ((__time64_t) mq->__msg_rtime_high << 32);
  mq64->msg_ctime  = mq->msg_ctime
		     | ((__time64_t) mq->__msg_ctime_high << 32);
  mq64->msg_cbytes = mq->msg_cbytes;
  mq64->msg_qnum   = mq->msg_qnum;
  mq64->msg_qbytes = mq->msg_qbytes;
  mq64->msg_lspid  = mq->msg_lspid;
  mq64->msg_lrpid  = mq->msg_lrpid;
}

static void
msqid64_to_msqid (struct msqid_ds *mq, const struct __msqid64_ds *mq64)
{
  mq->msg_perm         = mq64->msg_perm;
  mq->msg_stime        = mq64->msg_stime;
  mq->__msg_stime_high = 0;
  mq->msg_rtime        = mq64->msg_rtime;
  mq->__msg_rtime_high = 0;
  mq->msg_ctime        = mq64->msg_ctime;
  mq->__msg_ctime_high = 0;
  mq->msg_cbytes       = mq64->msg_cbytes;
  mq->msg_qnum         = mq64->msg_qnum;
  mq->msg_qbytes       = mq64->msg_qbytes;
  mq->msg_lspid        = mq64->msg_lspid;
  mq->msg_lrpid        = mq64->msg_lrpid;
}

int
__msgctl (int msqid, int cmd, struct msqid_ds *buf)
{
  struct __msqid64_ds msqid64, *buf64 = NULL;
  if (buf != NULL)
    {
      /* This is a Linux extension where kernel returns a 'struct msginfo'
	 instead.  */
      if (cmd == IPC_INFO || cmd == MSG_INFO)
	buf64 = (struct __msqid64_ds *) buf;
      else
	{
	  msqid_to_msqid64 (&msqid64, buf);
	  buf64 = &msqid64;
	}
    }

  int ret = __msgctl64 (msqid, cmd, buf64);
  if (ret < 0)
    return ret;

  switch (cmd)
    {
    case IPC_STAT:
    case MSG_STAT:
    case MSG_STAT_ANY:
      msqid64_to_msqid (buf, buf64);
    }

  return ret;
}
#endif

#ifndef DEFAULT_VERSION
# ifndef __ASSUME_SYSVIPC_BROKEN_MODE_T
#  define DEFAULT_VERSION GLIBC_2_2
# else
#  define DEFAULT_VERSION GLIBC_2_31
# endif
#endif
versioned_symbol (libc, __msgctl, msgctl, DEFAULT_VERSION);

#if defined __ASSUME_SYSVIPC_BROKEN_MODE_T \
    && SHLIB_COMPAT (libc, GLIBC_2_2, GLIBC_2_31)
int
attribute_compat_text_section
__msgctl_mode16 (int msqid, int cmd, struct msqid_ds *buf)
{
  return msgctl_syscall (msqid, cmd, (msgctl_arg_t *) buf);
}
compat_symbol (libc, __msgctl_mode16, msgctl, GLIBC_2_2);
#endif

#if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_2)
struct __old_msqid_ds
{
  struct __old_ipc_perm msg_perm;	/* structure describing operation permission */
  struct msg *__msg_first;		/* pointer to first message on queue */
  struct msg *__msg_last;		/* pointer to last message on queue */
  __time_t msg_stime;			/* time of last msgsnd command */
  __time_t msg_rtime;			/* time of last msgrcv command */
  __time_t msg_ctime;			/* time of last change */
  struct wait_queue *__wwait;		/* ??? */
  struct wait_queue *__rwait;		/* ??? */
  unsigned short int __msg_cbytes;	/* current number of bytes on queue */
  unsigned short int msg_qnum;		/* number of messages currently on queue */
  unsigned short int msg_qbytes;	/* max number of bytes allowed on queue */
  __ipc_pid_t msg_lspid;		/* pid of last msgsnd() */
  __ipc_pid_t msg_lrpid;		/* pid of last msgrcv() */
};

int
attribute_compat_text_section
__old_msgctl (int msqid, int cmd, struct __old_msqid_ds *buf)
{
#if defined __ASSUME_DIRECT_SYSVIPC_SYSCALLS \
    && !defined __ASSUME_SYSVIPC_DEFAULT_IPC_64
  /* For architecture that have wire-up msgctl but also have __IPC_64 to a
     value different than default (0x0) it means the compat symbol used the
     __NR_ipc syscall.  */
  return INLINE_SYSCALL_CALL (msgctl, msqid, cmd, buf);
#else
  return INLINE_SYSCALL_CALL (ipc, IPCOP_msgctl, msqid, cmd, 0, buf);
#endif
}
compat_symbol (libc, __old_msgctl, msgctl, GLIBC_2_0);
#endif
Commit	Line	Data
	1	/* Copyright (C) 1995-2025 Free Software Foundation, Inc.
	2	This file is part of the GNU C Library.
	3
	4	The GNU C Library is free software; you can redistribute it and/or
	5	modify it under the terms of the GNU Lesser General Public
	6	License as published by the Free Software Foundation; either
	7	version 2.1 of the License, or (at your option) any later version.
	8
	9	The GNU C Library is distributed in the hope that it will be useful,
	10	but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	12	Lesser General Public License for more details.
	13
	14	You should have received a copy of the GNU Lesser General Public
	15	License along with the GNU C Library; if not, see
	16	<https://www.gnu.org/licenses/>. */
	17
	18	#include <sys/msg.h>
	19	#include <ipc_priv.h>
	20	#include <sysdep.h>
	21	#include <shlib-compat.h>
	22	#include <errno.h>
	23	#include <linux/posix_types.h> /* For __kernel_mode_t. */
	24
	25	/* POSIX states ipc_perm mode should have type of mode_t. */
	26	_Static_assert (sizeof ((struct msqid_ds){0}.msg_perm.mode)
	27	== sizeof (mode_t),
	28	"sizeof (msqid_ds.msg_perm.mode) != sizeof (mode_t)");
	29
	30	#if __IPC_TIME64 == 0
	31	typedef struct msqid_ds msgctl_arg_t;
	32	#else
	33	# include <struct_kernel_msqid64_ds.h>
	34
	35	static void
	36	msqid64_to_kmsqid64 (const struct __msqid64_ds *msqid64,
	37	struct kernel_msqid64_ds *kmsqid)
	38	{
	39	kmsqid->msg_perm = msqid64->msg_perm;
	40	kmsqid->msg_stime = msqid64->msg_stime;
	41	kmsqid->msg_stime_high = msqid64->msg_stime >> 32;
	42	kmsqid->msg_rtime = msqid64->msg_rtime;
	43	kmsqid->msg_rtime_high = msqid64->msg_rtime >> 32;
	44	kmsqid->msg_ctime = msqid64->msg_ctime;
	45	kmsqid->msg_ctime_high = msqid64->msg_ctime >> 32;
	46	kmsqid->msg_cbytes = msqid64->msg_cbytes;
	47	kmsqid->msg_qnum = msqid64->msg_qnum;
	48	kmsqid->msg_qbytes = msqid64->msg_qbytes;
	49	kmsqid->msg_lspid = msqid64->msg_lspid;
	50	kmsqid->msg_lrpid = msqid64->msg_lrpid;
	51	}
	52
	53	static void
	54	kmsqid64_to_msqid64 (const struct kernel_msqid64_ds *kmsqid,
	55	struct __msqid64_ds *msqid64)
	56	{
	57	msqid64->msg_perm = kmsqid->msg_perm;
	58	msqid64->msg_stime = kmsqid->msg_stime
	59	\| ((__time64_t) kmsqid->msg_stime_high << 32);
	60	msqid64->msg_rtime = kmsqid->msg_rtime
	61	\| ((__time64_t) kmsqid->msg_rtime_high << 32);
	62	msqid64->msg_ctime = kmsqid->msg_ctime
	63	\| ((__time64_t) kmsqid->msg_ctime_high << 32);
	64	msqid64->msg_cbytes = kmsqid->msg_cbytes;
	65	msqid64->msg_qnum = kmsqid->msg_qnum;
	66	msqid64->msg_qbytes = kmsqid->msg_qbytes;
	67	msqid64->msg_lspid = kmsqid->msg_lspid;
	68	msqid64->msg_lrpid = kmsqid->msg_lrpid;
	69	}
	70
	71	typedef struct kernel_msqid64_ds msgctl_arg_t;
	72	#endif
	73
	74	static int
	75	msgctl_syscall (int msqid, int cmd, msgctl_arg_t *buf)
	76	{
	77	#ifdef __ASSUME_DIRECT_SYSVIPC_SYSCALLS
	78	return INLINE_SYSCALL_CALL (msgctl, msqid, cmd \| __IPC_64, buf);
	79	#else
	80	return INLINE_SYSCALL_CALL (ipc, IPCOP_msgctl, msqid, cmd \| __IPC_64, 0,
	81	buf);
	82	#endif
	83	}
	84
	85	int
	86	__msgctl64 (int msqid, int cmd, struct __msqid64_ds *buf)
	87	{
	88	#if IPC_CTL_NEED_TRANSLATION
	89	# if __IPC_TIME64
	90	struct kernel_msqid64_ds ksemid, *arg = NULL;
	91	# else
	92	msgctl_arg_t *arg;
	93	# endif
	94
	95	/* Some applications pass the __IPC_64 flag in cmd, to invoke
	96	previously unsupported commands back when there was no EINVAL
	97	error checking in glibc. Mask the flag for the switch statements
	98	below. msgctl_syscall adds back the __IPC_64 flag for the actual
	99	system call. */
	100	cmd &= ~__IPC_64;
	101
	102	switch (cmd)
	103	{
	104	case IPC_RMID:
	105	arg = NULL;
	106	break;
	107
	108	case IPC_SET:
	109	case IPC_STAT:
	110	case MSG_STAT:
	111	case MSG_STAT_ANY:
	112	# if __IPC_TIME64
	113	if (buf != NULL)
	114	{
	115	msqid64_to_kmsqid64 (buf, &ksemid);
	116	arg = &ksemid;
	117	}
	118	# ifdef __ASSUME_SYSVIPC_BROKEN_MODE_T
	119	if (cmd == IPC_SET)
	120	arg->msg_perm.mode *= 0x10000U;
	121	# endif
	122	# else
	123	arg = buf;
	124	# endif
	125	break;
	126
	127	case IPC_INFO:
	128	case MSG_INFO:
	129	/* This is a Linux extension where kernel returns a 'struct msginfo'
	130	instead. */
	131	arg = (__typeof__ (arg)) buf;
	132	break;
	133
	134	default:
	135	__set_errno (EINVAL);
	136	return -1;
	137	}
	138
	139	int ret = msgctl_syscall (msqid, cmd, arg);
	140	if (ret < 0)
	141	return ret;
	142
	143	switch (cmd)
	144	{
	145	case IPC_STAT:
	146	case MSG_STAT:
	147	case MSG_STAT_ANY:
	148	# ifdef __ASSUME_SYSVIPC_BROKEN_MODE_T
	149	arg->msg_perm.mode >>= 16;
	150	# else
	151	/* Old Linux kernel versions might not clear the mode padding. */
	152	if (sizeof ((struct msqid_ds){0}.msg_perm.mode)
	153	!= sizeof (__kernel_mode_t))
	154	arg->msg_perm.mode &= 0xFFFF;
	155	# endif
	156
	157	# if __IPC_TIME64
	158	kmsqid64_to_msqid64 (arg, buf);
	159	# endif
	160	}
	161
	162	return ret;
	163
	164	#else /* !IPC_CTL_NEED_TRANSLATION */
	165	return msgctl_syscall (msqid, cmd, buf);
	166	#endif
	167	}
	168	#if __TIMESIZE != 64
	169	libc_hidden_def (__msgctl64)
	170
	171	static void
	172	msqid_to_msqid64 (struct __msqid64_ds mq64, const struct msqid_ds mq)
	173	{
	174	mq64->msg_perm = mq->msg_perm;
	175	mq64->msg_stime = mq->msg_stime
	176	\| ((__time64_t) mq->__msg_stime_high << 32);
	177	mq64->msg_rtime = mq->msg_rtime
	178	\| ((__time64_t) mq->__msg_rtime_high << 32);
	179	mq64->msg_ctime = mq->msg_ctime
	180	\| ((__time64_t) mq->__msg_ctime_high << 32);
	181	mq64->msg_cbytes = mq->msg_cbytes;
	182	mq64->msg_qnum = mq->msg_qnum;
	183	mq64->msg_qbytes = mq->msg_qbytes;
	184	mq64->msg_lspid = mq->msg_lspid;
	185	mq64->msg_lrpid = mq->msg_lrpid;
	186	}
	187
	188	static void
	189	msqid64_to_msqid (struct msqid_ds mq, const struct __msqid64_ds mq64)
	190	{
	191	mq->msg_perm = mq64->msg_perm;
	192	mq->msg_stime = mq64->msg_stime;
	193	mq->__msg_stime_high = 0;
	194	mq->msg_rtime = mq64->msg_rtime;
	195	mq->__msg_rtime_high = 0;
	196	mq->msg_ctime = mq64->msg_ctime;
	197	mq->__msg_ctime_high = 0;
	198	mq->msg_cbytes = mq64->msg_cbytes;
	199	mq->msg_qnum = mq64->msg_qnum;
	200	mq->msg_qbytes = mq64->msg_qbytes;
	201	mq->msg_lspid = mq64->msg_lspid;
	202	mq->msg_lrpid = mq64->msg_lrpid;
	203	}
	204
	205	int
	206	__msgctl (int msqid, int cmd, struct msqid_ds *buf)
	207	{
	208	struct __msqid64_ds msqid64, *buf64 = NULL;
	209	if (buf != NULL)
	210	{
	211	/* This is a Linux extension where kernel returns a 'struct msginfo'
	212	instead. */
	213	if (cmd == IPC_INFO \|\| cmd == MSG_INFO)
	214	buf64 = (struct __msqid64_ds *) buf;
	215	else
	216	{
	217	msqid_to_msqid64 (&msqid64, buf);
	218	buf64 = &msqid64;
	219	}
	220	}
	221
	222	int ret = __msgctl64 (msqid, cmd, buf64);
	223	if (ret < 0)
	224	return ret;
	225
	226	switch (cmd)
	227	{
	228	case IPC_STAT:
	229	case MSG_STAT:
	230	case MSG_STAT_ANY:
	231	msqid64_to_msqid (buf, buf64);
	232	}
	233
	234	return ret;
	235	}
	236	#endif
	237
	238	#ifndef DEFAULT_VERSION
	239	# ifndef __ASSUME_SYSVIPC_BROKEN_MODE_T
	240	# define DEFAULT_VERSION GLIBC_2_2
	241	# else
	242	# define DEFAULT_VERSION GLIBC_2_31
	243	# endif
	244	#endif
	245	versioned_symbol (libc, __msgctl, msgctl, DEFAULT_VERSION);
	246
	247	#if defined __ASSUME_SYSVIPC_BROKEN_MODE_T \
	248	&& SHLIB_COMPAT (libc, GLIBC_2_2, GLIBC_2_31)
	249	int
	250	attribute_compat_text_section
	251	__msgctl_mode16 (int msqid, int cmd, struct msqid_ds *buf)
	252	{
	253	return msgctl_syscall (msqid, cmd, (msgctl_arg_t *) buf);
	254	}
	255	compat_symbol (libc, __msgctl_mode16, msgctl, GLIBC_2_2);
	256	#endif
	257
	258	#if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_2)
	259	struct __old_msqid_ds
	260	{
	261	struct __old_ipc_perm msg_perm; /* structure describing operation permission */
	262	struct msg __msg_first; / pointer to first message on queue */
	263	struct msg __msg_last; / pointer to last message on queue */
	264	__time_t msg_stime; /* time of last msgsnd command */
	265	__time_t msg_rtime; /* time of last msgrcv command */
	266	__time_t msg_ctime; /* time of last change */
	267	struct wait_queue __wwait; / ??? */
	268	struct wait_queue __rwait; / ??? */
	269	unsigned short int __msg_cbytes; /* current number of bytes on queue */
	270	unsigned short int msg_qnum; /* number of messages currently on queue */
	271	unsigned short int msg_qbytes; /* max number of bytes allowed on queue */
	272	__ipc_pid_t msg_lspid; /* pid of last msgsnd() */
	273	__ipc_pid_t msg_lrpid; /* pid of last msgrcv() */
	274	};
	275
	276	int
	277	attribute_compat_text_section
	278	__old_msgctl (int msqid, int cmd, struct __old_msqid_ds *buf)
	279	{
	280	#if defined __ASSUME_DIRECT_SYSVIPC_SYSCALLS \
	281	&& !defined __ASSUME_SYSVIPC_DEFAULT_IPC_64
	282	/* For architecture that have wire-up msgctl but also have __IPC_64 to a
	283	value different than default (0x0) it means the compat symbol used the
	284	__NR_ipc syscall. */
	285	return INLINE_SYSCALL_CALL (msgctl, msqid, cmd, buf);
	286	#else
	287	return INLINE_SYSCALL_CALL (ipc, IPCOP_msgctl, msqid, cmd, 0, buf);
	288	#endif
	289	}
	290	compat_symbol (libc, __old_msgctl, msgctl, GLIBC_2_0);
	291	#endif