1 use std::ffi::CString;
2 use std::str;
3
4 use nix::errno::Errno;
5 use nix::mqueue::{mq_open, mq_close, mq_send, mq_receive, mq_attr_member_t};
6 use nix::mqueue::{MqAttr, MQ_OFlag};
7 use nix::sys::stat::Mode;
8
9 #[test]
test_mq_send_and_receive()10 fn test_mq_send_and_receive() {
11 const MSG_SIZE: mq_attr_member_t = 32;
12 let attr = MqAttr::new(0, 10, MSG_SIZE, 0);
13 let mq_name= &CString::new(b"/a_nix_test_queue".as_ref()).unwrap();
14
15 let oflag0 = MQ_OFlag::O_CREAT | MQ_OFlag::O_WRONLY;
16 let mode = Mode::S_IWUSR | Mode::S_IRUSR | Mode::S_IRGRP | Mode::S_IROTH;
17 let r0 = mq_open(mq_name, oflag0, mode, Some(&attr));
18 if let Err(Errno::ENOSYS) = r0 {
19 println!("message queues not supported or module not loaded?");
20 return;
21 };
22 let mqd0 = r0.unwrap();
23 let msg_to_send = "msg_1";
24 mq_send(mqd0, msg_to_send.as_bytes(), 1).unwrap();
25
26 let oflag1 = MQ_OFlag::O_CREAT | MQ_OFlag::O_RDONLY;
27 let mqd1 = mq_open(mq_name, oflag1, mode, Some(&attr)).unwrap();
28 let mut buf = [0u8; 32];
29 let mut prio = 0u32;
30 let len = mq_receive(mqd1, &mut buf, &mut prio).unwrap();
31 assert_eq!(prio, 1);
32
33 mq_close(mqd1).unwrap();
34 mq_close(mqd0).unwrap();
35 assert_eq!(msg_to_send, str::from_utf8(&buf[0..len]).unwrap());
36 }
37
38
39 #[test]
40 #[cfg(not(any(target_os = "netbsd")))]
test_mq_getattr()41 fn test_mq_getattr() {
42 use nix::mqueue::mq_getattr;
43 const MSG_SIZE: mq_attr_member_t = 32;
44 let initial_attr = MqAttr::new(0, 10, MSG_SIZE, 0);
45 let mq_name = &CString::new(b"/attr_test_get_attr".as_ref()).unwrap();
46 let oflag = MQ_OFlag::O_CREAT | MQ_OFlag::O_WRONLY;
47 let mode = Mode::S_IWUSR | Mode::S_IRUSR | Mode::S_IRGRP | Mode::S_IROTH;
48 let r = mq_open(mq_name, oflag, mode, Some(&initial_attr));
49 if let Err(Errno::ENOSYS) = r {
50 println!("message queues not supported or module not loaded?");
51 return;
52 };
53 let mqd = r.unwrap();
54
55 let read_attr = mq_getattr(mqd).unwrap();
56 assert_eq!(read_attr, initial_attr);
57 mq_close(mqd).unwrap();
58 }
59
60 // FIXME: Fix failures for mips in QEMU
61 #[test]
62 #[cfg(not(any(target_os = "netbsd")))]
63 #[cfg_attr(all(
64 qemu,
65 any(target_arch = "mips", target_arch = "mips64")
66 ), ignore
67 )]
test_mq_setattr()68 fn test_mq_setattr() {
69 use nix::mqueue::{mq_getattr, mq_setattr};
70 const MSG_SIZE: mq_attr_member_t = 32;
71 let initial_attr = MqAttr::new(0, 10, MSG_SIZE, 0);
72 let mq_name = &CString::new(b"/attr_test_get_attr".as_ref()).unwrap();
73 let oflag = MQ_OFlag::O_CREAT | MQ_OFlag::O_WRONLY;
74 let mode = Mode::S_IWUSR | Mode::S_IRUSR | Mode::S_IRGRP | Mode::S_IROTH;
75 let r = mq_open(mq_name, oflag, mode, Some(&initial_attr));
76 if let Err(Errno::ENOSYS) = r {
77 println!("message queues not supported or module not loaded?");
78 return;
79 };
80 let mqd = r.unwrap();
81
82 let new_attr = MqAttr::new(0, 20, MSG_SIZE * 2, 100);
83 let old_attr = mq_setattr(mqd, &new_attr).unwrap();
84 assert_eq!(old_attr, initial_attr);
85
86 let new_attr_get = mq_getattr(mqd).unwrap();
87 // The following tests make sense. No changes here because according to the Linux man page only
88 // O_NONBLOCK can be set (see tests below)
89 assert_ne!(new_attr_get, new_attr);
90
91 let new_attr_non_blocking = MqAttr::new(MQ_OFlag::O_NONBLOCK.bits() as mq_attr_member_t, 10, MSG_SIZE, 0);
92 mq_setattr(mqd, &new_attr_non_blocking).unwrap();
93 let new_attr_get = mq_getattr(mqd).unwrap();
94
95 // now the O_NONBLOCK flag has been set
96 assert_ne!(new_attr_get, initial_attr);
97 assert_eq!(new_attr_get, new_attr_non_blocking);
98 mq_close(mqd).unwrap();
99 }
100
101 // FIXME: Fix failures for mips in QEMU
102 #[test]
103 #[cfg(not(any(target_os = "netbsd")))]
104 #[cfg_attr(all(
105 qemu,
106 any(target_arch = "mips", target_arch = "mips64")
107 ), ignore
108 )]
test_mq_set_nonblocking()109 fn test_mq_set_nonblocking() {
110 use nix::mqueue::{mq_getattr, mq_set_nonblock, mq_remove_nonblock};
111 const MSG_SIZE: mq_attr_member_t = 32;
112 let initial_attr = MqAttr::new(0, 10, MSG_SIZE, 0);
113 let mq_name = &CString::new(b"/attr_test_get_attr".as_ref()).unwrap();
114 let oflag = MQ_OFlag::O_CREAT | MQ_OFlag::O_WRONLY;
115 let mode = Mode::S_IWUSR | Mode::S_IRUSR | Mode::S_IRGRP | Mode::S_IROTH;
116 let r = mq_open(mq_name, oflag, mode, Some(&initial_attr));
117 if let Err(Errno::ENOSYS) = r {
118 println!("message queues not supported or module not loaded?");
119 return;
120 };
121 let mqd = r.unwrap();
122 mq_set_nonblock(mqd).unwrap();
123 let new_attr = mq_getattr(mqd);
124 assert_eq!(new_attr.unwrap().flags(), MQ_OFlag::O_NONBLOCK.bits() as mq_attr_member_t);
125 mq_remove_nonblock(mqd).unwrap();
126 let new_attr = mq_getattr(mqd);
127 assert_eq!(new_attr.unwrap().flags(), 0);
128 mq_close(mqd).unwrap();
129 }
130
131 #[test]
132 #[cfg(not(any(target_os = "netbsd")))]
test_mq_unlink()133 fn test_mq_unlink() {
134 use nix::mqueue::mq_unlink;
135 const MSG_SIZE: mq_attr_member_t = 32;
136 let initial_attr = MqAttr::new(0, 10, MSG_SIZE, 0);
137 let mq_name_opened = &CString::new(b"/mq_unlink_test".as_ref()).unwrap();
138 let mq_name_not_opened = &CString::new(b"/mq_unlink_test".as_ref()).unwrap();
139 let oflag = MQ_OFlag::O_CREAT | MQ_OFlag::O_WRONLY;
140 let mode = Mode::S_IWUSR | Mode::S_IRUSR | Mode::S_IRGRP | Mode::S_IROTH;
141 let r = mq_open(mq_name_opened, oflag, mode, Some(&initial_attr));
142 if let Err(Errno::ENOSYS) = r {
143 println!("message queues not supported or module not loaded?");
144 return;
145 };
146 let mqd = r.unwrap();
147
148 let res_unlink = mq_unlink(mq_name_opened);
149 assert_eq!(res_unlink, Ok(()) );
150
151 let res_unlink_not_opened = mq_unlink(mq_name_not_opened);
152 assert_eq!(res_unlink_not_opened, Err(Errno::ENOENT) );
153
154 mq_close(mqd).unwrap();
155 let res_unlink_after_close = mq_unlink(mq_name_opened);
156 assert_eq!(res_unlink_after_close, Err(Errno::ENOENT) );
157 }
158