permissioner

1) /**
2)  * Permissioner: set file ownerships and permissions
3)  * Copyright 2020: Stefan Schuermans, Aachen, Germany <stefan@schuermans.info>
4)  * Copyleft: GNU GENERAL PUBLIC LICENSE version 3 (see LICENSE)
5)  */
6) 

7) #include <permissioner/Config.h>

8) #include <permissioner/Group.h>
9) #include <permissioner/Permissions.h>
10) #include <permissioner/Tree.h>

11) #include <permissioner/User.h>

12) 

13) #include <boost/filesystem.hpp>
14) #include <boost/optional.hpp>
15) #include <boost/optional/optional_io.hpp>

16) #include <cstdlib>

17) #include <iomanip>
18) #include <iostream>
19) #include <string>
20) 

21) int testEmpty() {
22)   Config config;
23)   config.parseFile("empty.cfg");
24) 
25)   int ret = EXIT_SUCCESS;
26) 
27)   Nice const &nice = config.getNice();
28)   if (nice.getNice().is_initialized()) {
29)     std::cerr << "unexpected nice value: " << nice.getNice().get() << std::endl;
30)     ret = EXIT_FAILURE;
31)   }
32)   if (nice.getIoIdle()) {
33)     std::cerr << "unexpected I/O idle" << std::endl;
34)     ret = EXIT_FAILURE;
35)   }
36) 

37)   float sleepTime = config.getSleepTime().get();
38)   if (sleepTime != 1.0e-6f) {
39)     std::cerr << "unexpected sleepTime " << sleepTime << ", expected "
40)               << 1.0e-6f << std::endl;
41)     ret = EXIT_FAILURE;
42)   }
43)   float waitFactor = config.getWaitFactor().get();
44)   if (waitFactor != 10.0f) {
45)     std::cerr << "unexpected waitFactor " << waitFactor << ", expected "
46)               << 10.0f << std::endl;
47)     ret = EXIT_FAILURE;
48)   }
49)   float waitTime = config.getWaitTime().get();
50)   if (waitTime != 1.0f) {
51)     std::cerr << "unexpected waitTime " << waitTime << ", expected " << 1.0f
52)               << std::endl;
53)     ret = EXIT_FAILURE;
54)   }
55) 

56)   TreeMap const &treeMap = config.getTrees();
57)   if (treeMap.size() != 0) {
58)     std::cerr << "unexpected trees: " << treeMap.size() << std::endl;
59)     ret = EXIT_FAILURE;
60)   }
61) 
62)   return ret;
63) }
64) 
65) int testNice() {
66)   int ret = EXIT_SUCCESS;
67) 
68)   {
69)     Config config;
70)     config.parseFile("nice.cfg");
71) 
72)     Nice const &nice = config.getNice();
73)     if (!nice.getNice().is_initialized()) {
74)       std::cerr << "expected nice value, but got none" << std::endl;
75)       ret = EXIT_FAILURE;
76)     } else {
77)       if (nice.getNice().get() != 19) {
78)         std::cerr << "unexpected nice value: " << nice.getNice().get()
79)                   << ", expected 19" << std::endl;
80)         ret = EXIT_FAILURE;
81)       }
82)     }
83)     if (nice.getIoIdle()) {
84)       std::cerr << "unexpected I/O idle" << std::endl;
85)       ret = EXIT_FAILURE;
86)     }
87)   }
88) 
89)   {
90)     Config config;
91)     config.parseFile("idle.cfg");
92) 
93)     Nice const &nice = config.getNice();
94)     if (nice.getNice().is_initialized()) {
95)       std::cerr << "unexpected nice value: " << nice.getNice().get()
96)                 << std::endl;
97)       ret = EXIT_FAILURE;
98)     }
99)     if (!nice.getIoIdle()) {
100)       std::cerr << "expected I/O idle, but did not get it" << std::endl;
101)       ret = EXIT_FAILURE;
102)     }
103)   }
104) 
105)   {
106)     Config config;
107)     config.parseFile("nice_idle.cfg");
108) 
109)     Nice const &nice = config.getNice();
110)     if (!nice.getNice().is_initialized()) {
111)       std::cerr << "expected nice value, but got none" << std::endl;
112)       ret = EXIT_FAILURE;
113)     } else {
114)       if (nice.getNice().get() != 19) {
115)         std::cerr << "unexpected nice value: " << nice.getNice().get()
116)                   << ", expected 19" << std::endl;
117)         ret = EXIT_FAILURE;
118)       }
119)     }
120)   }
121) 
122)   return ret;
123) }
124) 

