int atributos(mqd_t cola, char *nombre)
{
struct mq_attr mqa;
if (mq_getattr(cola, &mqa) < 0)
perror("mq_getattr");
else {
printf("MQD: %s tiene %ld msjs (max %ld, max tamaño %ld, modo %s)\n",
nombre, mqa.mq_curmsgs, mqa.mq_maxmsg, mqa.mq_msgsize, (mqa.mq_flags & O_NONBLOCK) ? "sin-bloqueo" : "bloqueo");
}
return 0;
}
int main(void)
{
char mqname[NAMESIZE];
const char *msgptr = "test message";
mqd_t mqdes;
struct mq_attr mqstat;
int i;
int unresolved = 0, failure = 0;
sprintf(mqname, "/" FUNCTION "_" TEST "_%d", getpid());
memset(&mqstat, 0, sizeof(mqstat));
mqstat.mq_msgsize = MSGSIZE;
mqstat.mq_maxmsg = MAXMSG;
mqdes = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &mqstat);
if (mqdes == (mqd_t) - 1) {
perror(ERROR_PREFIX "mq_open()");
return PTS_UNRESOLVED;
}
for (i = 0; i < MSG_NUM; i++) {
if (mq_send(mqdes, msgptr, strlen(msgptr), 1) == -1) {
perror(ERROR_PREFIX "mq_send()");
unresolved = 1;
}
}
memset(&mqstat, 0, sizeof(mqstat));
if (mq_getattr(mqdes, &mqstat) != 0) {
perror(ERROR_PREFIX "mq_getattr");
unresolved = 1;
} else {
if (mqstat.mq_curmsgs != MSG_NUM) {
printf("mq_getattr didn't get the correct "
"mq_curmsgs \n");
failure = 1;
}
}
mq_close(mqdes);
mq_unlink(mqname);
if (failure == 1) {
printf("Test FAILED\n");
return PTS_FAIL;
}
if (unresolved == 1) {
printf("Test UNRESOLVED\n");
return PTS_UNRESOLVED;
}
printf("Test PASSED\n");
return PTS_PASS;
}
bool hasMessages(mqd_t mqueue)
{
mq_attr mqstat;
bool hasMessages = false;
if(!mq_getattr(mqueue, &mqstat))
{
if(mqstat.mq_curmsgs > 0)
hasMessages = true;
}
return hasMessages;
}
int main(int argc, char **argv)
{
int c_stat;
struct mq_attr m_attr;
char buf[bufsiz], recv[bufsiz];
unsigned int prio;
ssize_t sz_recv;
memset(buf, '\0', bufsiz);
memset(recv, '\0', bufsiz);
if (argc > 1)
strncpy(buf, argv[1], bufsiz-1);
m_attr.mq_flags = 0;
m_attr.mq_msgsize = bufsiz;
m_attr.mq_maxmsg = 10;
m_attr.mq_curmsgs = 0;
mq_unlink("/testmq");
mq_test = mq_open( "/testmq", O_NONBLOCK | O_CREAT | O_EXCL | O_RDWR, S_IRWXU | S_IRWXG, &m_attr );
myassert( mq_test != (mqd_t)-1, 0x1 );
myassert( mq_getattr(mq_test, &m_attr) == 0, 0x2 );
strcpy(buf, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVQXYZ");
myassert( mq_send(mq_test, buf, bufsiz, 0) == 0, 0x4 );
sz_recv = mq_receive(mq_test, recv, bufsiz, &prio);
myassert( sz_recv > 0, 0x8 );
memset(recv, '\0', bufsiz);
if (fork() > 0) {
mq_recv = mq_open( "/testmq", O_RDONLY, S_IRWXU | S_IRWXG, &m_attr );
myassert( mq_recv != (mqd_t)-1, 0x10 );
sz_recv = mq_receive(mq_recv, recv, bufsiz, &prio);
myassert( sz_recv > 0, 0x20 );
return ret;
}
myassert( mq_send(mq_test, buf, bufsiz, 0) == 0, 0x40 );
wait(&c_stat);
myassert( c_stat == 0xFF, 0x80 );
myassert( mq_close(mq_test) == 0, 0x100 );
myassert( mq_unlink("/testmq") == 0, 0x200 );
myassert( sem_unlink("/testsem") == 0, 0x400 );
sp_test = sem_open("/testsem", O_CREAT | O_EXCL, S_IRUSR | S_IWUSR, 0);
myassert( sp_test == 0, 0x800 );
myassert( sem_post(sp_test) == 0, 0x1000 );
myassert( sem_wait(sp_test) == 0, 0x1200 );
myassert( sem_close(sp_test) == 0, 0x1400 );
myassert( sem_unlink("/testsem") == 0, 0x1800 );
return ret;
}
void mqueue_check_functions(mqd_t m)
{
(void)mq_close(m);
(void)mq_getattr(m, (struct mq_attr *)0);
(void)mq_notify(m, (const struct sigevent *)0);
(void)mq_open((const char *)0, 0, 0);
(void)mq_receive(m, (char*)0, (size_t)0, (unsigned*)0);
(void)mq_send(m, (const char *)0, (size_t)0, (unsigned)0);
(void)mq_setattr(m, (const struct mq_attr *)0, (struct mq_attr *)0);
(void)mq_timedreceive(m, (char*)0, (size_t)0, (unsigned*)0, (const struct timespec*)0);
(void)mq_timedsend(m, (const char *)0, (size_t)0, (unsigned)0, (const struct timespec*)0);
(void)mq_unlink((const char *)0);
}
/*
* call-seq:
* mq.attr => mq_attr
*
* Returns a POSIX_MQ::Attr struct containing the attributes
* of the message queue. See the mq_getattr(3) manpage for
* more details.
*/
static VALUE getattr(VALUE self)
{
struct posix_mq *mq = get(self, 1);
if (mq_getattr(mq->des, &mq->attr) < 0)
rb_sys_fail("mq_getattr");
return rb_funcall(cAttr, id_new, 4,
LONG2NUM(mq->attr.mq_flags),
LONG2NUM(mq->attr.mq_maxmsg),
LONG2NUM(mq->attr.mq_msgsize),
LONG2NUM(mq->attr.mq_curmsgs));
}
queue_err_t queue_open(void *p, const char *filename, int flags)
{
int omask;
mode_t oldmask;
posix_queue_t *q;
q = (posix_queue_t *) p;
if (HAS_FLAG(flags, QUEUE_FL_SENDER)) {
omask = O_WRONLY;
} else {
omask = O_RDONLY;
}
if (HAS_FLAG(flags, QUEUE_FL_OWNER)) {
omask |= O_CREAT | O_EXCL;
oldmask = umask(0);
if (NULL == (q->filename = strdup(filename))) {
// TODO: error
return QUEUE_ERR_GENERAL_FAILURE;
}
}
if (NOT_MQD_T == (q->mq = mq_open(filename, omask, 0660, &q->attr))) {
if (HAS_FLAG(flags, QUEUE_FL_OWNER)) {
umask(oldmask);
#ifdef __FreeBSD__
if (ENOSYS == errno) {
// please load mqueuefs module with kldload or recompile your kernel to include "options P1003_1B_MQUEUE"
}
#endif
}
// TODO: error
return QUEUE_ERR_GENERAL_FAILURE;
}
if (!HAS_FLAG(flags, QUEUE_FL_SENDER)) {
// mq_setattr implies CAP_EVENT?
CAP_RIGHTS_LIMIT(__mq_oshandle(q->mq), CAP_READ, CAP_EVENT);
#if 0
} else {
CAP_RIGHTS_LIMIT(__mq_oshandle(q->mq), CAP_WRITE, CAP_EVENT);
#endif
}
if (HAS_FLAG(flags, QUEUE_FL_OWNER)) {
umask(oldmask);
} else {
if (0 != mq_getattr(q->mq, &q->attr)) {
// TODO: error
return QUEUE_ERR_GENERAL_FAILURE;
}
}
return QUEUE_ERR_OK;
}
/**
\details Return the list of pending mapistore notifications
available on the queue name specified in argument.
\param mstore_ctx pointer to the mapistore context
\param mqueue_name the name of the queue to open
\param nl pointer on pointer to the list of mapistore notifications to return
\return MAPISTORE_SUCCESS on success, otherwise MAPISTORE error.
*/
_PUBLIC_ enum MAPISTATUS mapistore_get_queued_notifications_named(struct mapistore_context *mstore_ctx,
const char *mqueue_name,
struct mapistore_notification_list **nl)
{
int ret;
mqd_t mqueue;
struct mapistore_notification_list *nlist = NULL;
struct mapistore_notification_list *el = NULL;
unsigned int prio;
struct mq_attr attr;
DATA_BLOB data;
bool found = false;
printf("[%s:%d]: queue name = %s\n", __FUNCTION__, __LINE__, ((mqueue_name) ? mqueue_name : NULL));
/* Sanity checks */
MAPISTORE_RETVAL_IF(!mstore_ctx, MAPISTORE_ERR_NOT_INITIALIZED, NULL);
MAPISTORE_RETVAL_IF(!nl, MAPISTORE_ERR_INVALID_PARAMETER, NULL);
mqueue = mq_open(mqueue_name, O_RDONLY|O_NONBLOCK|O_CREAT, 0777, NULL);
if (mqueue == -1) {
perror("mq_open");
return MAPISTORE_ERR_NOT_INITIALIZED;
}
/* Retrieve queue attributes */
ret = mq_getattr(mqueue, &attr);
if (ret == -1) {
perror("mq_getattr");
/* set proper error message here and remove above */
if (mq_close(mqueue) == -1) {
perror("mq_close");
}
MAPISTORE_RETVAL_IF(ret == -1, MAPISTORE_ERR_NOT_FOUND, NULL);
}
data.data = talloc_size((TALLOC_CTX *)mstore_ctx, attr.mq_msgsize);
while ((data.length = mq_receive(mqueue, (char *)data.data, attr.mq_msgsize, &prio)) != -1) {
printf("* we received a notification on queue %s\n", mqueue_name);
if (!nlist) {
nlist = talloc_zero((TALLOC_CTX *)mstore_ctx, struct mapistore_notification_list);
}
el = mapistore_notification_process_mqueue_notif((TALLOC_CTX *)nlist, data);
printf("* processing notification returned %p\n", el);
if (el) {
DLIST_ADD_END(nlist, el, struct mapistore_notification_list);
}
talloc_free(data.data);
found = true;
data.data = talloc_size((TALLOC_CTX *)mstore_ctx, attr.mq_msgsize);
}
// set message queue attributes to non-blocking, 10 messages with 4 bytes each
void setup_mbox(mqd_t *mbox, struct mq_attr * attr, const char * name)
{
attr->mq_flags = 0;
attr->mq_maxmsg = 10;
attr->mq_msgsize = 4;
attr->mq_curmsgs = 0;
*mbox = mq_open(name, O_RDWR | O_CREAT, S_IRWXU | S_IRWXG, attr);
if (*mbox == (mqd_t)-1) {
perror("mq_open");
fprintf(stderr,"-- unable to create mbox '%s'", name);
}
mq_getattr(*mbox, attr);
}
int main(int argc, char **argv)
{
mqd_t micola;
char *buf; /* Puntero a los datos recibidos */
int result;
int prio;
struct mq_attr atris;
int i;
fprintf(stderr, "lector -> activado\n", argv[0]);
/* Apertura de la cola: Se reintenta tantas veces como sea preciso */
do
{
micola = mq_open("/unacola", O_RDWR, 0, NULL);
if(micola == (mqd_t)-1)
{
fprintf(stderr, "lector -> error al abrir; probaremos de nuevo\n");
sleep(1);
}
} while(micola == (mqd_t)-1);
fprintf(stderr, "lector -> por fin consegui abrir la cola\n");
/* Se dimensiona el buffer de datos al tamano del mensaje */
mq_getattr(micola, &atris);
buf = (char *)malloc(atris.mq_msgsize);
/* Bucle de recepcion: Todo lo que llega es enviado por la salida
standard hasta encontrar un "\0" */
while(1)
{
result = mq_receive(micola, (char *)buf, atris.mq_msgsize, &prio);
if(*buf == '\0') break;
for(i=0; i<atris.mq_msgsize; i++)
putchar(buf[i]);
fflush(stdout);
fprintf(stderr, "\ntexto volcado a salida\n");
}
/* Final */
mq_close(micola);
fprintf(stderr, "lector -> acabando\n");
}
static void
fct (union sigval s)
{
/* Put the mq in non-blocking mode. */
struct mq_attr attr;
if (mq_getattr (m, &attr) != 0)
{
printf ("%s: mq_getattr failed: %m\n", __FUNCTION__);
exit (1);
}
attr.mq_flags |= O_NONBLOCK;
if (mq_setattr (m, &attr, NULL) != 0)
{
printf ("%s: mq_setattr failed: %m\n", __FUNCTION__);
exit (1);
}
/* Check the values. */
if (attr.mq_maxmsg != MAXMSG)
{
printf ("%s: mq_maxmsg wrong: is %ld, expecte %d\n",
__FUNCTION__, attr.mq_maxmsg, MAXMSG);
exit (1);
}
if (attr.mq_msgsize != MAXMSG)
{
printf ("%s: mq_msgsize wrong: is %ld, expecte %d\n",
__FUNCTION__, attr.mq_msgsize, MSGSIZE);
exit (1);
}
/* Read the message. */
char buf[attr.mq_msgsize];
ssize_t n = TEMP_FAILURE_RETRY (mq_receive (m, buf, attr.mq_msgsize, NULL));
if (n != sizeof (message))
{
printf ("%s: length of message wrong: is %zd, expected %zu\n",
__FUNCTION__, n, sizeof (message));
exit (1);
}
if (memcmp (buf, message, sizeof (message)) != 0)
{
printf ("%s: message wrong: is \"%s\", expected \"%s\"\n",
__FUNCTION__, buf, message);
exit (1);
}
exit (UNIQUE);
}
/*
* test_queue - Test opening a queue, shutdown if we fail. This should
* only be called in situations that should never fail. We clean up
* after ourselves and return the queue attributes in *result.
*/
static inline void test_queue(struct mq_attr *attr, struct mq_attr *result)
{
int flags = O_RDWR | O_EXCL | O_CREAT;
int perms = DEFFILEMODE;
if ((queue = mq_open(queue_path, flags, perms, attr)) == -1)
shutdown(1, "mq_open()", __LINE__);
if (mq_getattr(queue, result))
shutdown(1, "mq_getattr()", __LINE__);
if (mq_close(queue))
shutdown(1, "mq_close()", __LINE__);
queue = -1;
if (mq_unlink(queue_path))
shutdown(1, "mq_unlink()", __LINE__);
}
/*
* call-seq:
* POSIX_MQ.for_fd(socket) => mq
*
* Adopts a socket as a POSIX message queue. Argument will be
* checked to ensure it is a POSIX message queue socket.
*
* This is useful for adopting systemd sockets passed via the
* ListenMessageQueue directive.
* Returns a +POSIX_MQ+ instance. This method is only available
* under Linux and FreeBSD and is not intended to be portable.
*
*/
static VALUE for_fd(VALUE klass, VALUE socket)
{
VALUE mqv = alloc(klass);
struct posix_mq *mq = get(mqv, 0);
mqd_t mqd;
mq->name = Qnil;
mqd = FD_TO_MQD(NUM2INT(socket));
if (mq_getattr(mqd, &mq->attr) < 0)
rb_sys_fail("provided file descriptor is not a POSIX MQ");
mq->des = mqd;
return mqv;
}
int mq_setattr(mqd_t mqd, struct mq_attr* newattr, struct mq_attr* oldattr){
struct mq_attr *attr = hashLink[mqd];
if(attr == NULL) {
errno = EBADF;
return -1;
}
if(newattr->mq_flags & ~O_NONBLOCK) {
errno = EINVAL;
return -1;
}
if(oldattr != NULL)
mq_getattr(mqd, oldattr);
localinfo[mqd].mq_flags = newattr->mq_flags;
return 0;
}
void Mq::before_fork()
{
struct mq_attr attr;
mq_name = options["message_queue"];
mq_unlink(mq_name.c_str());
queuefd = mq_open(mq_name.c_str(), O_RDWR | O_CREAT, S_IRUSR | S_IWUSR, NULL);
if (queuefd < 0)
perror("mq_open");
if (mq_getattr(queuefd, &attr) < 0)
perror("mq_getattr");
max_msg_size = attr.mq_msgsize;
}
int orange_eq_open(struct orange_eq *self, const char *queue_name, bool server){
memset(self, 0, sizeof(struct orange_eq));
if(!queue_name) queue_name = "/orangerpcd-events";
if(server){
mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
self->mq = mq_open(queue_name, O_RDONLY | O_CREAT, mode, NULL);
} else {
self->mq = mq_open(queue_name, O_WRONLY);
}
if(self->mq == -1) return -1;
mq_getattr(self->mq, &self->attr);
self->buf = malloc(self->attr.mq_msgsize);
if(!self->buf) return -ENOMEM;
return 0;
}
// handlers
void client_handler(union sigval sv){
struct mq_attr attributes;
char *buf;
mqd_t mqdes = *((mqd_t *)sv.sival_ptr);
if(mq_getattr(mqdes, &attributes)==-1){
handle_error("mq_getattr");
}
while(1){
buf = malloc(attributes.mq_msgsize+1);
mq_receive(mqdes,buf,attributes.mq_msgsize,NULL);
printf("\n%s\n",buf);
free(buf);
}
}
int mymq_init(char *id) {
struct mq_attr mqat;
// TODO use session ID in path.
// implement session authenticaion? - allow user to specify umask.
char qname[64];
snprintf(qname,64,"/xjadeo-request%s%s", id?"-":"", id?(char*)id:"");
mqfd_r = mq_open(qname, O_RDONLY | O_CREAT | O_EXCL | O_NONBLOCK, S_IRWXU , NULL);
if (mqfd_r == -1) {
perror("mq_open failure:");
if (errno == EEXIST)
fprintf(stderr,"note: use `xjremote -u` to unlink old queues\n");
return(1);
}
if (mq_getattr(mqfd_r, &mqat) == -1) {
perror("mq_getattr error:");
return(1);
}
mq_msgsize_r = mqat.mq_msgsize;
msg_buffer = malloc(mq_msgsize_r);
snprintf(qname,64,"/xjadeo-reply%s%s", id?"-":"", id?(char*)id:"");
mqfd_s = mq_open(qname, O_WRONLY | O_CREAT | O_EXCL | O_NONBLOCK, S_IRWXU , NULL);
if (mqfd_s == -1) {
perror("mq_open failure:");
if (errno == EEXIST)
fprintf(stderr,"note: use `xjremote -u` to unlink old queues\n");
mq_close(mqfd_r);
snprintf(qname,64,"/xjadeo-request%s%s", id?"-":"", id?(char*)id:"");
mq_unlink(qname);
return(1);
}
while (mq_receive(mqfd_r, msg_buffer, mq_msgsize_r, 0) > 0) ;
#if 0
{ // FLUSH the output Queue
mqd_t mqfd_sx = mq_open(qname, O_RDONLY | O_NONBLOCK, S_IRWXU , NULL);
while (mq_receive(mqfd_sx, msg_buffer, mq_msgsize_r, 0) > 0) ;
mq_close(mqfd_sx);
}
#endif
if (!want_quiet)
printf("activated remote interface. mqID:%s\n",id?id:"[default]");
return(0);
}
void server_handler(union sigval sv){
printf("server handler started\n");
#define MAX_CLIENTS 10
struct mq_attr attributes;
char *buf, *message;
char keyValue, testValue='/';
char testString[45] = "yolo hello ./knkp . not be included";
int current_client = 0;
int clients = 0;
mqd_t client_list[MAX_CLIENTS];
mqd_t mqdes = *((mqd_t *)sv.sival_ptr);
if(mq_getattr(mqdes, &attributes)==-1){
handle_error("mq_getattr");
}
while(1){
buf = malloc(attributes.mq_msgsize+1);
mq_receive(mqdes,buf,attributes.mq_msgsize,NULL);
printf("new message\n");
parse_message2(buf, &message);
printf("first value of message is: %c\n", &message[0]);
printf("message is: %s\n",&message);
keyValue = &message[0];
if(keyValue == testValue){
printf("got new client\n");
if(clients == MAX_CLIENTS){
printf("reached maximum clients\n");
}
else {
client_list[clients] = mq_open(&message, O_RDWR);
clients++;
}
}
else {
printf("sending messages\n");
for(current_client = 0; current_client < clients; current_client++){
send_message(client_list[current_client], &message);
}
}
free(buf);
}
}
int main(int argc, char *argv[]) {
mqd_t msgq_id;
char* msgcontent = (char*)malloc(MAX_MSG_LEN);
int msgsz;
unsigned int sender;
struct mq_attr msgq_attr;
assert(argc == 2);
if (argv[1][0] != '/') {
fprintf(stderr, "Queue name must start with '/'\n");
exit(EXIT_FAILURE);
}
/* opening the queue -- mq_open() */
msgq_id = mq_open(argv[1], O_RDWR);
if (msgq_id == (mqd_t)-1) {
perror("In mq_open()");
exit(1);
}
/* getting the attributes from the queue -- mq_getattr() */
mq_getattr(msgq_id, &msgq_attr);
printf("Queue \"%s\":\n\t- stores at most %ld messages\n\t- large at most %ld bytes each\n\t- currently holds %ld messages\n", argv[1], msgq_attr.mq_maxmsg, msgq_attr.mq_msgsize, msgq_attr.mq_curmsgs);
/* getting a message */
while(1){
msgsz = mq_receive(msgq_id, msgcontent, MAX_MSG_LEN, &sender);
if (msgsz == -1) {
perror("In mq_receive()");
exit(1);
}
if(msgsz != 0){
msgcontent[msgsz] = '\0';
fprintf(stdout,"%d %s\n", sender, msgcontent);
}
if(sender == 666){
break;
}
}
/* closing the queue -- mq_close() */
mq_close(msgq_id);
return 0;
}
ipc_mq ipc_mq_posix_new(void* value, int mode, int perm)
{
ipc_mq ret = NULL;
struct ipc_mq_posix* priv = NULL;
char* name = (char*)value;
mqd_t mq;
struct mq_attr attr;
if(name == NULL)
{
errno = EINVAL;
return NULL;
}
mq = mq_open(name, mode, (mode_t)perm, NULL);
if(mq == (mqd_t)-1)
{
return NULL;
}
if(mq_getattr(mq, &attr) != 0)
{
mq_close(mq);
return NULL;
}
ret = malloc(sizeof(struct ipc_mq) + sizeof(struct ipc_mq_posix));
if(!ret)
{
mq_close(mq);
return NULL;
}
memset(ret, 0x00, sizeof(struct ipc_mq) + sizeof(struct ipc_mq_posix));
ret->type = IPC_MQ_POSIX;
ret->free = ipc_mq_posix_free;
ret->get_max_msg_size = ipc_mq_posix_get_max_msg_size;
ret->send = ipc_mq_posix_send;
ret->recv = ipc_mq_posix_recv;
priv = (struct ipc_mq_posix*)&ret->priv;
strncpy(priv->name, name, sizeof(priv->name));
priv->mq = mq;
priv->max_msg_size = attr.mq_msgsize;
return ret;
}
int main(int argc, char **argv)
{
int c, flags;
mqd_t mqd;
ssize_t n;
unsigned int prio;
void *buff;
struct mq_attr attr;
flags = O_RDONLY;
while ((c = getopt(argc, argv, "n")) != -1) {
switch (c) {
case 'n':
flags |= O_NONBLOCK;
break;
case '?':
exit(1);
}
}
if (optind != argc - 1) {
fprintf(stderr, "usage: mqreceive [ -n ] <name>\n");
exit(1);
}
if ((mqd = mq_open(argv[optind], flags)) == -1) {
fprintf(stderr, "mq_open error for %s: %s\n", argv[optind], strerror(errno));
exit(1);
}
if (mq_getattr(mqd, &attr) == -1) {
perror("mq_getattr error");
exit(1);
}
if ((buff = malloc(attr.mq_msgsize)) == NULL) {
perror("malloc error");
exit(1);
}
if ((n = mq_receive(mqd, buff, attr.mq_msgsize, &prio)) == -1) {
perror("mq_receive error");
exit(1);
}
printf("read %ld bytes, priority = %u\n", (long) n, prio);
exit(0);
}
int main(void)
{
char mqname[NAMESIZE];
mqd_t mqdes;
struct mq_attr mqstat, nmqstat;
int unresolved = 0;
int failure = 0;
sprintf(mqname, "/" FUNCTION "_" TEST "_%d", getpid());
memset(&mqstat, 0, sizeof(mqstat));
mqstat.mq_msgsize = MSGSIZE;
mqstat.mq_maxmsg = MAXMSG;
mqdes = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &mqstat);
if (mqdes == (mqd_t) - 1) {
perror(ERROR_PREFIX "mq_open()");
return PTS_UNRESOLVED;
}
memset(&nmqstat, 0, sizeof(nmqstat));
if (mq_getattr(mqdes, &nmqstat) != 0) {
perror(ERROR_PREFIX "mq_getattr");
unresolved = 1;
}
if ((mqstat.mq_maxmsg != nmqstat.mq_maxmsg) ||
(mqstat.mq_msgsize != nmqstat.mq_msgsize)) {
printf("FAIL: mq_getattr didn't get the correct mq_maxmsg, "
"mq_msgsize set by mq_open\n");
failure = 1;
}
mq_close(mqdes);
mq_unlink(mqname);
if (failure == 1) {
printf("Test FAILED\n");
return PTS_FAIL;
}
if (unresolved == 1) {
printf("Test UNRESOLVED\n");
return PTS_UNRESOLVED;
}
printf("Test PASSED \n");
return PTS_PASS;
}
static int
do_test (int argc, char **argv)
{
if (after_exec != (mqd_t) -1)
return do_after_exec ();
char name[sizeof "/tst-mqueue7-" + sizeof (pid_t) * 3];
snprintf (name, sizeof (name), "/tst-mqueue7-%u", getpid ());
struct mq_attr attr = { .mq_maxmsg = 10, .mq_msgsize = 1 };
mqd_t q = mq_open (name, O_CREAT | O_EXCL | O_WRONLY, 0600, &attr);
if (q == (mqd_t) -1)
{
printf ("mq_open failed with: %m\n");
return 0;
}
else if (mq_unlink (name) != 0)
{
printf ("mq_unlink failed with: %m\n");
return 1;
}
if (mq_getattr (q, &attr) != 0)
{
printf ("mq_getattr failed: %m\n");
return 1;
}
char after_exec_arg[sizeof "--after-exec=0x" + sizeof (long) * 3];
snprintf (after_exec_arg, sizeof (after_exec_arg),
"--after-exec=0x%lx", (long) q);
const char *newargv[argc + 2];
for (int i = 1; i < argc; ++i)
newargv[i - 1] = argv[i];
newargv[argc - 1] = "--direct";
newargv[argc] = after_exec_arg;
newargv[argc + 1] = NULL;
/* Verify that exec* has the effect of mq_close (q). */
execv (newargv[0], (char * const *) newargv);
printf ("execv failed: %m\n");
return 1;
}
//-----------------------------------------------------------------------------
void child_func(int arg) {
int i;
size_t n = 0;
char inBuf[50];
uint priority = 0;
int nMsgs = 0;
struct mq_attr my_attrs ={0,0,0,0};
mode_t my_mode = 0;
int my_oflags = (O_RDONLY | O_NONBLOCK);
mqd_t rx_q = INVALID_PQUEUE;
rt_printk("Starting child task %d\n", arg);
for(i = 0; i < 3; i++) {
rt_printk("child task %d, loop count %d\n", arg, i);
}
//Open the queue for reading
rx_q = mq_open("my_queue", my_oflags, my_mode, &my_attrs);
if (rx_q <= 0) {
rt_printk("ERROR: child cannot open my_queue\n");
} else {
//Get the message(s) off the pQueue
n = mq_getattr(rx_q, &my_attrs);
nMsgs = my_attrs.mq_curmsgs;
rt_printk("There are %d messages on the queue\n", nMsgs);
while(nMsgs-- > 0) {
n = mq_receive(rx_q, inBuf, sizeof(inBuf), &priority);
inBuf[n] = '\0';
//Report what happened
rt_printk("Child got >%s<, %d bytes at priority %d\n", inBuf,n, priority);
}
}
mq_close(rx_q);
mq_unlink("my_queue");
free_z_apps(rt_whoami());
rt_task_delete(rt_whoami());
}
WORD32 Vos_GetQueueCurrentCount(WORD32 dwQueueId)
{
struct mq_attr attr;
if (MAX_QUEUE_COUNT <= dwQueueId)
{
/* 队列控制块ID不合法 */
printf("[%s:%d] Value of QueueID is invalid!\n" , __FUNCTION__, __LINE__);
return -1;
}
if (-1 == mq_getattr(s_atQueueCtl[dwQueueId].dwQueueId, &attr))
{
printf("[%s:%d] Fail to get message queue info of Linux!\n" , __FUNCTION__, __LINE__);
return -1;
}
return attr.mq_curmsgs;
}
int main(int argc, char *argv[])
{
int c, flags;
mqd_t mqd;
ssize_t n;
uint32_t prio;
void *buf;
struct mq_attr attr;
flags = O_RDONLY;
while ((c = getopt(argc, argv, "n")) != -1) {
switch (c) {
case 'n':
flags |= O_NONBLOCK;
break;
}
}
if (optind != argc -1)
err_quit("usage: mqreceive [ -n ] <name>\n");
mqd = mq_open(argv[optind],flags);
if (mqd < 0) {
err_sys("mq_open error:");
}
if (mq_getattr(mqd, &attr) < 0) {
err_sys("mq_getattr error:");
}
buf = malloc(attr.mq_msgsize);
if (buf == NULL) {
err_sys("malloc error:");
}
n = mq_receive(mqd,buf, attr.mq_msgsize, &prio);
if (n < 0) {
err_sys("mq_receive error:");
}
printf("read %ld bytes, priority = %u\n",
(long)n, prio);
return 0;
}
int main()
{
char qname[NAMESIZE];
mqd_t queue;
struct mq_attr attr;
struct mq_attr attrget;
sprintf(qname, "/mq_open_13-1_%d", getpid());
attr.mq_maxmsg = MAXMSG;
attr.mq_msgsize = MSGSIZE;
queue = mq_open(qname, O_CREAT |O_RDWR, S_IRUSR | S_IWUSR, &attr);
if (queue == (mqd_t)-1) {
perror("mq_open() did not return success");
printf("Test FAILED\n");
return PTS_FAIL;
}
if (mq_getattr(queue, &attrget) != 0) {
perror("mq_getattr() failed");
printf("Test FAILED -- could not get attributes\n");
mq_close(queue);
mq_unlink(qname);
return PTS_FAIL;
}
if ((attrget.mq_maxmsg != attr.mq_maxmsg) ||
(attrget.mq_msgsize != attr.mq_msgsize)) {
printf("sent: mq_maxmsg %ld; received %ld\n", attr.mq_maxmsg,
attrget.mq_maxmsg);
printf("sent: mq_msgsize %ld; received %ld\n", attr.mq_msgsize,
attrget.mq_msgsize);
printf("Test FAILED -- attributes do not match\n");
mq_close(queue);
mq_unlink(qname);
return PTS_FAIL;
}
mq_close(queue);
mq_unlink(qname);
printf("Test PASSED\n");
return PTS_PASS;
}
int main(int argc, char const *argv[])
{
int seqnum;
mqd_t mqd, client_mqd;
struct mq_attr attr;
openlog("mq_seqnum_client", LOG_PID, LOG_USER);
srand(time(NULL));
client_id = rand();
snprintf(client_mq, 21, CLIENT_MQ, client_id);
client_mqd = mq_open(client_mq, O_CREAT | O_RDONLY, S_IWUSR | S_IRUSR, NULL);
if (client_mqd == (mqd_t) -1)
log_err_exit("mq_open server error");
if (atexit(clear) != 0)
log_err_exit("atexit error");
syslog(LOG_INFO, "open mq %s to receive", client_mq);
if (mq_getattr(client_mqd, &attr) == -1)
errExit("mq_getattr");
mqd = mq_open(SERVER_MQ, O_WRONLY);
if (mqd == (mqd_t) -1)
log_err_exit("mq_open client error");
syslog(LOG_INFO, "open mq %s to send", SERVER_MQ);
if (mq_send(mqd, (char *) &client_id, sizeof(client_id), 0) == -1)
log_err_exit("mq_send error");
syslog(LOG_INFO, "client id sent: %d", client_id);
if (mq_close(mqd) == -1)
log_err_exit("mq_close server error");
if (mq_receive(client_mqd, (char *) &seqnum, attr.mq_msgsize, NULL) == -1)
log_err_exit("mq_receive error");
if (mq_close(client_mqd) == -1)
log_err_exit("mq_close client error");
printf("%d\n", seqnum);
exit(EXIT_SUCCESS);
}
static VALUE _receive(int rflags, int argc, VALUE *argv, VALUE self)
{
struct posix_mq *mq = get(self, 1);
struct rw_args x;
VALUE buffer, timeout;
struct timespec expire;
if (mq->attr.mq_msgsize < 0) {
if (mq_getattr(mq->des, &mq->attr) < 0)
rb_sys_fail("mq_getattr");
}
rb_scan_args(argc, argv, "02", &buffer, &timeout);
x.timeout = convert_timeout(&expire, timeout);
if (NIL_P(buffer)) {
buffer = rb_str_new(0, mq->attr.mq_msgsize);
} else {
StringValue(buffer);
rb_str_modify(buffer);
rb_str_resize(buffer, mq->attr.mq_msgsize);
}
OBJ_TAINT(buffer);
x.msg_ptr = RSTRING_PTR(buffer);
x.msg_len = (size_t)mq->attr.mq_msgsize;
x.des = mq->des;
retry:
WITHOUT_GVL(xrecv, &x, RUBY_UBF_IO, 0);
if (x.received < 0) {
if (errno == EINTR)
goto retry;
if (errno == EAGAIN && (rflags & PMQ_TRY))
return Qnil;
rb_sys_fail("mq_receive");
}
rb_str_set_len(buffer, x.received);
if (rflags & PMQ_WANTARRAY)
return rb_ary_new3(2, buffer, UINT2NUM(x.msg_prio));
return buffer;
}
