Add files via upload

Author: HxnDev

utility.cpp

@@ -0,0 +1,135 @@
+#include <map>
+#include <string>
+#include <vector>
+#include <string.h>
+#include <sstream>
+#include <fstream>
+#include <algorithm>
+
+using std::map;
+using std::ios;
+using std::cout;
+using std::fstream;
+using std::string;
+using std::vector;
+using std::stringstream;
+
+template <typename T, typename U>
+void print_map(map<T, U> to_print) {
+	// a templatised function to output a map's key value pairs
+
+	for (auto itr = to_print.begin(); itr != to_print.end(); ++itr) {
+		cout << itr->first << ": " << itr->second << "\n";
+	}
+}
+
+string charToString(char arr[]) {
+	// function that returns a string representation of a character array
+
+	string str = "";
+
+	for (int i = 0; arr[i] != '\0'; i++)
+		str += arr[i];
+
+	return str;
+}
+
+vector<string> split_string(const string str, const char delim) {
+
+	// this is a custom function to split a string
+	// returns a vector of "words", according to the delimiter char
+    
+    string token;
+    vector<string> out;
+    stringstream ss(str);
+
+    while (getline(ss, token, delim))	// splitting or tokenizing the string according to the specified delimiter
+        out.push_back(token);	// adding each token to the vector
+
+    return out;
+}
+
+string get_salt_hash(const string file, const string username) {
+
+	// this function reads the file (typically shadow.txt) and finds the value corresponding to the specified username
+	// the value is then parsed to get the salt and hash (as one string) for this username
+	// salt and hash are returned as one string
+
+	string line, salt_hash;
+
+	fstream infile;
+    infile.open(file, ios::in);
+	
+	if (infile.is_open()) {
+		while (getline(infile, line)) {
+			if (strstr(line.c_str(), username.c_str())) {	// if line has specified username
+				vector<string> tokens = split_string(line, ':');	// split by " : " character
+				salt_hash = tokens[1];	// salt and hash are after first colon and before second
+				break;
+			}
+		}
+
+		return salt_hash;
+	}
+
+	else {
+		cout << "Shadow file not opened :(\n";
+		return "";
+	}
+}
+
+map<int, string> divide_alphabet(const int slave_procs) {
+
+	// this function divides the alphabet characters and assigns certain number of characters to each process
+	// also takes into account the case when alphabet is not perfectly divisible by number of slave processes
+	// so may also assign master some characters
+	// the distribution is stored in a map with (key, value) pair being (process rank, characters assigned)
+	// rank 0 is master, rank 1 is slave 1, rank 2 is slave 2 and so on...
+
+	map<int, string> distrib;
+    string alphabet = "abcdefghijklmnopqrstuvwxyz";
+    random_shuffle(alphabet.begin(), alphabet.end());
+    
+	// case 1: alphabet perfectly divisible by number of slaves
+    if (alphabet.length() % slave_procs == 0) {
+        int chunk = alphabet.length() / slave_procs;
+
+		distrib[0] = "";	// no letters assigned to master (characters can be evenly distributed among the slaves), still we keep a record for master in case required
+
+		int index = 0;
+        for (int i = 1; i <= slave_procs; i++) {
+            int start = index;
+
+			string letters = alphabet.substr(start, chunk);
+
+			distrib[i] = letters;	// assigning letters to that slave rank
+
+			index += chunk;
+		}
+          
+    }
+
+	// case 2: alphabet not perfectly divisible, some characters will have to be allotted to master too
+    else {
+        int mod = alphabet.length() % slave_procs;
+		
+		distrib[0] = alphabet.substr(0,mod);
+
+        int new_len = alphabet.length()-mod;
+        int mod1 = new_len/slave_procs;
+
+		int index = mod;
+
+        for (int i = 1 ; i <= slave_procs; i++) {
+            int start = index;
+
+            string letters = alphabet.substr(start, mod1);
+
+			distrib[i] = letters;
+
+            index+=mod1;
+        }
+    }
+
+	return distrib;
+}