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