API tools faq
paste
Advertisement
Guest User

ACL_modul3.h (PO POLSKU)

a guest
Dec 31st, 2017
98
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 16.55 KB | None | 0 0
raw download clone embed print report
  1. #ifndef ACL_modul3_h
  2. #define ACL_modul3_h
  3.  
  4. #include<list>
  5. #include<string>
  6. #include<map>
  7. #include<iostream>
  8. #include<vector>
  9.  
  10. struct User {
  11. std::string name;
  12. std::string password;
  13. std::string group;
  14. std::string permissions;
  15. std::string effective_permissions;
  16.  
  17. User() {}
  18. User(std::string _name, std::string _pass) {
  19. this->name = _name;
  20. this->password = _pass;
  21. }
  22. };
  23.  
  24.  
  25. struct Group {
  26. std::string name;
  27. std::vector<User> users_in_group;
  28. std::string permissions;
  29. std::string effective_permissions;
  30.  
  31. Group() {}
  32. Group(std::string _name) {
  33. this->name = _name;
  34. }
  35. };
  36.  
  37. struct ACL {
  38. std::string owner;
  39. std::string group;
  40. std::string user_owner_permissions;
  41. std::string group_owner_permissions;
  42. std::string group_owner_effective_permissions;
  43. std::vector<User> users;
  44. std::vector<Group> groups;
  45. std::string mask;
  46. std::string others;
  47.  
  48. ACL() {}
  49. };
  50.  
  51. class Uprawnienia {
  52. private:
  53. std::map<std::string, ACL> kontener_ACL;
  54. std::vector<User> wszyscy_uzytkownicy;
  55. std::vector<Group> wszystkie_grupy;
  56. User zalogowany_uzytkownik;
  57. bool mask_defined = false;
  58.  
  59. public:
  60. Uprawnienia() {
  61. User u;
  62. Group g1, g2;
  63. g1.name = "administratorzy";
  64. g2.name = "uzytkownicy";
  65. u.name = "administrator";
  66. u.password = "admin";
  67. u.group = g1.name;
  68. g1.users_in_group.push_back(u);
  69. wszystkie_grupy.push_back(g1);
  70. wszystkie_grupy.push_back(g2);
  71. wszyscy_uzytkownicy.push_back(u);
  72. zalogowany_uzytkownik = u;
  73. }
  74.  
  75. std::string zwroc_nazwe_zalogowanego_uzytkownika() {
  76. return zalogowany_uzytkownik.name;
  77. }
  78.  
  79. bool uzytkownik_istnieje(std::string nazwa);
  80.  
  81. bool grupa_istnieje(std::string nazwa);
  82.  
  83. void dodaj_uzytkownika(std::string nazwa, std::string haslo);
  84.  
  85. void dodaj_grupe(std::string nazwa);
  86.  
  87. void usun_uzytkownika(std::string nazwa);
  88.  
  89. void usun_grupe(std::string nazwa);
  90.  
  91. void wyswietl_uzytkownikow();
  92.  
  93. void wyswietl_grupy();
  94.  
  95. void przelacz_uzytkownika(std::string name, std::string haslo);
  96.  
  97. void dodaj_do_grupy(std::string nazwa, std::string grupa);
  98.  
  99. std::string numbers_to_rwx(char right) {
  100. std::string permissions;
  101. switch (right) {
  102. case '0':
  103. permissions = "---";
  104. return permissions;
  105. case '1':
  106. permissions = "--x";
  107. return permissions;
  108. case '2':
  109. permissions = "-w-";
  110. return permissions;
  111. case '3':
  112. permissions = "-wx";
  113. return permissions;
  114. case '4':
  115. permissions = "r--";
  116. return permissions;
  117. case '5':
  118. permissions = "r-x";
  119. return permissions;
  120. case '6':
  121. permissions = "rw-";
  122. return permissions;
  123. case '7':
  124. permissions = "rwx";
  125. return permissions;
  126. }
  127. }
  128.  
  129. void stworzACL(std::string nazwa_pliku) {
  130. std::pair<std::string, ACL> para;
  131. para.first = nazwa_pliku;
  132. para.second.owner = zalogowany_uzytkownik.name;
  133. para.second.group = zalogowany_uzytkownik.group;
  134. para.second.user_owner_permissions = "rwx";
  135. para.second.group_owner_permissions = "rwx";
  136. para.second.mask = "rwx";
  137. para.second.others = "r--";
  138. kontener_ACL.insert(para);
  139. }
  140.  
  141. void getfacl(std::string nazwa_pliku) {
  142. std::cout << "\n";
  143. if (kontener_ACL.find(nazwa_pliku) != kontener_ACL.end()) {
  144. if (kontener_ACL[nazwa_pliku].mask == "rwx") {
  145. std::cout << "# file: " << nazwa_pliku << "\n";
  146. std::cout << "# owner: " << kontener_ACL[nazwa_pliku].owner << "\n";
  147. std::cout << "# group: " << kontener_ACL[nazwa_pliku].group << "\n";
  148. std::cout << "user::" << kontener_ACL[nazwa_pliku].user_owner_permissions << "\n";
  149. for (auto p : kontener_ACL[nazwa_pliku].users)
  150. std::cout << "user:" << p.name << ":" << p.permissions << "\n";
  151. std::cout << "group::" << kontener_ACL[nazwa_pliku].group_owner_permissions << "\n";
  152. for (auto p : kontener_ACL[nazwa_pliku].groups)
  153. std::cout << "group:" << p.name << ":" << p.permissions << "\n";
  154. std::cout << "mask::" << kontener_ACL[nazwa_pliku].mask << "\n";
  155. std::cout << "other::" << kontener_ACL[nazwa_pliku].others << "\n\n";
  156. }
  157. else {
  158. std::cout << "# file: " << nazwa_pliku << "\n";
  159. std::cout << "# owner: " << kontener_ACL[nazwa_pliku].owner << "\n";
  160. std::cout << "# group: " << kontener_ACL[nazwa_pliku].group << "\n";
  161. std::cout << "user::" << kontener_ACL[nazwa_pliku].user_owner_permissions << "\n";
  162. for (auto p : kontener_ACL[nazwa_pliku].users)
  163. std::cout << "user:" << p.name << ":" << p.permissions << "\t\t\t#effective:" << p.effective_permissions << "\n";
  164. std::cout << "group::" << kontener_ACL[nazwa_pliku].group_owner_permissions << "\t\t\t#effective:" << kontener_ACL[nazwa_pliku].group_owner_effective_permissions << "\n";
  165. for (auto p : kontener_ACL[nazwa_pliku].groups)
  166. std::cout << "group:" << p.name << ":" << p.permissions << "\t\t\t#effective:" << p.effective_permissions << "\n";
  167. std::cout << "mask::" << kontener_ACL[nazwa_pliku].mask << "\n";
  168. std::cout << "other::" << kontener_ACL[nazwa_pliku].others << "\n\n";
  169. }
  170. }
  171. else std::cout << "Plik nie istnieje\n\n";
  172. }
  173.  
  174. bool jest_user_na_ACL(std::string name, std::string file_name) {
  175. for (auto z : kontener_ACL) {
  176. if (z.first == file_name) {
  177. for (auto x : z.second.users)
  178. if (x.name == name)
  179. return true;
  180. }
  181. }
  182. return false;
  183. }
  184.  
  185. bool jest_grupa_na_ACL(std::string name, std::string file_name) {
  186. for (auto z : kontener_ACL) {
  187. if (z.first == file_name) {
  188. for (auto x : z.second.groups)
  189. if (x.name == name)
  190. return true;
  191. }
  192. }
  193. return false;
  194. }
  195.  
  196. void usun_uzytkownika_z_ACL(std::string name, std::string file_name) {
  197. for (int i = 0; i < kontener_ACL[file_name].users.size(); i++) {
  198. if (kontener_ACL[file_name].users[i].name == name)
  199. kontener_ACL[file_name].users.erase(kontener_ACL[file_name].users.begin() + i);
  200. }
  201. }
  202.  
  203. void usun_grupe_z_ACL(std::string name, std::string file_name) {
  204. for (int i = 0; i < kontener_ACL[file_name].groups.size(); i++) {
  205. if (kontener_ACL[file_name].groups[i].name == name)
  206. kontener_ACL[file_name].groups.erase(kontener_ACL[file_name].groups.begin() + i);
  207. }
  208. }
  209.  
  210. std::string from_normal_to_effective(std::string mask, std::string permissions) {
  211. std::string effective_permissions="";
  212. for (int i = 0; i < 3; i++) {
  213. if (permissions[i] != mask[i])
  214. effective_permissions += '-';
  215. else
  216. effective_permissions += mask[i];
  217. }
  218. return effective_permissions;
  219. }
  220.  
  221. void set_effective_permissions(std::string permissions, std::string file_name) {
  222. std::string new_permissions="";
  223. std::string mask = permissions;
  224. for (auto &x : kontener_ACL[file_name].users) {
  225. new_permissions = from_normal_to_effective(mask, x.permissions);
  226. x.effective_permissions = new_permissions;
  227. }
  228. new_permissions = from_normal_to_effective(mask, kontener_ACL[file_name].group_owner_permissions);
  229. kontener_ACL[file_name].group_owner_effective_permissions = new_permissions;
  230.  
  231. for (auto &y : kontener_ACL[file_name].groups) {
  232. new_permissions = from_normal_to_effective(mask, y.permissions);
  233. y.effective_permissions = new_permissions;
  234. }
  235. }
  236.  
  237. void setfacl(char parameter, std::string command, char right, std::string file_name) {
  238. char mark = command[0];
  239. User u; Group g;
  240. std::string name = "", permissions = "";
  241. if (parameter == 'm') {
  242. switch (mark) {
  243. case 'u':
  244. name = command.substr(2, command.size() - 2);
  245. if (uzytkownik_istnieje(name)) {
  246. permissions = numbers_to_rwx(right);
  247. if (!mask_defined) {
  248. if (!jest_user_na_ACL(name, file_name)) {
  249. u.name = name;
  250. u.permissions = permissions;
  251. kontener_ACL[file_name].users.push_back(u);
  252. }
  253. else {
  254. for (int i = 0; i < kontener_ACL[file_name].users.size(); i++) {
  255. if (kontener_ACL[file_name].users[i].name == name) {
  256. kontener_ACL[file_name].users[i].permissions = permissions;
  257. }
  258. }
  259. }
  260. }
  261. else {
  262. if (!jest_user_na_ACL(name, file_name)) {
  263. u.name = name;
  264. u.permissions = permissions;
  265. u.effective_permissions = from_normal_to_effective(kontener_ACL[file_name].mask, permissions);
  266. kontener_ACL[file_name].users.push_back(u);
  267. }
  268. else {
  269. for (int i = 0; i < kontener_ACL[file_name].users.size(); i++) {
  270. if (kontener_ACL[file_name].users[i].name == name) {
  271. kontener_ACL[file_name].users[i].permissions = permissions;
  272. kontener_ACL[file_name].users[i].effective_permissions = from_normal_to_effective(kontener_ACL[file_name].mask, permissions);
  273. }
  274. }
  275. }
  276. }
  277. }
  278. else {
  279. std::cout << "\nPodany uzytkownik nie istnieje\n\n";
  280. }
  281. break;
  282. case 'g':
  283. name = command.substr(2, command.size() - 2);
  284. if (grupa_istnieje(name)) {
  285. permissions = numbers_to_rwx(right);
  286. if (!jest_grupa_na_ACL(name, file_name)) {
  287. g.name = name;
  288. g.permissions = permissions;
  289. kontener_ACL[file_name].groups.push_back(g);
  290. }
  291. else {
  292. for (int i = 0; i < kontener_ACL[file_name].groups.size(); i++) {
  293. if (kontener_ACL[file_name].groups[i].name == name)
  294. kontener_ACL[file_name].groups[i].permissions = permissions;
  295. }
  296. }
  297. }
  298. else {
  299. std::cout << "\nPodana grupa nie istnieje\n\n";
  300. }
  301. break;
  302. case 'm':
  303. if (right < 55) {
  304. permissions = numbers_to_rwx(right);
  305. set_effective_permissions(permissions, file_name);
  306. kontener_ACL[file_name].mask = permissions;
  307. mask_defined = true;
  308. }
  309. else {
  310. permissions = numbers_to_rwx(right);
  311. kontener_ACL[file_name].mask = permissions;
  312. }
  313. break;
  314. case 'o':
  315. permissions = numbers_to_rwx(right);
  316. kontener_ACL[file_name].others = permissions;
  317. break;
  318. }
  319. }
  320. else if (parameter == 'x') {
  321. switch (mark) {
  322. case 'u':
  323. name = command.substr(2, command.size() - 2);
  324. if (uzytkownik_istnieje(name))
  325. if (jest_user_na_ACL(name, file_name))
  326. usun_uzytkownika_z_ACL(name, file_name);
  327. break;
  328. case 'g':
  329. name = command.substr(2, command.size() - 2);
  330. if (grupa_istnieje(name))
  331. if (jest_grupa_na_ACL(name, file_name))
  332. usun_grupe_z_ACL(name, file_name);
  333. break;
  334. }
  335. }
  336. }
  337.  
  338. void deleteACL(std::string file_name) {
  339. if (kontener_ACL.find(file_name) != kontener_ACL.end()) {
  340. std::map<std::string, ACL>::iterator it;
  341. it = kontener_ACL.find(file_name);
  342. kontener_ACL.erase(it);
  343. }
  344. else std::cout << "Plik nie istnieje\n\n";
  345.  
  346. }
  347.  
  348. bool zgoda_na_odczyt(std::string nazwa_pliku) {
  349. bool others1 = false, others2 = false, others3 = false;
  350. if (kontener_ACL.find(nazwa_pliku) != kontener_ACL.end()) {
  351. if (zalogowany_uzytkownik.name == kontener_ACL[nazwa_pliku].owner)
  352. return true;
  353.  
  354. if (mask_defined) {
  355. for (auto x : kontener_ACL[nazwa_pliku].users) {
  356. if (x.name == zalogowany_uzytkownik.name) {
  357. if (x.effective_permissions[0] == 'r') {
  358. return true;
  359. }
  360. }
  361. else
  362. others1 = true;
  363. }
  364. if (zalogowany_uzytkownik.group == kontener_ACL[nazwa_pliku].group) {
  365. if (kontener_ACL[nazwa_pliku].group_owner_effective_permissions[0] == 'r')
  366. return true;
  367. else
  368. return false;
  369. }
  370. else others2 = true;
  371.  
  372. for (auto x : kontener_ACL[nazwa_pliku].groups) {
  373. if (x.name == zalogowany_uzytkownik.group) {
  374. if (x.effective_permissions[0] == 'r')
  375. return true;
  376. else
  377. return false;
  378. }
  379. else others3 = true;
  380. }
  381.  
  382. if (others1 == true && others2 == true && others3 == true) {
  383. if (kontener_ACL[nazwa_pliku].others[0] == 'r')
  384. return true;
  385. else
  386. return false;
  387. }
  388. }
  389. else {
  390. for (auto x : kontener_ACL[nazwa_pliku].users) {
  391. if (x.name == zalogowany_uzytkownik.name) {
  392. if (x.permissions[0] == 'r') {
  393. return true;
  394. }
  395. }
  396. else
  397. others1 = true;
  398. }
  399. if (zalogowany_uzytkownik.group == kontener_ACL[nazwa_pliku].group) {
  400. if (kontener_ACL[nazwa_pliku].group_owner_permissions[0] == 'r')
  401. return true;
  402. else
  403. return false;
  404. }
  405. else others2 = true;
  406.  
  407. for (auto x : kontener_ACL[nazwa_pliku].groups) {
  408. if (x.name == zalogowany_uzytkownik.group) {
  409. if (x.permissions[0] == 'r')
  410. return true;
  411. else
  412. return false;
  413. }
  414. else others3 = true;
  415. }
  416.  
  417. if (others1 == true && others2 == true && others3 == true) {
  418. if (kontener_ACL[nazwa_pliku].others[0] == 'r')
  419. return true;
  420. else
  421. return false;
  422. }
  423. }
  424. }
  425. }
  426.  
  427. bool zgoda_na_modyfikacje(std::string nazwa_pliku) {
  428. bool others1 = false, others2 = false, others3 = false;
  429. if (kontener_ACL.find(nazwa_pliku) != kontener_ACL.end()) {
  430. if (zalogowany_uzytkownik.name == kontener_ACL[nazwa_pliku].owner)
  431. return true;
  432.  
  433. if (mask_defined) {
  434. for (auto x : kontener_ACL[nazwa_pliku].users) {
  435. if (x.name == zalogowany_uzytkownik.name) {
  436. if (x.effective_permissions[1] == 'w') {
  437. return true;
  438. }
  439. }
  440. else
  441. others1 = true;
  442. }
  443. if (zalogowany_uzytkownik.group == kontener_ACL[nazwa_pliku].group) {
  444. if (kontener_ACL[nazwa_pliku].group_owner_effective_permissions[1] == 'w')
  445. return true;
  446. else
  447. return false;
  448. }
  449. else others2 = true;
  450.  
  451. for (auto x : kontener_ACL[nazwa_pliku].groups) {
  452. if (x.name == zalogowany_uzytkownik.group) {
  453. if (x.effective_permissions[1] == 'w')
  454. return true;
  455. else
  456. return false;
  457. }
  458. else others3 = true;
  459. }
  460.  
  461. if (others1 == true && others2 == true && others3 == true) {
  462. if (kontener_ACL[nazwa_pliku].others[1] == 'w')
  463. return true;
  464. else
  465. return false;
  466. }
  467. }
  468. else {
  469. for (auto x : kontener_ACL[nazwa_pliku].users) {
  470. if (x.name == zalogowany_uzytkownik.name) {
  471. if (x.permissions[1] == 'w') {
  472. return true;
  473. }
  474. }
  475. else
  476. others1 = true;
  477. }
  478. if (zalogowany_uzytkownik.group == kontener_ACL[nazwa_pliku].group) {
  479. if (kontener_ACL[nazwa_pliku].group_owner_permissions[1] == 'w')
  480. return true;
  481. else
  482. return false;
  483. }
  484. else others2 = true;
  485.  
  486. for (auto x : kontener_ACL[nazwa_pliku].groups) {
  487. if (x.name == zalogowany_uzytkownik.group) {
  488. if (x.permissions[1] == 'w')
  489. return true;
  490. else
  491. return false;
  492. }
  493. else others3 = true;
  494. }
  495.  
  496. if (others1 == true && others2 == true && others3 == true) {
  497. if (kontener_ACL[nazwa_pliku].others[1] == 'w')
  498. return true;
  499. else
  500. return false;
  501. }
  502. }
  503. }
  504. }
  505.  
  506. bool zgoda_na_usuniecie(std::string nazwa_pliku) {
  507. bool others1 = false, others2 = false, others3 = false;
  508. if (kontener_ACL.find(nazwa_pliku) != kontener_ACL.end()) {
  509. if (zalogowany_uzytkownik.name == kontener_ACL[nazwa_pliku].owner)
  510. return true;
  511.  
  512. if (mask_defined) {
  513. for (auto x : kontener_ACL[nazwa_pliku].users) {
  514. if (x.name == zalogowany_uzytkownik.name) {
  515. if (x.effective_permissions[2] == 'x') {
  516. return true;
  517. }
  518. }
  519. else
  520. others1 = true;
  521. }
  522. if (zalogowany_uzytkownik.group == kontener_ACL[nazwa_pliku].group) {
  523. if (kontener_ACL[nazwa_pliku].group_owner_effective_permissions[2] == 'x')
  524. return true;
  525. else
  526. return false;
  527. }
  528. else others2 = true;
  529.  
  530. for (auto x : kontener_ACL[nazwa_pliku].groups) {
  531. if (x.name == zalogowany_uzytkownik.group) {
  532. if (x.effective_permissions[2] == 'x')
  533. return true;
  534. else
  535. return false;
  536. }
  537. else others3 = true;
  538. }
  539.  
  540. if (others1 == true && others2 == true && others3 == true) {
  541. if (kontener_ACL[nazwa_pliku].others[2] == 'x')
  542. return true;
  543. else
  544. return false;
  545. }
  546. }
  547. else {
  548. for (auto x : kontener_ACL[nazwa_pliku].users) {
  549. if (x.name == zalogowany_uzytkownik.name) {
  550. if (x.permissions[2] == 'x') {
  551. return true;
  552. }
  553. }
  554. else
  555. others1 = true;
  556. }
  557. if (zalogowany_uzytkownik.group == kontener_ACL[nazwa_pliku].group) {
  558. if (kontener_ACL[nazwa_pliku].group_owner_permissions[2] == 'x')
  559. return true;
  560. else
  561. return false;
  562. }
  563. else others2 = true;
  564.  
  565. for (auto x : kontener_ACL[nazwa_pliku].groups) {
  566. if (x.name == zalogowany_uzytkownik.group) {
  567. if (x.permissions[2] == 'x')
  568. return true;
  569. else
  570. return false;
  571. }
  572. else others3 = true;
  573. }
  574.  
  575. if (others1 == true && others2 == true && others3 == true) {
  576. if (kontener_ACL[nazwa_pliku].others[2] == 'x')
  577. return true;
  578. else
  579. return false;
  580. }
  581. }
  582. }
  583. }
  584. };
  585.  
  586. #endif
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!