/** * Desc: get the open mode of the file: * Return: 000 - not open; 001 - read only; 010 - write only; 011 - read and write; -1 - failed */ int zht_get_openmode(const char *virtualfname) { char *buf; // Buffer to store serialized data unsigned len; // Length of serialized data char result[ZHT_MAX_BUFF] = {0}; //return result size_t ln; //return length int rtn; Package package = PACKAGE__INIT; // Package package.virtualpath = (char*)virtualfname; package.realfullpath = ""; package.has_operation = true; package.operation = 1; //1 for look up, 2 for remove, 3 for insert len = package__get_packed_size(&package); buf = (char*) calloc(len, sizeof(char)); package__pack(&package, (uint8_t *)buf); int lret = c_zht_lookup(buf, result, &ln); if (lret == 0 && ln > 0) { Package *lkPackage; lkPackage = package__unpack(NULL, ln, (const uint8_t *)result); if (lkPackage == NULL) { fprintf(stderr, "error unpacking lookup result\n"); } rtn = lkPackage->openmode; package__free_unpacked(lkPackage, NULL); } free(buf); // Free the allocated serialized buffer return rtn; }
int zht_lookup(const char *key, char *val) { // return c_zht_lookup2(key, val); // size_t len; // return c_zht_lookup2(key, val, &len); char *buf; // Buffer to store serialized data unsigned len; // Length of serialized data char result[ZHT_MAX_BUFF] = {0}; //return result size_t ln; //return length Package package = PACKAGE__INIT; // Package package.virtualpath = (char*)key; // package.realfullpath = ""; // package.has_operation = true; package.operation = 1; //1 for look up, 2 for remove, 3 for insert len = package__get_packed_size(&package); buf = (char*) calloc(len, sizeof(char)); package__pack(&package, (uint8_t *)buf); int lret = c_zht_lookup(buf, result, &ln); if (lret == 0 && ln > 0) { Package *lkPackage; // char *lkBuf = (char*) calloc(ln, sizeof(char)); // char lkBuf[ln + 1] = {0}; // strncpy(lkBuf, result, ln); lkPackage = package__unpack(NULL, ln, (const uint8_t *)result); if (lkPackage == NULL) { fprintf(stderr, "error unpacking lookup result\n"); } // else { // fprintf(stderr, // "c_zht_lookup, return {key}:{value} ==>\n{%s}:{%s}\n", // lkPackage->virtualpath, lkPackage->realfullpath); // } // free(lkBuf); strcpy(val, lkPackage->realfullpath); package__free_unpacked(lkPackage, NULL); } //fprintf(stderr, "dfz debug: in zht_lookup(): val = %s. \n", val); log_msg("DFZ debug: in zht_lookup(): key = %s, val = %s. \n\n", key, val); free(buf); // Free the allocated serialized buffer return 0; }
extern void _c_zht_lookup2(char *key, char *ret) { Package package2 = PACKAGE__INIT; package2.virtualpath = key; package2.operation = 1; unsigned len = package__get_packed_size(&package2); char *buf = (char*) calloc(len, sizeof(char)); package__pack(&package2, buf); size_t ln; char *result = (char*)calloc(1024 * 10, sizeof(char)); if (result != NULL) { int lret = c_zht_lookup(buf, result, &ln); free(buf); if (lret == 0 && ln > 0) { //printf("OK, seems fine!\n"); Package * lPackage; char *lBuf = (char*) calloc(ln, sizeof(char)); strncpy(lBuf, result, ln); lPackage = package__unpack(NULL, ln, lBuf); free(lBuf); free(result); if (lPackage == NULL) { printf("error unpacking lookup result\n"); } else { //printf("The value is:%s\n", lPackage->realfullpath); strcpy(ret, lPackage->realfullpath); } } else { free(result); } } }
void test_pass_package() { char *key = "hello"; char *value = "zht"; Package package = PACKAGE__INIT; // Package package.virtualpath = key; package.realfullpath = value; package.has_isdir = true; package.isdir = true; package.has_operation = true; package.operation = 3; //1 for look up, 2 for remove, 3 for insert char *buf; // Buffer to store serialized data unsigned len; // Length of serialized data len = package__get_packed_size(&package); buf = (char*) calloc(len, sizeof(char)); package__pack(&package, buf); /* * test c_zht_insert * */ int iret = c_zht_insert(buf); fprintf(stderr, "c_zht_insert, return code: %d\n", iret); /* * test c_zht_lookup * */ memset(buf, 0, len); package.operation = 1; //1 for look up, 2 for remove, 3 for insert package.realfullpath = ""; package__pack(&package, buf); size_t ln; char *result = (char*) calloc(LOOKUP_SIZE, sizeof(char)); if (result != NULL) { int lret = c_zht_lookup(buf, result, &ln); fprintf(stderr, "c_zht_lookup, return code(length): %d(%lu)\n", lret, ln); if (lret == 0 && ln > 0) { Package *lkPackage; char *lkBuf = (char*) calloc(ln, sizeof(char)); strncpy(lkBuf, result, ln); lkPackage = package__unpack(NULL, ln, lkBuf); if (lkPackage == NULL) { fprintf(stderr, "error unpacking lookup result\n"); } else { fprintf(stderr, "c_zht_lookup, return {key}:{value} ==>\n{%s}:{%s}\n", lkPackage->virtualpath, lkPackage->realfullpath); } free(lkBuf); package__free_unpacked(lkPackage, NULL); } } free(result); /* * test c_zht_remove * */ memset(buf, 0, len); package.operation = 2; //1 for look up, 2 for remove, 3 for insert package__pack(&package, buf); int rret = c_zht_remove(buf); fprintf(stderr, "c_zht_remove, return code: %d\n", rret); free(buf); // Free the allocated serialized buffer }
int main(int argc, char *argv[]) { int i; int fuse_stat; struct fusion_state *fusion_data; // fusionfs doesn't do any access checking on its own (the comment // blocks in fuse.h mention some of the functions that need // accesses checked -- but note there are other functions, like // chown(), that also need checking!). Since running fusionfs as root // will therefore open Metrodome-sized holes in the system // security, we'll check if root is trying to mount the filesystem // and refuse if it is. The somewhat smaller hole of an ordinary // user doing it with the allow_other flag is still there because // I don't want to parse the options string. if ((getuid() == 0) || (geteuid() == 0)) { fprintf(stderr, "Running BBFS as root opens unnacceptable security holes\n"); return 1; } fusion_data = calloc(sizeof(struct fusion_state), 1); if (fusion_data == NULL) { perror("main calloc"); abort(); } fusion_data->logfile = log_open(); // libfuse is able to do most of the command line parsing; all I // need to do is to extract the rootdir; this will be the first // non-option passed in. I'm using the GNU non-standard extension // and having realpath malloc the space for the path // the string. for (i = 1; (i < argc) && (argv[i][0] == '-'); i++) if (argv[i][1] == 'o') i++; // -o takes a parameter; need to // skip it too. This doesn't // handle "squashed" parameters if ((argc - i) != 2) fusion_usage(); fusion_data->rootdir = realpath(argv[i], NULL); argv[i] = argv[i + 1]; argc--; /* * DFZ: test gbuf starts */ printf("\n=====Start testing Google Protocol Buffer=====\n\n"); size_t size = 0, size2 = 0; Package pkg = PACKAGE__INIT; Package *pkg_rtn; /* test data */ pkg.has_replicano = 1; /* This is in need if this int32 is optional */ pkg.replicano = 5; pkg.has_operation = 1; pkg.operation = 3; pkg.virtualpath = "mykey"; pkg.realfullpath = "mypathname"; pkg.has_isdir = true; pkg.isdir = false; /* pack the data */ size = package__get_packed_size(&pkg); unsigned char *packed = malloc(size); size2 = package__pack(&pkg, packed); assert(size == size2); printf("\n=====DFZ debug gbuf: packed = %s. \n\n", packed); /* unpack the data */ pkg_rtn = package__unpack(NULL, size, packed); /* verify the matchings */ printf("dfz debug: pkg_rtn->replicano = %d \n", pkg_rtn->replicano); printf("dfz debug: pkg_rtn->operation = %d \n", pkg_rtn->operation); printf("dfz debug: pkg_rtn->virtualpath = %s \n", pkg_rtn->virtualpath); printf("dfz debug: pkg_rtn->realfullpath = %s \n", pkg_rtn->realfullpath); package__free_unpacked(pkg_rtn, NULL); free(packed); printf("\n=====Finish testing Google Protocol Buffer=====\n\n"); /* * DFZ: test gbuf ends */ /* DFZ: initialize the hash table */ zht_init(); /* initialize new spade */ fprintf(stderr, "init spade...\n"); if (spade_init() < 0) { perror("spade failed"); return -1; } printf("spade done \n"); /*DFZ: add root dir in ZHT*/ zht_insert("/", " "); /*DFZ: test GPU erasure printf("start testing GPU erasure.\n"); gib_context gc; int m = 2, n = 2; int rc = gib_init(m, n, &gc); if (rc) { printf("error in gib_init.\n"); exit (1); } int bs = 1024 * 1024; void *data, *dense_data; gib_alloc(&data, bs, &bs, gc); gib_generate(data, bs, gc); char buff_id[256] = {'1'}; gib_recover(data, bs, buff_id, m, gc); gib_free(data, gc); gib_destroy(gc); printf("GPU erasure successful. \n"); DFZ: end of GPU erasure test*/ fprintf(stderr, "about to call fuse_main\n"); fuse_stat = fuse_main(argc, argv, &fusion_oper, fusion_data); fprintf(stderr, "fuse_main returned %d\n", fuse_stat); /* DFZ: destruct the hash table */ zht_free(); spade_close(); return fuse_stat; }