void testInsert() { printf("###########################\n"); printf("Test 6. insert: "); BTree *tree = malloc(sizeof(BTree)); tree->root = NULL; tree->arity = 4; tree->height = 0; insertBTree(tree, 1); int a1[1] = {1}; if ((tree->root == NULL) || (!compareKeys(tree->root->keys,a1, 1))){ printf("NOK - vkladani do prazdneho B-stromu stupne 2\n"); }else{ insertBTree(tree, 7); insertBTree(tree, 2); int a2[3] = {1,2,7}; if((tree->root == NULL) || (!compareKeys(tree->root->keys,a2, 3))){ printf("NOK - vkladani do B-stromu bez stepeni\n"); }else{ int a3_1[1] = {2}; int a3_2[1] = {1}; int a3_3[2] = {5, 7}; insertBTree(tree,5); if(tree->root == NULL || (!compareKeys(tree->root->keys,a3_1, 1)) || (!compareKeys(tree->root->children[0]->keys,a3_2, 1)) || (!compareKeys(tree->root->children[1]->keys,a3_3, 2))){ printf("NOK - vkladani se stepenim korene\n"); }else{ insertBTree(tree, 12); insertBTree(tree, 8); int a4_1[2] = {2,7}; int a4_2[1] = {1}; int a4_3[1] = {5}; int a4_4[2] = {8, 12}; if(tree->root == NULL || (!compareKeys(tree->root->keys,a4_1, 2)) || (!compareKeys(tree->root->children[0]->keys,a4_2, 1)) || (!compareKeys(tree->root->children[1]->keys,a4_3, 1)) || (!compareKeys(tree->root->children[2]->keys,a4_4, 2))){ printf("NOK - vkladani se stepenim listu\n"); }else{ insertBTree(tree, 4); insertBTree(tree, 3); insertBTree(tree, 6); int a5_1[3] = {2,4,7}; int a5_2[1] = {3}; int a5_3[2] = {5, 6}; int a5_4[2] = {8, 12}; if(tree->root == NULL || (!compareKeys(tree->root->keys,a5_1, 3)) || (!compareKeys(tree->root->children[1]->keys,a5_2, 1)) || (!compareKeys(tree->root->children[2]->keys,a5_3, 2)) || (!compareKeys(tree->root->children[3]->keys,a5_4, 2))){ printf("NOK - vkladani se stepenim listu\n"); }else{ insertBTree(tree, 11); int a6_1[1] = {4}; int a6_2[1] = {2}; int a6_3[1] = {7}; int a6_4[2] = {5, 6}; int a6_5[3] = {8, 11, 12}; if(tree->root == NULL || (!compareKeys(tree->root->keys,a6_1, 1)) || (!compareKeys(tree->root->children[0]->keys,a6_2, 1)) || (!compareKeys(tree->root->children[1]->keys,a6_3, 1)) || (!compareKeys(tree->root->children[1]->children[0]->keys,a6_4, 2)) || (!compareKeys(tree->root->children[1]->children[1]->keys,a6_5, 3))){ printf("NOK - vkladani se stepenim korene\n"); }else{ printf("OK\n"); } } } } } } makeGraph(tree, "insert.dot"); printf("Vykresleny B-strom najdete v souboru insert.dot\n"); freeTree(tree); }
void test_compareKeys() { Key key1 = {100, 10}; Key key2 = {100, 10}; assertLongEquals("Compare should eq", 0, compareKeys(&key1, &key2)); key1.ip = 99; assertLongEquals("Firs Keyk is less (ip less)", -1, compareKeys(&key1, &key2)); key1.port = 9; assertLongEquals("Firs Keyk is less (ip less port less)", -1, compareKeys(&key1, &key2)); key1.port = 11; assertLongEquals("Firs Keyk is less (ip less port greater)", -1, compareKeys(&key1, &key2)); key1.ip = 100; key1.port = 10; assertLongEquals("Compare should eq", 0, compareKeys(&key1, &key2)); key1.port = 9; assertLongEquals("Firs Keyk is less (ip eq port less)", -1, compareKeys(&key1, &key2)); key1.ip = 100; key1.port = 10; assertLongEquals("Compare should eq", 0, compareKeys(&key1, &key2)); key1.port = 11; assertLongEquals("Firs Keyk is greater (ip eq port greater)", 1, compareKeys(&key1, &key2)); key1.ip = 101; key1.port = 11; assertLongEquals("Firs Keyk is greater (ip greater port greater)", 1, compareKeys(&key1, &key2)); key1.port = 10; assertLongEquals("Firs Keyk is greater (ip greater port eq)", 1, compareKeys(&key1, &key2)); key1.port = 9; assertLongEquals("Firs Keyk is greater (ip greater port less)", 1, compareKeys(&key1, &key2)); }
void testPostOrderPrint() { printf("###########################\n"); printf("Test 3. post_order_print: "); int res1[5] = {1, 8, 12, 16, 25}; int res2[21] = {0, 1, 3, 2, 6, 7, 9, 10, 12, 8, 14, 15, 17, 25, 55, 75, 16, 18, 50, 5, 13}; int res3[42] = {1, 3, 8, 13, 15, 16, 18, 19, 20, 21, 23, 24, 27, 29, 31, 32, 33, 34, 36, 37, 38, 40, 42, 47, 48, 50, 52, 56, 66, 67, 68, 69, 70, 73, 79, 12, 17, 22, 28, 35, 39, 65}; BTree *tree = testTree1(); int* res = postOrderPrintBTree(tree); if (!compareKeys(res1, res, 5)) { printf("NOK\n"); printf("vysledek:\t "); if (res != NULL) { for(int i = 0; i < 5; i++) printf("%d ",res[i]); putchar('\n'); }else{ printf("[]\n"); } printf("ocekavany vysledek:"); for(int i = 0; i < 5; i++) printf("%d ",res1[i]); putchar('\n'); } else { free(res); freeTree(tree); tree = testTree2(); res = postOrderPrintBTree(tree); if (!compareKeys(res2, res, 21)){ printf("NOK\n"); printf("vysledek:\t "); if (res != NULL) { for(int i = 0; i < 21; i++) printf("%d ",res[i]); putchar('\n'); }else{ printf("[]\n"); } printf("ocekavany vysledek:"); for(int i = 0; i < 21; i++) printf("%d ",res2[i]); putchar('\n'); }else{ free(res); freeTree(tree); tree = testTree3(); res = postOrderPrintBTree(tree); if (!compareKeys(res3, res, 42)){ printf("NOK\n"); printf("vysledek:\t "); if (res != NULL) { for(int i = 0; i < 42; i++) printf("%d ",res[i]); putchar('\n'); }else{ printf("[]\n"); } printf("ocekavany vysledek:"); for(int i = 0; i < 42; i++) printf("%d ",res3[i]); putchar('\n'); }else{ printf("OK\n"); } } } makeGraph(tree, "post_order_print.dot"); printf("Vykresleny B-strom najdete v souboru post_order_print.dot\n"); free(res); freeTree(tree); }
bool GridWorld::computeShortestPath(){ if (open.empty()){ std::cout << "ERROR: No tiles to expand on... can't do anything" << std::endl; return false; } while (!open.empty() && (compareKeys(open.front()->key, goal->key = calculateKey(goal)) || goal->rhs != goal->g)){ Tile* current = open.front(); //Notice that CURRENT wasn't pop/removed yet //std::cout << "Expanding:"; //current->info(); //std::cout << std::endl; KeyPair k_new = calculateKey(current); if (compareKeys(current->key, k_new)){ //Tiles under this branch will have to be updated as incremental search has happened current->key = k_new; make_heap(open.begin(), open.end(), GridWorld::compareTiles); } else if (current->g > current->rhs){ //Majority of the tiles will fall under this conditional branch as //it undergoes normal A* pathfinding current->g = current->rhs; open.erase(open.begin()); make_heap(open.begin(), open.end(), GridWorld::compareTiles); current->isOpen = false; std::vector<Tile*> neighbours(getNeighbours(current)); for (int i = 0; i < neighbours.size(); i++){ if (neighbours[i] != start && neighbours[i]->rhs > current->g + calculateC(current, neighbours[i])){ neighbours[i]->successor = current; neighbours[i]->rhs = current->g + calculateC(current, neighbours[i]); updateVertex(neighbours[i]); } } } else { //Tiles under this branch will need to be updated during incremental search current->g = PF_INFINITY; //Update CURRENT if (current != start && current->successor == current){ TilePair minSucc(getMinSuccessor(current)); current->rhs = minSucc.second; current->successor = current->rhs == PF_INFINITY ? 0 : minSucc.first; } updateVertex(current); //Update NEIGHBOURS std::vector<Tile*> neighbours(getNeighbours(current)); for (int i = 0; i < neighbours.size(); i++){ if (neighbours[i] != start && neighbours[i]->successor == current){ TilePair minSucc(getMinSuccessor(neighbours[i])); neighbours[i]->rhs = minSucc.second; neighbours[i]->successor = neighbours[i]->rhs == PF_INFINITY ? 0 : minSucc.first; } updateVertex(neighbours[i]); } } //Uncomment this to see CURRENT'S new values //std::cout << "Expanded:"; //current->info(); //std::cout << std::endl; } return true; }
int main(int argc, char *argv[]) { int i, j; int record_count = 400; int range = record_count/10; uint8_t len = 5; AttributeType type[len]; const char hans[] = "hans"; Index *index; Iterator **iterator = (Iterator**) malloc(sizeof(Iterator*)); Transaction *t; Record recs[record_count]; Key keys[record_count]; Key minkey; Key maxkey; Record *currentResult; Attribute attr; Block blocks[record_count]; time_t tm; for (j = 0; j < record_count; j++) { blocks[j].size = 5; blocks[j].data = malloc(5); sprintf((char*)blocks[j].data, "%i", j); attr.type = kInt; keys[j].value = (Attribute**) malloc(len*sizeof(Attribute*)); keys[j].attribute_count = len; // printf("Key number %i: \n", j); for (i = 0; i < len; i++) { type[i] = kInt; keys[j].value[i] = (Attribute*) malloc(sizeof(Attribute)); keys[j].value[i]->type = kInt; keys[j].value[i]->int_value = randInt(range); // printf("key.value[%i] = %ld \n", i, keys[j].value[i]->int_value); } // printf("\n"); recs[j].key = keys[j]; recs[j].payload = blocks[j]; } // generate min and max keys minkey.value = (Attribute**) malloc(len*sizeof(Attribute*)); minkey.attribute_count = len; maxkey.value = (Attribute**) malloc(len*sizeof(Attribute*)); maxkey.attribute_count = len; for (i = 0; i < len; i++) { minkey.value[i] = (Attribute*) malloc(sizeof(Attribute)); minkey.value[i]->type = kInt; minkey.value[i]->int_value = 0.3*range; maxkey.value[i] = (Attribute*) malloc(sizeof(Attribute)); maxkey.value[i]->type = kInt; maxkey.value[i]->int_value = 0.8*range; } printf("Done with generating data. \n"); tm = time(NULL); CreateIndex(hans, len, type); // len OpenIndex(hans, &index); BeginTransaction(&t); for (i = 0; i < record_count; i++) { //record_count InsertRecord(t, index, recs+i); if (i % 1000 == 0) printf("i = %i / %i \n", i, record_count); } printf("finished inserting, took %is \n", time(NULL)-tm); tm = time(NULL); // for (i = 0; i < record_count; i+=2) { // record_count // if (i == 398) { // printf("deleting record %i \n", i); // } DeleteRecord(t, index, recs+4, 0); // } // if (DeleteRecord(t, index, recs+398, 0) != kErrorNotFound) { // printf(";_; \n "); // } printf("deleted half of the records, took %is \n", time(NULL)-tm); GetRecords(t, index, minkey, maxkey, iterator); while (GetNext(*iterator, ¤tResult) != kErrorNotFound) { printf("%i \t(%i\t%i\t%i\t%i\t%i)\t%s \n", currentResult->key.value[0]->int_value, currentResult->key.value[0]->int_value, currentResult->key.value[1]->int_value, currentResult->key.value[2]->int_value, currentResult->key.value[3]->int_value, currentResult->key.value[4]->int_value, currentResult->payload.data); } printf("just to be sure: \n"); for (i = 0; i < record_count; i++) { for (j = 0; j < len; j++) { // len // if (!(compareKeys(minkey, keys[i], j, true) <= 0 && compareKeys(keys[i], maxkey, j, true) < 0)) { if (!((minkey.value[j] == 0 || compareKeys(minkey, keys[i], j, true) <= 0) && (maxkey.value[j] == 0 || compareKeys(keys[i], maxkey, j, true) < 0))) { break; } } if (j == len) { // len printf("so: %i \n", keys[i].value[0]->int_value); } } // printf("committing \n"); CommitTransaction(&t); // printf("closing \n"); CloseIndex(&index); // printf("deleting \n"); DeleteIndex(hans); // printf("should be zero: %i \n", all_indices["hans"]); return 0; }
int TCBinaryObjectTree::setObjectForKey(TCObject *object, const char* key) { if (rootNode) { TCBinaryObjectTreeNode* spot = rootNode; int currentDepth = 0; while (1) { int result = compareKeys(key, spot->key); currentDepth++; if (result < 0) { if (spot->left) { spot = spot->left; } else { spot->left = new TCBinaryObjectTreeNode(key, object); count++; break; } } else if (result > 0) { if (spot->right) { spot = spot->right; } else { spot->right = new TCBinaryObjectTreeNode(key, object); count++; break; } } else { TCObject *oldObject = spot->value; // already exists, so replace, and return 0 to indicate this. spot->value = object->retain(); oldObject->release(); return 0; } } if (currentDepth > depth) { depth = currentDepth; } } else { rootNode = new TCBinaryObjectTreeNode(key, object); depth = 1; count = 1; } return 1; }
asmlinkage long xcrypt(void *arg) { if (arg == NULL) { printk("User level argument is NULL\n"); return -EINVAL; } else { struct myargs *arguments; int result, paddedresult, padvalue, preambleWritten, temp, paddingWritten, paddingRead; struct file *filp=NULL, *filp1=NULL; struct dentry *dentry=NULL, *olddentry=NULL, *newdentry=NULL; long int inputFileLen=-1, outputFileLen=-1, keyLen=-1; char *srcbuffer, *destbuffer, *padding, *keyFromFile=NULL, *md5_hash=NULL, *tempOutFile; umode_t inputFileMode, outputFileMode; bool outFileCreated=false, renamed=false, success = false; int err=0; arguments = (struct myargs *)kmalloc(sizeof(struct myargs), GFP_KERNEL); if (arguments==NULL) { printk("Failed to allocate kernel memory\n"); err = -ENOMEM; goto out1; } result = copy_from_user((void *)arguments, arg, sizeof(struct myargs)); if(result!=0) { printk("Copying from user failed\n"); err = -EFAULT; goto out2; } if (((struct myargs*)arg)->inputFile == NULL) { /*Checking whether user passed NULL input File*/ printk("user level input file argument is NULL\n"); err = -EINVAL; goto out2; } inputFileLen = strnlen_user(((struct myargs*)arg)->inputFile, 32767); //TODO get the maximum value from getname if (inputFileLen == -1) { printk("Finding User inputFile string length Failed\n"); err = -EFAULT; goto out2; } arguments->inputFile = (char *)kmalloc(inputFileLen*sizeof(char), GFP_KERNEL); if ((arguments->inputFile)==NULL) { printk("Failed to allocate kernel memory for input file\n"); err = -ENOMEM; goto out2; } result = strncpy_from_user(arguments->inputFile, ((struct myargs*)arg)->inputFile, inputFileLen); if(result!=(inputFileLen-1)) { printk("Copying input file string from user failed\n"); err = -EFAULT; goto out3; } if((arguments->inputFile)==NULL) { printk("Copying input file string from user failed\n"); err = -EFAULT; goto out3; } if (((struct myargs*)arg)->outputFile == NULL) { printk("user level output file argument is NULL\n"); err = -EINVAL; goto out3; } outputFileLen = strnlen_user(((struct myargs*)arg)->outputFile, 32767); //TODO get the maximum value from getname if (outputFileLen == -1) { printk("Finding User outputFile string length Failed\n"); err = -EFAULT; goto out3; } arguments->outputFile = (char *)kmalloc(outputFileLen*sizeof(char), GFP_KERNEL); if ((arguments->outputFile)==NULL) { printk("Failed to allocate kernel memory for outputfile\n"); err = -ENOMEM; goto out3; } result = strncpy_from_user(arguments->outputFile, ((struct myargs*)arg)->outputFile, outputFileLen); if(result!=(outputFileLen-1)) { printk("Copying output file string from user failed\n"); err = -EFAULT; goto out4; } if((arguments->outputFile)==NULL) { printk("Copying output file string from user failed\n"); err = -EFAULT; goto out4; } if (((struct myargs*)arg)->keyBuf == NULL) { printk("user level key buffer argument is NULL\n"); err = -EINVAL; goto out4; } keyLen = strnlen_user(((struct myargs*)arg)->keyBuf, 32767); //TODO get the maximum value from getname if (keyLen == -1) { printk("Finding User keyBuf string length Failed\n"); err = -EFAULT; goto out4; } arguments->keyBuf = (char *)kmalloc(keyLen*sizeof(char), GFP_KERNEL); if ((arguments->keyBuf)==NULL) { printk("Failed to allocate kernel memory\n"); err = -ENOMEM; goto out4; } result = strncpy_from_user(arguments->keyBuf, ((struct myargs*)arg)->keyBuf, keyLen); if(result!=(keyLen-1)) { printk("Copying key buf string from user failed\n"); err = -EFAULT; goto out5; } if((arguments->keyBuf)==NULL) { printk("Copying key buf string from user failed\n"); err = -EFAULT; goto out5; } if (strlen(arguments->keyBuf) != arguments->keyLen) { printk("User key buffer length and kernel key buffer lengths differ\n"); err = -EINVAL; goto out5; } if((arguments->flags)!=0 && (arguments->flags)!=1) { printk("Invalid values for flag argument, it should be either 1 or 0\n"); err = -EINVAL; goto out5; } srcbuffer = (char *)kmalloc((PAGE_SIZE+1)*sizeof(char), GFP_KERNEL); if (srcbuffer==NULL) { printk("Failed to allocate kernel memory for srcbuffer\n"); err = -ENOMEM; goto out5; } destbuffer = (char *)kmalloc((PAGE_SIZE+1)*sizeof(char), GFP_KERNEL); if (destbuffer==NULL) { printk("Failed to allocate kernel memory for destbuffer\n"); err = -ENOMEM; goto out6; } padding = (char *)kmalloc(4*sizeof(char), GFP_KERNEL); if (padding==NULL) { printk("Failed to allocate kernel memory for padding\n"); err = -ENOMEM; goto out7; } initialisePadding(padding); /*Initialising the padding array to all 0's */ result=PAGE_SIZE; filp = filp_open(arguments->inputFile, O_RDONLY, 0); if (PTR_ERR(filp)==-ENOENT) { printk("Input File doesnot exists\n"); err = -ENOENT; goto out8; } else { printk("Input File exists\n"); } if (!filp || IS_ERR(filp)) { printk("Read error for input file %d\n", (int) PTR_ERR(filp)); err = PTR_ERR(filp); goto out8; } inputFileMode = filp->f_inode->i_mode; if(!S_ISREG(inputFileMode)) { printk("Input File is not a regular file\n"); err = -EISDIR; goto out9; } if (!filp->f_op->read) { printk("Error in reading input file\n"); err = PTR_ERR(filp); goto out9; } filp1 = filp_open(arguments->outputFile, O_WRONLY, 0); if (PTR_ERR(filp1)==-ENOENT) { printk("Output File doesnot exists, creating it\n"); filp1 = filp_open(arguments->outputFile, O_CREAT, inputFileMode); /*Creating output file if it doesnot exists with input file permissions*/ if(!filp1 || IS_ERR(filp1)) { printk("Error in creating output file\n"); err = PTR_ERR(filp1); goto out8_1; } else { printk("Output File created succesfully\n"); outFileCreated = true; } } else { printk("Output File exists\n"); } if(!outFileCreated) { if(!filp1 || IS_ERR(filp1)) { printk("Error in opening output file\n"); err = PTR_ERR(filp1); goto out8_1; } } if(!outFileCreated) { outputFileMode = filp1->f_inode->i_mode; if(!S_ISREG(outputFileMode)) { printk("Output File is not a regular file\n"); err = -EISDIR; goto out9; } } if(!outFileCreated) { if (filp->f_inode->i_ino == filp1->f_inode->i_ino) { printk("Both input and output files are same, they should be different\n"); err = -EPERM; goto out9; } } if(!outFileCreated) { olddentry = filp1->f_path.dentry; filp_close(filp1, NULL); tempOutFile = (char *)kmalloc((strlen(arguments->outputFile)+5)*sizeof(char), GFP_KERNEL); strncpy(tempOutFile, arguments->outputFile, strlen(arguments->outputFile)); strcat(tempOutFile, ".tmp"); tempOutFile[(strlen(arguments->outputFile)+5)]='\0'; filp1 = filp_open(tempOutFile, O_WRONLY, 0); if (PTR_ERR(filp1)==-ENOENT || IS_ERR(filp1)) { printk("temp Output File doesnot exists, creating it\n"); } else { printk("temp output File exists, truncating and creating new one\n"); dentry = filp1->f_path.dentry; filp_close(filp1, NULL); err = file_unlink(dentry->d_parent->d_inode, dentry); if(err != 0) { printk("unlink of already existing temporary file failed\n"); err = -EBUSY; goto out9; } printk("unlink function returned : %d\n", err); } filp1 = filp_open(tempOutFile, O_CREAT, outputFileMode); if(!filp1 || IS_ERR(filp1)) { printk("Error in creating temp output file\n"); err = PTR_ERR(filp1); goto out8_1; } else { printk("temp output File created succesfully\n"); } } newdentry = filp1->f_path.dentry; if (!filp1 || IS_ERR(filp1)) { printk("Write error for output file %d\n", (int) PTR_ERR(filp1)); err = PTR_ERR(filp1); goto out10; } if (!filp1->f_op->write) { printk("Error in writing to temp output file\n"); err = PTR_ERR(filp1); goto out10; } md5_hash = kmalloc(17*sizeof(char), GFP_KERNEL); if (md5_hash==NULL) { printk("Failed to allocate kernel memory for key from file\n"); err = -ENOMEM; goto out10; } err = generate_md5(arguments->keyBuf, md5_hash, strlen(arguments->keyBuf)); if(err != 0) { printk("kernel MD5 generation failed\n"); goto out11; } md5_hash[strlen(arguments->keyBuf)] = '\0'; if (arguments->flags) { //ENCRYPTION preambleWritten = wrapfs_write_file(filp1, (void *)(md5_hash), strlen(md5_hash)); /*Writing Key hash to the file*/ if(preambleWritten < 0) { printk("Writing preamble failed\n"); err = -EFAULT; goto out11; } paddingWritten = wrapfs_write_file(filp1, (void *)(padding), 4); /*Writing Inital Padding to the file*/ if (paddingWritten < 0) { printk("Writing padding failed\n"); err = -EFAULT; goto out11; } while(result==PAGE_SIZE) { result = wrapfs_read_file(filp, (void *)srcbuffer, PAGE_SIZE); if(result < 0) { printk("Reading from input file failed\n"); err = -EFAULT; goto out11; } err = encrypt_Cipher(arguments->keyBuf, srcbuffer, destbuffer, result, &paddedresult); if (err < 0) { printk("Error occured while encrypting\n"); goto out11; } if(paddedresult!=result) { padvalue = paddedresult - result; buildPadding(padding, padvalue); result = paddedresult; } result = wrapfs_write_file(filp1, (void *)destbuffer, result); if (result < 0) { printk("Writing to output file failed\n"); err = -EFAULT; goto out11; } } paddingWritten = wrapfs_write_file_pos(filp1, (void *)padding, 4, preambleWritten); if (paddingWritten < 0) { printk("Writing padding failed\n"); err = -EFAULT; goto out11; } } else { //DECRYPTION keyFromFile = kmalloc(16*sizeof(char), GFP_KERNEL); if (keyFromFile==NULL) { printk("Failed to allocate kernel memory for key from file\n"); err = -ENOMEM; goto out11; } temp = wrapfs_read_file(filp, (void *)keyFromFile, strlen(md5_hash)); if (temp != strlen(md5_hash)) { printk("reading key from file failed\n"); err = -EFAULT; goto out12; } if (compareKeys(md5_hash, keyFromFile, temp)) { printk("Both Keys Match\n"); } else { printk("Both keys doesnot match\n"); err = -EINVAL; //TODO : Return proper error Value. goto out12; } paddingRead = wrapfs_read_file(filp, (void *)padding, 4); if(paddingRead < 0) { printk("Reading padding failed\n"); err = -EFAULT; goto out12; } padvalue = reconstructPadding(padding); if (padvalue < 0) { printk("Reconstructing padding value failed(negative value not acceptable)\n"); err = -EFAULT; goto out12; } printk("Pad value returned : %d\n", padvalue); while(result==PAGE_SIZE) { result = wrapfs_read_file(filp, (void *)srcbuffer, PAGE_SIZE); if (result < 0) { printk("Reading from input file failed\n"); err = -EFAULT; goto out12; } printk("result read from file : %u\n", result); err = decrypt_Cipher(arguments->keyBuf, srcbuffer, destbuffer, result); if (err < 0) { printk("Error occured while encrypting\n"); goto out12; } if (result<PAGE_SIZE) { result = result - padvalue; } result = wrapfs_write_file(filp1, (void *)destbuffer, result); if(result < 0) { printk("writing to output file failed\n"); err = -EFAULT; //TODO goto goto out12; } } } if(!outFileCreated) { err = file_rename(newdentry->d_parent->d_inode, newdentry, olddentry->d_parent->d_inode, olddentry); if(err!=0) { printk("renaming of tempfile to output file failed\n"); err = -EBUSY; goto out12; } else renamed = true; } else success = true; out12: if(keyFromFile) kfree(keyFromFile); out11: kfree(md5_hash); out10: if(filp1) filp_close(filp1, NULL); if((!renamed && !outFileCreated)||(!success && outFileCreated)) file_unlink(newdentry->d_parent->d_inode, newdentry); out9: if(filp1) filp_close(filp1, NULL); out8_1: if(filp) filp_close(filp, NULL); out8: kfree(padding); out7: kfree(destbuffer); out6: kfree(srcbuffer); out5: kfree(arguments->keyBuf); out4: kfree(arguments->outputFile); out3: kfree(arguments->inputFile); out2: kfree(arguments); out1: return err; } }
bool GridWorld::computeShortestPath(){ if (open.empty()){ std::cout << "ERROR: No tiles to expand on... can't do anything" << std::endl; return false; } double currentRHS, otherG, previousG; while (!open.empty() && (compareKeys(open.front()->key, start->key = calculateKey(start)) || start->rhs != start->g)){ Tile* current = open.front(); //Notice that CURRENT wasn't pop/removed yet.. KeyPair k_old = current->key; KeyPair k_new = calculateKey(current); currentRHS = current->rhs; otherG = current->g; /*std::cout << "Expanding:"; current->info(); std::cout << std::endl;*/ if (compareKeys(k_old, k_new)){ //This branch updates tile that were already in the OPEN list originally //This branch tends to execute AFTER the else branch current->key = k_new; make_heap(open.begin(), open.end(), GridWorld::compareTiles); } else if (otherG > currentRHS){ //Majority of the execution will fall under this conditional branch as //it is undergoing normal A* pathfinding current->g = current->rhs; otherG = currentRHS; open.erase(open.begin()); make_heap(open.begin(), open.end(), GridWorld::compareTiles); current->isOpen = false; std::vector<Tile*> neighbours(getNeighbours(current)); for (int i = 0; i < neighbours.size(); i++){ if (neighbours[i] != 0){ if (neighbours[i] != goal){ neighbours[i]->rhs = std::min(neighbours[i]->rhs, calculateC(current, neighbours[i]) + otherG); } updateVertex(neighbours[i]); } } } else { //Execution of this branch updates the tile during incremental search previousG = otherG; current->g = PF_INFINITY; //Update CURRENT'S RHS if (current != goal){ current->rhs = getMinSuccessor(current).second; } updateVertex(current); //Update NEIGHBOUR'S RHS to their minimum successor std::vector<Tile*> neighbours(getNeighbours(current)); for (int i = 0; i < neighbours.size(); i++){ if (neighbours[i] != 0){ if (neighbours[i]->rhs == (calculateC(current, neighbours[i]) + previousG) && neighbours[i] != goal){ neighbours[i]->rhs = getMinSuccessor(neighbours[i]).second; } updateVertex(neighbours[i]); } } } //Uncomment this to see CURRENT'S new values //std::cout << "Expanded:"; //current->info(); //std::cout << std::endl; } return true; }