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; }