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;
} else {
if (EMSGSIZE != errno) {
printf("errno != EMSGSIZE\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;
}
InstrumentationRuntime::~InstrumentationRuntime()
{
int err = mq_close(messageQueue);
if(err < 0)
report( "Failed to close message queue" );
lynx::clearInstrumentors();
instrumentationContexts.clear();
}
int main()
{
char mqname[NAMESIZE];
mqd_t mqdes;
struct mq_attr omqstat, 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, 0);
if (mqdes == (mqd_t)-1) {
perror("mq_open() did not return success");
return PTS_UNRESOLVED;
}
memset(&mqstat,0,sizeof(mqstat));
memset(&omqstat,0,sizeof(omqstat));
memset(&nmqstat,0,sizeof(nmqstat));
if (mq_getattr(mqdes, &omqstat) == -1) {
perror("mq_getattr() did not return success");
unresolved = 1;
}
if (mq_unlink(mqname) != 0) {
perror("mq_unlink()");
return PTS_UNRESOLVED;
}
nmqstat.mq_flags = MQFLAGS;
nmqstat.mq_maxmsg = MQMAXMSG;
nmqstat.mq_msgsize = MQMSGSIZE;
nmqstat.mq_curmsgs = MQCURMSGS;
if (mq_setattr(mqdes, &nmqstat, &mqstat) != 0) {
failure = 1;
}
if ((omqstat.mq_flags != mqstat.mq_flags)||
(omqstat.mq_maxmsg != mqstat.mq_maxmsg)||
(omqstat.mq_msgsize != mqstat.mq_msgsize)||
(omqstat.mq_curmsgs != mqstat.mq_curmsgs)) {
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 qname[NAMESIZE], msgrcd[BUFFER];
const char *msgptr = MSGSTR;
mqd_t queue;
struct mq_attr attr;
int unresolved=0, failure=0;
unsigned pri;
sprintf(qname, "/mq_send_4-3_%d", getpid());
attr.mq_msgsize = BUFFER;
attr.mq_maxmsg = MAXMSG;
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;
}
if (mq_send(queue, msgptr, strlen(msgptr), MQ_PRIO_MAX-1) != 0) {
perror("mq_send() did not return success");
failure=1;
}
if (mq_receive(queue, msgrcd, BUFFER, &pri) == -1) {
perror("mq_receive() returned failure");
failure=1;
}
if (strncmp(msgptr, msgrcd, strlen(msgptr)) != 0) {
printf("FAIL: sent %s received %s\n", msgptr, msgrcd);
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 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);
}
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 *argv[])
{
int oflags = O_WRONLY;
mqd_t msg_queue = mq_open(argv[argc-1],oflags);
if( msg_queue < 0 )
{
perror("perror");
exit(EXIT_FAILURE);
};
struct mq_attr mqueue_attr;
if( mq_getattr(msg_queue,&mqueue_attr) < 0)
{
perror("perror");
exit(EXIT_FAILURE);
}
int maxsize = mqueue_attr.mq_msgsize;
char *massage = malloc(maxsize);
int priority=0;
int opt;
/* suppress the error massage*/
//opterr = 0;
while((opt = getopt(argc,argv,"m:p:")) != -1 )
{
switch ( opt )
{
case 'm' :
strcpy(massage,optarg);
break;
case 'p' :
priority = atoi(optarg);
break;
default : /* '?' */
fprintf(stderr,"usage: %s <-m massage> [-p priority] name\n",argv[0]);
exit(EXIT_FAILURE);
}
}
if( optind >= argc )
{
fprintf(stderr,"usage: %s <-m massage> [-p priority] name\n",argv[0]);
exit(EXIT_FAILURE);
}
if( mq_send(msg_queue,massage,maxsize,priority) < 0)
{
perror("perror");
exit(EXIT_FAILURE);
}
free(massage);
mq_close(msg_queue);
return 0;
}
void
fmd_adm_close(fmd_adm_t *ap)
{
mqd_t mqd = ap->adm_mqd;
if (ap == NULL)
return; /* permit NULL to simply caller code */
mq_close(mqd);
free(ap);
}
static void
qb_ipcs_pmq_disconnect(struct qb_ipcs_connection *c)
{
struct qb_ipc_response_header msg;
msg.id = QB_IPC_MSG_DISCONNECT;
msg.size = sizeof(msg);
msg.error = 0;
(void)qb_ipc_pmq_send(&c->event, &msg, msg.size);
mq_close(c->event.u.pmq.q);
mq_close(c->response.u.pmq.q);
mq_close(c->request.u.pmq.q);
mq_unlink(c->event.u.pmq.name);
mq_unlink(c->request.u.pmq.name);
mq_unlink(c->response.u.pmq.name);
}
int mqsend(const char* name, size_t len)
{
mqd_t mqd;
void *ptr;
mqd = mq_open(name, O_WRONLY);
ptr = malloc(sizeof(char)*len);
int ret = mq_send(mqd, ptr, len, 0);
mq_close(mqd);
return ret;
}
void
llc_service_llc_thread_cleanup(void *arg)
{
/*
* Beware:
* The cleanup routine is called while sem_log is held. Trying ot log some
* information using log4c will lead to a deadlock.
*/
struct llc_link *link = (struct llc_link *)arg;
if (link->llc_up != (mqd_t) - 1)
mq_close(link->llc_up);
if (link->llc_down != (mqd_t) - 1)
mq_close(link->llc_down);
link->llc_up = (mqd_t) - 1;
link->llc_down = (mqd_t) - 1;
}
void closeConnection(int clientID)
{
mqd_t clientDesc = clients[clientID];
printf("Closing client %d queue\n", clientID);
if(mq_close(clientDesc) == -1) {
printf("Error while closing connection with client %d!", clientID);
}
clients[clientID] = -1;
}
void do_close()
{
streamDescriptor.cancel();
if (mqid >= 0)
{
mq_close(mqid);
mqid = -1;
}
cond.notify_all();
}
CAMLprim value
caml_backpack_mq_close(value val_mq)
{
CAMLparam1(val_mq);
if (mq_close(Int_val(val_mq)) == -1)
uerror("mq_close", Nothing);
CAMLreturn(Val_unit);
}
void mqcreate(char* name)
{
int flags;
mqd_t mqd;
flags = O_RDWR | O_CREAT | O_EXCL;
mqd = mq_open(name, flags, FILE_MODE, NULL);
if(mqd == -1)
printf("Error num:%d\n", errno);
mq_close(mqd);
}
int main()
{
char qname[NAMESIZE];
const char *msgptr = MSGSTR;
struct timespec ts;
mqd_t queue;
int unresolved=0, failure=0, i;
sprintf(qname, "/mq_timedsend_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;
}
ts.tv_sec=time(NULL)+1;
ts.tv_nsec=0;
for (i=0; i<NUMINVALID; i++) {
if (mq_timedsend(queue, msgptr,
strlen(msgptr), invalidpri[i], &ts)== 0) {
printf("mq_timedsend() ret 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;
}
void *ClockChrono_Read(void *args)
{
RT_TASK *mytask;
char ch;
int run = 0;
mqd_t Keyboard;
struct mq_attr kb_attrs = { MAX_MSGS, 1, 0, 0 };
if (!(mytask = rt_thread_init(nam2num("READ"), 1, 0, SCHED_FIFO, 0xF))) {
printf("CANNOT INIT TASK ClockChronoRead\n");
exit(1);
}
Keyboard = mq_open("KEYBRD", O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP, &kb_attrs);
printf("INIT TASK ClockChronoRead %p.\n", mytask);
mlockall(MCL_CURRENT | MCL_FUTURE);
while(1) {
mq_receive(Keyboard, &ch, 1, NULL);
ch = toupper(ch);
switch(ch) {
case 'T': case 'R': case 'H': case 'M': case 'S':
CommandClock_Put(ch);
break;
case 'C': case 'I': case 'E':
CommandChrono_Put(ch);
break;
case 'N':
hide = ~hide;
break;
case 'P':
Pause = TRUE;
rt_fractionated_sleep(nano2count(FIVE_SECONDS));
Pause = FALSE;
break;
case 'K': case 'D':
run |= ch;
if (run == ('K' | 'D')) {
sem_post(&sync_sem);
sem_post(&sync_sem);
}
break;
case 'F':
CommandClock_Put('F');
CommandChrono_Put('F');
goto end;
}
}
end:
mq_close(Keyboard);
rt_task_delete(mytask);
printf("END TASK ClockChronoRead %p.\n", mytask);
return 0;
}
NFCSTATUS phDal4Nfc_ConfigRelease(void *pHwRef)
{
NFCSTATUS result = NFCSTATUS_SUCCESS;
void * pThreadReturn;
DAL_PRINT("phDal4Nfc_ConfigRelease ");
if (gDalContext.hw_valid == TRUE)
{
/* Signal the read and write threads to exit. NOTE: there
actually is no write thread! :) */
DAL_PRINT("Stop Reader Thread");
gReadWriteContext.nReadThreadAlive = 0;
gReadWriteContext.nWriteThreadAlive = 0;
/* Wake up the read thread so it can exit */
DAL_PRINT("Release Read Semaphore");
sem_post(&nfc_read_sem);
DAL_DEBUG("phDal4Nfc_ConfigRelease - doing pthread_join(%d)",
gReadWriteContext.nReadThread);
if (pthread_join(gReadWriteContext.nReadThread, &pThreadReturn) != 0)
{
result = PHNFCSTVAL(CID_NFC_DAL, NFCSTATUS_FAILED);
DAL_PRINT("phDal4Nfc_ConfigRelease KO");
}
/* Close the message queue */
#ifdef USE_MQ_MESSAGE_QUEUE
mq_close(nDeferedCallMessageQueueId);
#endif
/* Shutdown NFC Chip */
phDal4Nfc_Reset(0);
/* Close the link */
gLinkFunc.close();
if (gDalContext.pDev != NULL) {
nfc_pn544_close(gDalContext.pDev);
}
/* Reset the Read Writer context to NULL */
memset((void *)&gReadWriteContext,0,sizeof(gReadWriteContext));
/* Reset the DAL context values to NULL */
memset((void *)&gDalContext,0,sizeof(gDalContext));
}
gDalContext.hw_valid = FALSE;
DAL_DEBUG("phDal4Nfc_ConfigRelease(): %04x\n", result);
return result;
}
int main()
{
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, 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;
}
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 = 0;
if (mq_timedreceive(mqdes, msgrv, BUFFER, &rvprio, &ts) == -1) {
perror("FAIL: mq_receive fails 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(){
mqd_t mq;
struct mq_attr attr;
char QUEUE_NAME[] = "/test1";
ssize_t bytes_read;
int ret;
struct timespec looptime;
looptime.tv_sec = 1;
looptime.tv_nsec = 0;
testStruct msg;
/* initialize the queue attributes */
attr.mq_flags = 0;
attr.mq_maxmsg = 1;
attr.mq_msgsize = sizeof(testStruct);
attr.mq_curmsgs = 0;
//mq_unlink(QUEUE_NAME);
/* create the message queue */
mq = mq_open(QUEUE_NAME, O_WRONLY|O_NONBLOCK);
int i;
for(i = 0; i < 10; i++)
{
msg.a = i+1;
msg.b = i+11;
ret = clock_nanosleep(CLOCK_REALTIME, NULL, &looptime, NULL);
if(ret < 0)
{
printf("Problem with sleep\n");
}
/* send the message */
bytes_read = mq_send(mq, (char *) &msg, 8, NULL);
if(bytes_read < 0)
{
perror("");
printf("error sending value to queue\n");
}
else
{
printf("sent: %d, %d\n",msg.a, msg.b);
}
}
mq_close(mq);
return 0;
};
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, 0);
if (mqdes == (mqd_t)-1) {
perror("mq_open() did not return success");
return PTS_UNRESOLVED;
}
memset(&mqstat,0,sizeof(mqstat));
memset(&nmqstat,0,sizeof(mqstat));
if (mq_getattr(mqdes, &mqstat) == -1) {
perror(ERROR_PREFIX "mq_getattr");
unresolved = 1;
}
mqstat.mq_maxmsg = mqstat.mq_maxmsg + 1;
mqstat.mq_msgsize = mqstat.mq_msgsize + 1;
mqstat.mq_curmsgs = mqstat.mq_curmsgs + 1;
if (mq_setattr(mqdes, &mqstat, NULL) != 0) {
perror(ERROR_PREFIX "mq_setattr()");
failure = 1;
}
if (mq_getattr(mqdes, &nmqstat) == -1) {
perror(ERROR_PREFIX "mq_getattr()");
unresolved = 1;
}
if ((nmqstat.mq_maxmsg == mqstat.mq_maxmsg)||
(nmqstat.mq_msgsize == mqstat.mq_msgsize)||
(nmqstat.mq_curmsgs == mqstat.mq_curmsgs)) {
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;
}
/*
* Cleanup event receive.
*/
static void
deinit_event_rx(UAMP_STATE *uamp)
{
/* Cleanup the message queue. */
mq_close(uamp->evt_q);
mq_unlink(UAMP_EVT_Q_STR);
/* Kill the receive thread. */
write(uamp->evt_fd_pipe[1], NULL, 0);
close(uamp->evt_fd_pipe[1]);
}
int main(void)
{
mqd_t mqid;
mqid = mq_open("/abc", O_CREAT | O_RDWR, 0666, NULL);
if (mqid == (mqd_t)-1)
ERR_EXIT("mq_open");
printf("mq_open succ\n");
mq_close(mqid);
return 0;
}
/* called by GC */
static void _free(void *ptr)
{
struct posix_mq *mq = ptr;
if (mq->des != MQD_INVALID && MQ_IO_NIL_P(mq)) {
/* we ignore errors when gc-ing */
if (mq->autoclose)
mq_close(mq->des);
errno = 0;
}
xfree(ptr);
}
void cs_open(const char* name, int value)
{
struct mq_attr attr;
attr.mq_flags = 0;
attr.mq_msgsize = 1;
attr.mq_maxmsg = value;
attr.mq_curmsgs = 0;
mqd_t mq = mq_open(name, O_CREAT | O_RDWR | O_EXCL, 0660, &attr);
for(int i = 0;i < value; i++)
mq_send(mq, "X", 1, 0);
mq_close(mq);
}
int main()
{
mqd_t mqd;
struct mq_attr attr;
int ret;
char msg_buff[MQ_MESSAGE_MAX_LENGTH];
ssize_t msg_len;
/* Form the queue attributes */
attr.mq_flags = 0; /* i.e mq_send will be block if message queue is full */
attr.mq_maxmsg = MQ_MAX_NUM_OF_MESSAGES;
attr.mq_msgsize = MQ_MESSAGE_MAX_LENGTH;
attr.mq_curmsgs = 0; /* mq_curmsgs is dont care */
/* Create message queue */
mqd = mq_open(MQ_NAME, O_RDONLY | O_CREAT, MQ_MODE, &attr);
if( mqd != (mqd_t)-1 )
{
printf(" Message Queue Opened\n");
printf(" Receiving message .... \n");
msg_len = mq_receive(mqd, msg_buff, MQ_MESSAGE_MAX_LENGTH, NULL);
if(msg_len < 0)
{
perror(" Failed");
}
else
{
msg_buff[MQ_MESSAGE_MAX_LENGTH-1] = '\0';
printf(" Successfully received %d bytes\n", (int)msg_len);
printf(" Message : %s \n", msg_buff);
}
/* Close the message queue */
ret = mq_close(mqd);
if(ret)
perror(" Message queue close failed");
else
printf(" Message Queue Closed\n");
ret = mq_unlink(MQ_NAME);
if(ret)
perror(" Message queue unlink failed");
else
printf(" Message Queue unlinked\n");
}
else
{
perror(" Message queue open failed ");
}
return 0;
}
int __destr_mq(int from_id) {
mqd_t mqd;
string mq_name;
if ((mqd = __get_mqd(from_id, false)) == (mqd_t)-1) {
return -1;
}
mq_close(mqd);
mq_name = __as_mq_name(from_id);
return mq_unlink(mq_name);
}
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, 0);
if (mqdes == (mqd_t)-1) {
perror("mq_open() did not return success");
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) != 0) {
perror(ERROR_PREFIX "mq_setattr");
failure = 1;
}
if (mq_getattr(mqdes, &nmqstat) == -1) {
perror(ERROR_PREFIX "mq_getattr");
unresolved = 1;
}
mq_close(mqdes);
if (mq_unlink(mqname) != 0) {
perror(ERROR_PREFIX "mq_unlink");
return PTS_UNRESOLVED;
}
if (nmqstat.mq_flags != mqstat.mq_flags) {
printf("FAIL: mq_flags getted is %ld , while mq_flags "
"setted is %ld\n", nmqstat.mq_flags, mqstat.mq_flags);
failure = 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];
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;
}
int main(int argc, char *argv[])
{
mqd_t mqd;
int retval = 0;
size_t len;
unsigned int prio;
char *ptr;
if (argc != 4) {
printf("usage:mq_send <name> <byte> <priority>");
exit(1);
}
len = atoi(argv[2]);
prio = atoi(argv[3]);
/*
*以只写模式打开消息队列
*/
mqd = mq_open(argv[1], O_WRONLY);
if (mqd == -1) {
perror("打开消息队列失败");
exit(1);
}
/*
* 动态申请一块内存空间
* */
ptr = calloc(len, sizeof(char));
if (ptr == NULL) {
perror("申请空间失败");
mq_close(mqd);
exit(1);
}
retval = mq_send(mqd, ptr, len, prio);
if (retval == -1) {
perror("消息发送失败");
mq_close(mqd);
exit(1);
}
free(ptr);//释放内存
return 0;
}
