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)   TreeMap const &treeMap = config.getTrees();
38)   if (treeMap.size() != 0) {
39)     std::cerr << "unexpected trees: " << treeMap.size() << std::endl;
40)     ret = EXIT_FAILURE;
41)   }
42) 
43)   return ret;
44) }
45) 
46) int testNice() {
47)   int ret = EXIT_SUCCESS;
48) 
49)   {
50)     Config config;
51)     config.parseFile("nice.cfg");
52) 
53)     Nice const &nice = config.getNice();
54)     if (!nice.getNice().is_initialized()) {
55)       std::cerr << "expected nice value, but got none" << std::endl;
56)       ret = EXIT_FAILURE;
57)     } else {
58)       if (nice.getNice().get() != 19) {
59)         std::cerr << "unexpected nice value: " << nice.getNice().get()
60)                   << ", expected 19" << std::endl;
61)         ret = EXIT_FAILURE;
62)       }
63)     }
64)     if (nice.getIoIdle()) {
65)       std::cerr << "unexpected I/O idle" << std::endl;
66)       ret = EXIT_FAILURE;
67)     }
68)   }
69) 
70)   {
71)     Config config;
72)     config.parseFile("idle.cfg");
73) 
74)     Nice const &nice = config.getNice();
75)     if (nice.getNice().is_initialized()) {
76)       std::cerr << "unexpected nice value: " << nice.getNice().get()
77)                 << std::endl;
78)       ret = EXIT_FAILURE;
79)     }
80)     if (!nice.getIoIdle()) {
81)       std::cerr << "expected I/O idle, but did not get it" << std::endl;
82)       ret = EXIT_FAILURE;
83)     }
84)   }
85) 
86)   {
87)     Config config;
88)     config.parseFile("nice_idle.cfg");
89) 
90)     Nice const &nice = config.getNice();
91)     if (!nice.getNice().is_initialized()) {
92)       std::cerr << "expected nice value, but got none" << std::endl;
93)       ret = EXIT_FAILURE;
94)     } else {
95)       if (nice.getNice().get() != 19) {
96)         std::cerr << "unexpected nice value: " << nice.getNice().get()
97)                   << ", expected 19" << std::endl;
98)         ret = EXIT_FAILURE;
99)       }
100)     }
101)   }
102) 
103)   return ret;
104) }
105) 
106) bool checkTrees(TreeMap const &treeMap, std::string const &rel_path,
107)                 boost::optional<std::string> user,
108)                 boost::optional<std::string> group, mode_t setMode,
109)                 mode_t setCondMode, mode_t clearMode, mode_t clearCondMode) {

110)   std::string path = boost::filesystem::canonical(rel_path).string();
111)   TreeMap::const_iterator itTree = treeMap.find(path);
112)   if (itTree == treeMap.end()) {
113)     std::cerr << "tree map entry \"" << path << "\" not found" << std::endl;
114)     return false;
115)   }
116)   Tree const &tree = itTree->second;
117) 
118)   bool ret = true;
119) 
120)   if (tree.getRoot() != path) {
121)     std::cerr << "tree map entry \"" << path << "\": unexpected root \""
122)               << tree.getRoot() << "\"" << std::endl;
123)     ret = false;
124)   }
125)   if (tree.getUser().getUserName() != user) {
126)     std::cerr << "tree map entry \"" << path << "\": unexpected user \""
127)               << tree.getUser().getUserName() << "\"" << std::endl;
128)     ret = false;
129)   }
130)   if (tree.getGroup().getGroupName() != group) {
131)     std::cerr << "tree map entry \"" << path << "\": unexpected group \""
132)               << tree.getGroup().getGroupName() << "\"" << std::endl;
133)     ret = false;
134)   }
135)   Permissions const &perms = tree.getPermissions();
136)   if (perms.getSet() != setMode) {

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

140)     ret = false;
141)   }
142)   if (perms.getSetCond() != setCondMode) {

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

144)               << std::oct << perms.getSetCond() << " != " << setCondMode
145)               << std::dec << std::endl;
146)     ret = false;
147)   }
148)   if (perms.getClear() != clearMode) {

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

152)     ret = false;
153)   }
154)   if (perms.getClearCond() != clearCondMode) {
155)     std::cerr << "tree map entry \"" << path

156)               << "\": unexpected clear cond mode " << std::oct
157)               << perms.getClearCond() << " != " << clearCondMode << std::dec
158)               << std::endl;

159)     ret = false;
160)   }
161) 
162)   return ret;
163) }

164) 

165) int testTrees() {

166)   Config config;

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

168) 
169)   int ret = EXIT_SUCCESS;
170) 
171)   TreeMap const &treeMap = config.getTrees();
172)   if (treeMap.size() != 2) {
173)     std::cerr << "unexpected number of trees: " << treeMap.size() << std::endl;
174)     ret = EXIT_FAILURE;
175)   }

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

178)     ret = EXIT_FAILURE;
179)   }

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

182)     ret = EXIT_FAILURE;
183)   }
184) 
185)   return ret;

186) }