125) int testSleepWait() {
126)   Config config;
127)   config.parseFile("sleep_wait.cfg");
128) 
129)   int ret = EXIT_SUCCESS;
130) 
131)   float sleepTime = config.getSleepTime().get();
132)   if (sleepTime != 42.42e-3f) {
133)     std::cerr << "unexpected sleepTime " << sleepTime << ", expected "
134)               << 42.42e-3f << std::endl;
135)     ret = EXIT_FAILURE;
136)   }
137)   float waitFactor = config.getWaitFactor().get();
138)   if (waitFactor != 5.5f) {
139)     std::cerr << "unexpected waitFactor " << waitFactor << ", expected "
140)               << 5.5f << std::endl;
141)     ret = EXIT_FAILURE;
142)   }
143)   float waitTime = config.getWaitTime().get();
144)   if (waitTime != 23.23f) {
145)     std::cerr << "unexpected waitTime " << waitTime << ", expected " << 23.23f
146)               << std::endl;
147)     ret = EXIT_FAILURE;
148)   }
149) 
150)   return ret;
151) }
152) 

153) bool checkTrees(TreeMap const &treeMap, std::string const &rel_path,
154)                 boost::optional<std::string> user,
155)                 boost::optional<std::string> group, mode_t setMode,
156)                 mode_t setCondMode, mode_t clearMode, mode_t clearCondMode) {

157)   std::string path = boost::filesystem::canonical(rel_path).string();
158)   TreeMap::const_iterator itTree = treeMap.find(path);
159)   if (itTree == treeMap.end()) {
160)     std::cerr << "tree map entry \"" << path << "\" not found" << std::endl;
161)     return false;
162)   }
163)   Tree const &tree = itTree->second;
164) 
165)   bool ret = true;
166) 
167)   if (tree.getRoot() != path) {
168)     std::cerr << "tree map entry \"" << path << "\": unexpected root \""
169)               << tree.getRoot() << "\"" << std::endl;
170)     ret = false;
171)   }
172)   if (tree.getUser().getUserName() != user) {
173)     std::cerr << "tree map entry \"" << path << "\": unexpected user \""
174)               << tree.getUser().getUserName() << "\"" << std::endl;
175)     ret = false;
176)   }
177)   if (tree.getGroup().getGroupName() != group) {
178)     std::cerr << "tree map entry \"" << path << "\": unexpected group \""
179)               << tree.getGroup().getGroupName() << "\"" << std::endl;
180)     ret = false;
181)   }
182)   Permissions const &perms = tree.getPermissions();
183)   if (perms.getSet() != setMode) {

184)     std::cerr << "tree map entry \"" << path << "\": unexpected set mode "
185)               << std::oct << perms.getSet() << " != " << setMode << std::dec
186)               << std::endl;

187)     ret = false;
188)   }
189)   if (perms.getSetCond() != setCondMode) {

190)     std::cerr << "tree map entry \"" << path << "\": unexpected set cond mode "

191)               << std::oct << perms.getSetCond() << " != " << setCondMode
192)               << std::dec << std::endl;
193)     ret = false;
194)   }
195)   if (perms.getClear() != clearMode) {

196)     std::cerr << "tree map entry \"" << path << "\": unexpected clear mode "
197)               << std::oct << perms.getClear() << " != " << clearMode << std::dec
198)               << std::endl;

199)     ret = false;
200)   }
201)   if (perms.getClearCond() != clearCondMode) {
202)     std::cerr << "tree map entry \"" << path

203)               << "\": unexpected clear cond mode " << std::oct
204)               << perms.getClearCond() << " != " << clearCondMode << std::dec
205)               << std::endl;

206)     ret = false;
207)   }
208) 
209)   return ret;
210) }

211) 

212) int testTrees() {

213)   Config config;

214)   config.parseFile("trees.cfg");

215) 
216)   int ret = EXIT_SUCCESS;
217) 
218)   TreeMap const &treeMap = config.getTrees();
219)   if (treeMap.size() != 2) {
220)     std::cerr << "unexpected number of trees: " << treeMap.size() << std::endl;
221)     ret = EXIT_FAILURE;
222)   }

223)   if (!checkTrees(treeMap, "some/dir", std::string("nobody"),
224)                   std::string("nogroup"), 0011, 0044, 0022, 000)) {

225)     ret = EXIT_FAILURE;
226)   }

227)   if (!checkTrees(treeMap, "some/other/dir", boost::none, boost::none, 0777,
228)                   0000, 0000, 0000)) {

229)     ret = EXIT_FAILURE;
230)   }
231) 
232)   return ret;

233) }

234) 
235) void merge_ret(int &ret, int ret2) {
236)   if (ret == EXIT_SUCCESS && ret2 != EXIT_SUCCESS) {
237)     ret = ret2;
238)   }
239) }
240) 
241) int main() {
242)   int ret = EXIT_SUCCESS;
243)   merge_ret(ret, testEmpty());
244)   merge_ret(ret, testNice());

245)   merge_ret(ret, testSleepWait());