void
errl_Unlink ()
{
char name[64];
char *busid = getenv(pwr_dEnvBusId);
pthread_cancel(tid);
sprintf(name, "%s_%s", LOG_QUEUE_NAME, busid ? busid : "");
/* We don't care about return status */
mq_unlink(name);
}
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);
}
int main(int argc, char **argv)
{
char mqname[256];
char *user = getenv("USER");
sprintf(mqname, "/dmtcp-mq-%s", user == NULL ? "" : user);
mq_unlink(mqname);
if (fork() == 0) {
child(mqname);
} else {
parent(mqname);
}
return 0;
}
int main(void)
{
char mqname[50] = "/something-which-does-not-exit";
mq_unlink(mqname);
if (ENOENT == errno) {
printf("Test PASSED\n");
return PTS_PASS;
} else {
printf("Test FAILED\n");
return PTS_FAIL;
}
}
int main()
{
char mqname[NAMESIZE];
mqd_t mqdes;
struct mq_attr mqstat, nmqstat;
int unresolved = 0;
int failure = 0;
sprintf(mqname, "/" FUNCTION "_" TEST "_%d", getpid());
mqdes = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, NULL);
if (mqdes == (mqd_t) - 1) {
perror(ERROR_PREFIX "mq_open()");
return PTS_UNRESOLVED;
}
memset(&mqstat, 0, sizeof(mqstat));
memset(&nmqstat, 0, sizeof(nmqstat));
if (mq_getattr(mqdes, &mqstat) == -1) {
perror(ERROR_PREFIX "mq_getattr");
unresolved = 1;
}
mqstat.mq_flags |= MQFLAGS;
if (mq_setattr(mqdes, &mqstat, NULL) == -1) {
perror(ERROR_PREFIX "mq_setattr");
failure = 1;
}
if (mq_getattr(mqdes, &nmqstat) != 0) {
perror(ERROR_PREFIX "mq_getattr");
unresolved = 1;
}
if (nmqstat.mq_flags != mqstat.mq_flags) {
printf("FAIL: mq_getattr didn't get the correct mq_flags "
"set by mq_setattr \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;
}
int main()
{
char mqname[NAMESIZE];
mqd_t mqdes;
const char s_msg_ptr[MSG_SIZE] = "test message \n";
struct sigevent notification;
struct sigaction sa;
unsigned int prio = 1;
sprintf(mqname, "/" FUNCTION "_" TEST "_%d", getpid());
mqdes = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, 0);
if (mqdes == (mqd_t)-1) {
perror(ERROR_PREFIX "mq_open");
return PTS_UNRESOLVED;
}
notification.sigev_notify = SIGEV_SIGNAL;
notification.sigev_signo = SIGUSR1;
sa.sa_handler = msg_handler;
sa.sa_flags = 0;
sigaction(SIGUSR1, &sa, NULL);
if (mq_notify(mqdes, ¬ification) != 0) {
perror(ERROR_PREFIX "mq_notify");
mqclean(mqdes, mqname);
return PTS_UNRESOLVED;
}
if (mq_notify(mqdes, NULL) != 0 ) {
printf("Test FAILED \n");
mqclean(mqdes, mqname);
return PTS_FAIL;
}
if (mq_send(mqdes, s_msg_ptr, MSG_SIZE, prio) == -1) {
perror(ERROR_PREFIX "mq_send");
mqclean(mqdes, mqname);
return PTS_UNRESOLVED;
}
sleep(1);
if (mq_unlink(mqname) != 0) {
perror(ERROR_PREFIX "mq_unlink");
return PTS_UNRESOLVED;
}
if (!enter_handler) {
printf("Test PASSED \n");
mqclean(mqdes, mqname);
return PTS_PASS;
}
else {
printf("Test FAILED \n");
mqclean(mqdes, mqname);
return PTS_FAIL;
}
}
static int clean_posix_mq(uid_t uid) {
_cleanup_closedir_ DIR *dir = NULL;
struct dirent *de;
int ret = 0;
dir = opendir("/dev/mqueue");
if (!dir) {
if (errno == ENOENT)
return 0;
log_warning("Failed to open /dev/mqueue: %m");
return -errno;
}
FOREACH_DIRENT(de, dir, goto fail) {
struct stat st;
char fn[1+strlen(de->d_name)+1];
if (STR_IN_SET(de->d_name, "..", "."))
continue;
if (fstatat(dirfd(dir), de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0) {
if (errno == ENOENT)
continue;
log_warning("Failed to stat() MQ segment %s: %m", de->d_name);
ret = -errno;
continue;
}
if (st.st_uid != uid)
continue;
fn[0] = '/';
strcpy(fn+1, de->d_name);
if (mq_unlink(fn) < 0) {
if (errno == ENOENT)
continue;
log_warning("Failed to unlink POSIX message queue %s: %m", fn);
ret = -errno;
}
}
return ret;
fail:
log_warning("Failed to read /dev/mqueue: %m");
return -errno;
}
int main()
{
char qname[NAMESIZE];
const char *msgptr = MSGSTR;
mqd_t queue;
int unresolved=0, failure=0, i;
sprintf(qname, "/mq_send_13-1_%d", getpid());
queue = mq_open(qname, O_CREAT |O_RDWR, S_IRUSR | S_IWUSR, NULL);
if (queue == (mqd_t)-1) {
perror("mq_open() did not return success");
return PTS_UNRESOLVED;
}
for (i=0; i<NUMINVALID; i++) {
if (mq_send(queue, msgptr, strlen(msgptr), invalidpri[i])== 0) {
printf("mq_send() returned success on invalid %d\n",
invalidpri[i]);
failure = 1;
}
if (errno != EINVAL) {
printf("errno not == EINVAL for invalid %d\n",
invalidpri[i]);
failure = 1;
}
}
if (mq_close(queue) != 0) {
perror("mq_close() did not return success");
unresolved=1;
}
if (mq_unlink(qname) != 0) {
perror("mq_unlink() did not return success");
unresolved=1;
}
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;
}
int main(void)
{
char mqname[NAMESIZE], msgrv[BUFFER];
const char *msgptr = "test message";
mqd_t mqdes;
unsigned rvprio, sdprio = 1;
struct timespec ts;
struct mq_attr attr;
int unresolved = 0;
sprintf(mqname, "/" FUNCTION "_" TEST "_%d", getpid());
attr.mq_msgsize = BUFFER;
attr.mq_maxmsg = BUFFER;
mqdes = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
if (mqdes == (mqd_t) - 1) {
perror(ERROR_PREFIX "mq_open");
unresolved = 1;
}
if (mq_send(mqdes, msgptr, strlen(msgptr), sdprio) != 0) {
perror(ERROR_PREFIX "mq_send");
unresolved = 1;
}
ts.tv_sec = time(NULL) + 1;
ts.tv_nsec = -1;
if (mq_timedreceive(mqdes, msgrv, BUFFER, &rvprio, &ts) == -1) {
printf("mq_timedreceive() did fail on invalid abs_time\n");
} else {
printf("mq_timedreceive() did not fail on invalid abs_time\n");
}
if (mq_close(mqdes) != 0) {
perror(ERROR_PREFIX "mq_close");
unresolved = 1;
}
if (mq_unlink(mqname) != 0) {
perror(ERROR_PREFIX "mq_unlink");
unresolved = 1;
}
if (unresolved == 1) {
printf("Test UNRESOLVED\n");
return PTS_UNRESOLVED;
}
printf("Test PASSED\n");
return PTS_PASS;
}
int main()
{
char qname[NAMESIZE];
const char *msgptr = MSGSTR;
struct timespec ts;
mqd_t queue;
int unresolved=0, failure=0;
sprintf(qname, "/mq_timedsend_11-1_%d", getpid());
queue = mq_open(qname, O_CREAT |O_RDWR, S_IRUSR | S_IWUSR, NULL);
if (queue == (mqd_t)-1) {
perror("mq_open() did not return success");
return PTS_UNRESOLVED;
}
ts.tv_sec=time(NULL)+1;
ts.tv_nsec=0;
if (mq_timedsend(queue+1, msgptr, strlen(msgptr), 1, &ts) != -1) {
printf("mq_timedsend() did not return -1 on invalid queue\n");
failure=1;
}
if (errno != EBADF) {
printf("errno != EBADF\n");
failure = 1;
}
if (mq_close(queue) != 0) {
perror("mq_close() did not return success");
unresolved=1;
}
if (mq_unlink(qname) != 0) {
perror("mq_unlink() did not return success");
unresolved=1;
}
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;
}
int main()
{
char mqname[NAMESIZE];
mqd_t mqdes;
char msgrv[BUFFER];
struct timespec ts;
struct mq_attr attr;
int unresolved = 0, failure = 0;
sprintf(mqname, "/" FUNCTION "_" TEST "_%d", getpid());
attr.mq_msgsize = BUFFER;
attr.mq_maxmsg = BUFFER;
mqdes = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
if (mqdes == (mqd_t)-1) {
perror(ERROR_PREFIX "mq_open()");
unresolved = 1;
}
mqdes = mqdes + 1;
ts.tv_sec = time(NULL) + 1;
ts.tv_nsec = 0;
if (mq_timedreceive(mqdes, msgrv, BUFFER, NULL, &ts) == -1) {
if (EBADF != errno) {
printf("errno != EBADF \n");
failure = 1;
}
}
else {
printf("mq_timedreceive() succeed unexpectly \n");
failure = 1;
}
if (mq_close(mqdes - 1) != 0) {
perror(ERROR_PREFIX "mq_close()");
unresolved=1;
}
if (mq_unlink(mqname) != 0) {
perror(ERROR_PREFIX "mq_unlink()");
unresolved=1;
}
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;
}
int main()
{
char mqname[NAMESIZE], msgrv[BUFFER];
const char *msgptr = "test message";
mqd_t mqdes;
int prio = 1;
struct mq_attr mqstat;
struct timespec ts;
int unresolved = 0, failure = 0;
sprintf(mqname, "/" FUNCTION "_" TEST "_%d", getpid());
memset(&mqstat, 0, sizeof(mqstat));
mqstat.mq_msgsize = BUFFER + 1;
mqstat.mq_maxmsg = BUFFER + 1;
mqdes = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &mqstat);
if (mqdes == (mqd_t)-1) {
perror(ERROR_PREFIX "mq_open");
unresolved = 1;
}
if (mq_send(mqdes, msgptr, strlen(msgptr), prio) != 0) {
perror(ERROR_PREFIX "mq_send");
unresolved = 1;
}
ts.tv_sec = time(NULL) + 1;
ts.tv_nsec = 0;
if (mq_timedreceive(mqdes, msgrv, BUFFER, NULL, &ts) > 0) {
printf("FAIL: mq_timedreceive succeed unexpectly\n");
failure = 1;
}
if (mq_close(mqdes) != 0) {
perror(ERROR_PREFIX "mq_close");
unresolved = 1;
}
if (mq_unlink(mqname) != 0) {
perror(ERROR_PREFIX "mq_unlink");
unresolved = 1;
}
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;
}
int main()
{
char qname[NAMESIZE];
const char *msgptr = MSGSTR;
struct timespec ts;
mqd_t queue;
int unresolved=0, failure=0;
struct mq_attr attr;
sprintf(qname, "/mq_timedsend_2-1_%d", getpid());
attr.mq_msgsize = MSGSIZE;
attr.mq_maxmsg = 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");
return PTS_UNRESOLVED;
}
ts.tv_sec=time(NULL)+1;
ts.tv_nsec=0;
if (mq_timedsend(queue, msgptr, strlen(msgptr), 1, &ts) == 0) {
printf("mq_timedsend() ret success w/msg_len>=mq_msgsize\n");
failure=1;
}
if (mq_close(queue) != 0) {
perror("mq_close() did not return success");
unresolved=1;
}
if (mq_unlink(qname) != 0) {
perror("mq_unlink() did not return success");
unresolved=1;
}
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;
}
int main(int argc, char *argv[])
{
if (2 != argc){
printf("usage: mqunlink <name>\n");
exit(1);
}
if (mq_unlink(argv[1]) == -1){
perror("mq_unlink failed");
exit(1);
}
exit(0);
}
void mymq_close(void) {
if(mqfd_s == -1 || mqfd_r==-1) {
return;
}
if (mq_close(mqfd_r) == -1)
perror("mq_close failure on mqfd_r");
if (mq_close(mqfd_s) == -1)
perror("mq_close failure on mqfd_s");
//FIXME : use mqID
// snprintf(qname,64,"/xjadeo-request%s%s", id?"-":"", id?(char*)id:"");
if (mq_unlink("/xjadeo-request") == -1)
perror("mq_unlink failure");
if (mq_unlink("/xjadeo-reply") == -1)
perror("mq_unlink failure");
if (!want_quiet)
printf("closed MQ remote control.\n");
mqfd_s=mqfd_r=-1;
}
int create_message_queue( struct mq_attr* attr) {
mq_unlink(IMG_MQ_SEND);
mq_unlink(IMG_MQ_RECEIVE);
msg_queue_send = mq_open(IMG_MQ_SEND, O_WRONLY | O_CREAT, S_IRWXU | S_IRWXG, attr);
if (msg_queue_send < 0) {
perror("Error Opening MQ: ");
return -1;
}
msg_queue_receive = mq_open(IMG_MQ_RECEIVE, O_RDONLY | O_CREAT |O_NONBLOCK, S_IRWXU | S_IRWXG, attr);
if (msg_queue_receive == -1) {
perror("Error Opening MQ: ");
return -1;
}
//create buffers
send_buffer = (MESSAGE *)malloc(MAX_MESSAGES_SIZE);
if (send_buffer == NULL){
APP_ERROR("malloc fail!");
return -1;
}
receive_buffer = (MESSAGE *)malloc(MAX_MESSAGES_SIZE);
if (receive_buffer == NULL){
APP_ERROR("malloc fail!");
return -1;
}
while (mq_receive(msg_queue_receive, (char *)receive_buffer, MAX_MESSAGES_SIZE, NULL) > 0){
APP_INFO("POLL QUEUE TO CLEAN!");
}
memset(send_buffer, 0, MAX_MESSAGES_SIZE);
memset(receive_buffer, 0, MAX_MESSAGES_SIZE);
//bind Receive callback
NotifySetup(&msg_queue_receive);
return 0;
}
static int32_t
posix_mq_create(struct qb_ipcs_connection *c,
struct qb_ipc_one_way *one_way, const char *name, size_t q_len)
{
struct mq_attr attr;
mqd_t q = 0;
int32_t res = 0;
mode_t m = 0600;
size_t max_msg_size = one_way->max_msg_size;
res = posix_mq_increase_limits(max_msg_size, q_len);
if (res != 0) {
return res;
}
try_smaller:
if (q != 0) {
max_msg_size = max_msg_size / 2;
q_len--;
}
attr.mq_flags = O_NONBLOCK;
attr.mq_maxmsg = q_len;
attr.mq_msgsize = max_msg_size;
q = mq_open(name, O_RDWR | O_CREAT | O_EXCL | O_NONBLOCK, m, &attr);
if (q == (mqd_t) - 1 && errno == ENOMEM) {
if (max_msg_size > 9000 && q_len > 3) {
goto try_smaller;
}
}
if (q == (mqd_t) - 1) {
res = -errno;
qb_util_perror(LOG_ERR, "Can't create mq \"%s\"", name);
return res;
}
q_space_used += max_msg_size * q_len;
one_way->max_msg_size = max_msg_size;
one_way->u.pmq.q = q;
(void)strlcpy(one_way->u.pmq.name, name, NAME_MAX);
res = fchown((int)q, c->euid, c->egid);
if (res == -1) {
res = -errno;
qb_util_perror(LOG_ERR, "fchown:%s", name);
mq_close(q);
mq_unlink(name);
}
return res;
}
int main()
{
char mqname[50] = "/123";
// sprintf(mqname, FUNCTION "_" TEST "_%d", getpid());
mq_unlink(mqname);
if (ENOENT == errno) {
printf("Test PASSED\n");
return PTS_PASS;
} else {
printf("Test FAILED, error is %s\n", strerror(errno));
return PTS_FAIL;
}
}
void
cleanup(iter_t iterations, void* cookie)
{
state_t * state = (state_t *)cookie;
if (iterations) return;
if (state->pid) {
kill(state->pid, SIGKILL);
waitpid(state->pid, NULL, 0);
state->pid = 0;
}
mq_close(state->mq);
mq_unlink("/testqueue");
}
int main(int argc, char * argv[])
{
int retval;
if (argc != 2) {
printf("usage: mqunlink <name>");
exit(0);
}
retval = mq_unlink(argv[1]);
if (retval != 0) {
fprintf(stderr,"unlink failed %d:%s\n", errno, (char *)strerror(errno));
return -2;
}
return 0;
}
void interface_closeServer()
{
if (fdCmdMq != (mqd_t)-1)
{
DEBUG(2, "closing cmd mq");
if (mq_close(fdCmdMq) == -1)
{
ERROR("error closing cmd mq");
}
DEBUG(2, "unlinking cmd mq");
if (mq_unlink(cmdname) == -1)
{
ERROR("error unlinking cmd mq");
}
fdCmdMq = (mqd_t)-1;
}
if (fdPubMq != (mqd_t)-1)
{
DEBUG(2, "closing pub fifo");
if (mq_close(fdPubMq) == -1)
{
ERROR("error closing pub fifo");
}
DEBUG(2, "unlinking pub fifo");
if (mq_unlink(pubname) == -1)
{
ERROR("error unlinking pub fifo");
}
fdPubMq = (mqd_t)-1;
}
}
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;
}
/*
* 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__);
}
void
VixMntMsgQue::unlink() {
std::map<std::string, mqd_t>::iterator itr =
VixMntMsgQue::vixMntMsgMap.begin();
while (itr != VixMntMsgQue::vixMntMsgMap.end()) {
if (mq_unlink(itr->first.c_str()) < 0) {
ILog("%s unlink faild.", itr->first.c_str());
} else {
ILog("%s unlink ok.", itr->first.c_str());
}
itr++;
}
VixMntMsgQue::vixMntMsgMap.clear();
}
int main()
{
int pid;
mqd_t mqd;
if (tst_kvercmp(2, 6, 30) < 0)
return 1;
mq_unlink("/checkmqnsenabled");
mqd =
mq_open("/checkmqnsenabled", O_RDWR | O_CREAT | O_EXCL, 0777, NULL);
if (mqd == -1) {
perror("mq_open");
return 3;
}
mq_close(mqd);
mq_unlink("/checkmqnsenabled");
pid = ltp_clone_quick(CLONE_NEWIPC, dummy, NULL);
if (pid == -1)
return 5;
return 0;
}
int main(int argc, char *argv[])
{
if( argc != 2 )
{
fprintf(stderr,"usage: %s name\n",argv[0]);
exit(EXIT_FAILURE);
}
if( mq_unlink(argv[1]) != 0 )
{
perror("perror");
exit(EXIT_FAILURE);
}
return 0;
}
int main(int argc, char *argv[])
{
struct mq_attr mqstat;
int oflag = O_CREAT | O_NONBLOCK | O_RDWR;
pthread_t sed[Max_Threads], rev[Max_Threads];
int ThreadID[Max_Threads];
int num, i;
/* #ifndef _POSIX_MESSAGE_PASSING
printf("_POSIX_MESSAGE_PASSING is not defined \n");
return PTS_UNRESOLVED;
#endif */
if ((2 != argc) || ((num = atoi(argv[1])) <= 0)) {
fprintf(stderr, "Usage: %s number_of_threads\n", argv[0]);
return PTS_FAIL;
}
if (num > Max_Threads) {
printf("The num of threads are too large. Reset to %d\n",
Max_Threads);
num = Max_Threads;
}
memset(&mqstat, 0, sizeof(mqstat));
mqstat.mq_maxmsg = MAX_MSG;
mqstat.mq_msgsize = MSG_SIZE;
mqstat.mq_flags = 0;
if ((mq = mq_open(MQ_NAME, oflag, 0777, &mqstat)) == (mqd_t)-1) {
printf("mq_open doesn't return success\n");
return PTS_UNRESOLVED;
}
for (i = 0; i < num; i++) {
ThreadID[i] = i;
pthread_create(&sed[i], NULL, (void *)send,
(void *)&ThreadID[i]);
pthread_create(&rev[i], NULL, (void *)receive,
(void *)&ThreadID[i]);
}
for (i = 0; i < num; i++) {
pthread_join(sed[i], NULL);
pthread_join(rev[i], NULL);
}
mq_close(mq);
mq_unlink(MQ_NAME);
return PTS_PASS;
}
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);
}
int main()
{
int i;
mqd_t mq = mq_open("/temp.1234", O_CREAT|O_RDWR, 0660, NULL);
printf("mq=%d\n", mq);
mq_close(mq);
mq_unlink("/temp.1234");
int msgid;
for(i = 0; i < 1; i++)
{
//msgid = msgget(ftok("/tmp", 1),IPC_CREAT|0660 );
printf("msgid=%d\n", msgid);
msgctl(163840, IPC_RMID, NULL);
}
return 0;
}
void sig_handler(int signum) {
if (signum != SIGINT) {
printf("Received invalid signum = %d in sig_handler()\n", signum);
ASSERT(signum == SIGINT);
}
printf("Received SIGINT. Exiting Application\n");
pthread_cancel(thread1);
pthread_cancel(cam);
mq_close(cam_mq);
mq_unlink(CAM_MQ_NAME);
exit(0);
}
