int shpam_shadow_pass_append(shfs_ino_t *file, shseed_t *seed) { shbuf_t *buff; shseed_t *seeds; int total; int idx; int err; buff = shbuf_init(); shfs_read(file, buff); seeds = (shseed_t *)shbuf_data(buff); total = shbuf_size(buff) / sizeof(shseed_t); for (idx = 0; idx < total; idx++) { if (seeds[idx].seed_uid == seed->seed_uid) { memcpy(&seeds[idx], seed, sizeof(shseed_t)); break; } } if (idx == total) { shbuf_cat(buff, seed, sizeof(shseed_t)); } err = shfs_write(file, buff); shbuf_free(&buff); if (err) return (err); return (0); }
int install_sexe_userdata(sexe_t *S, char *tag) { SHFL *fl; shjson_t *udata; shfs_t *fs; shbuf_t *buff; shkey_t *k; char path[PATH_MAX+1]; int is_new; k = shkey_str(tag); sprintf(path, "/sys/data/sexe/%s", shkey_hex(k)); memcpy(&S->pname, k, sizeof(S->pname)); shkey_free(&k); buff = shbuf_init(); fs = shfs_init(NULL); fl = shfs_file_find(fs, path); is_new = shfs_read(fl, buff); udata = shjson_init(shbuf_size(buff) ? (char *)shbuf_data(buff) : NULL); shbuf_free(&buff); if (is_new) shjson_num_add(udata, "birth", shtimef(shtime())); sexe_table_set(S, udata); lua_setglobal(S, "userdata"); shjson_free(&udata); shfs_free(&fs); return (0); }
int shpam_shadow_pass_remove(shfs_ino_t *file, uint64_t rem_uid) { shbuf_t *rbuff; shbuf_t *buff; shseed_t *seeds; int total; int idx; int err; rbuff = shbuf_init(); shfs_read(file, rbuff); buff = shbuf_init(); seeds = (shseed_t *)shbuf_data(rbuff); total = shbuf_size(rbuff) / sizeof(shseed_t); for (idx = 0; idx < total; idx++) { if (seeds[idx].seed_uid == rem_uid) continue; shbuf_cat(buff, &seeds[idx], sizeof(shseed_t)); } shbuf_free(&rbuff); err = shfs_write(file, buff); shbuf_free(&buff); if (err) return (err); return (0); }
int shfs_file_pipe(shfs_ino_t *file, int fd) { shbuf_t *buff; ssize_t b_of; int b_len; int err; if (file == NULL) return (SHERR_NOENT); buff = shbuf_init(); err = shfs_read(file, buff); if (err) { shbuf_free(&buff); return (err); } for (b_of = 0; b_of < buff->data_of; b_of++) { b_len = write(fd, buff->data + b_of, buff->data_of - b_of); if (b_len < 0) { shbuf_free(&buff); return (-errno); } b_of += b_len; } shbuf_free(&buff); return (0); }
const shseed_t *shpam_shadow_pass(shfs_ino_t *file, uint64_t uid) { static shseed_t ret_seed; shbuf_t *buff; shseed_t *seeds; int total; int idx; int err; memset(&ret_seed, 0, sizeof(ret_seed)); buff = shbuf_init(); err = shfs_read(file, buff); if (err) { shbuf_free(&buff); return (NULL); } seeds = (shseed_t *)shbuf_data(buff); total = shbuf_size(buff) / sizeof(shseed_t); for (idx = 0; idx < total; idx++) { if (seeds[idx].seed_uid == uid) { memcpy(&ret_seed, &seeds[idx], sizeof(shseed_t)); break; } } shbuf_free(&buff); if (idx != total) { return (&ret_seed); } return (NULL); }
int shfs_rev_diff(shfs_ino_t *file, shkey_t *rev_key, shbuf_t *buff) { shbuf_t *work_buff; shbuf_t *head_buff; shfs_ino_t *new_rev; shfs_ino_t *delta; shfs_ino_t *rev; shfs_t *fs; int err; if (!file || shfs_type(file) != SHINODE_FILE) return (SHERR_INVAL); if (!buff) return (SHERR_INVAL); if (!rev_key) { /* obtain current committed revision. */ rev = shfs_rev_base(file); } else { rev = shfs_rev_get(file, rev_key); } if (!rev) return (SHERR_NOENT); /* obtain work-data for BASE branch revision. */ head_buff = shbuf_init(); err = shfs_rev_ref_read(file, "tag", "BASE", head_buff); if (err) { shbuf_free(&head_buff); return (err); } work_buff = shbuf_init(); err = shfs_read(file, work_buff); if (err) { shbuf_free(&head_buff); shbuf_free(&work_buff); return (err); } if (shbuf_size(work_buff) == shbuf_size(head_buff) && 0 == memcmp(shbuf_data(work_buff), shbuf_data(head_buff), shbuf_size(work_buff))) { /* no difference to report */ err = 0; } else { /* print textual difference to <buff> */ err = shdiff(buff, shbuf_data(work_buff), shbuf_data(head_buff)); } shbuf_free(&work_buff); shbuf_free(&head_buff); return (err); }
int share_file_cat(char *path, int pflags) { shstat st; shfs_t *tree; shfs_ino_t *file; shbuf_t *buff; char fpath[PATH_MAX+1]; unsigned char *data; size_t data_len; size_t of; int w_len; int err; tree = shfs_uri_init(path, 0, &file); if (!tree) return (SHERR_NOENT); err = shfs_fstat(file, &st); if (err) { shfs_free(&tree); return (err); } buff = shbuf_init(); err = shfs_read(file, buff); if (err) { shbuf_free(&buff); shfs_free(&tree); return (err); } of = 0; while (of < shbuf_size(buff)) { data_len = MIN((shbuf_size(buff) - of), 65536); data = shbuf_data(buff) + of; w_len = fwrite(data, sizeof(char), data_len, sharetool_fout); if (w_len < 0) { shbuf_free(&buff); shfs_free(&tree); return (-errno); } of += w_len; } shbuf_free(&buff); shfs_free(&tree); return (0); }
int shfs_rev_delta(shfs_ino_t *file, shbuf_t *diff_buff) { shstat st; shbuf_t *work_buff; shbuf_t *head_buff; shbuf_t *ref_buff; shfs_t *fs; shkey_t *key; int err; if (shfs_type(file) != SHINODE_FILE) return (SHERR_INVAL); err = shfs_fstat(file, &st); if (err) return (err); work_buff = shbuf_init(); err = shfs_read(file, work_buff); if (err) { shbuf_free(&work_buff); return (err); } /* obtain BASE branch snapshot */ head_buff = shbuf_init(); err = shfs_rev_ref_read(file, "tag", "BASE", head_buff); if (err) goto done; if (shbuf_size(work_buff) == shbuf_size(head_buff) && 0 == memcmp(shbuf_data(work_buff), shbuf_data(head_buff), shbuf_size(work_buff))) { /* no difference */ err = SHERR_AGAIN; goto done; } err = shdelta(work_buff, head_buff, diff_buff); done: shbuf_free(&work_buff); shbuf_free(&head_buff); shbuf_free(&work_buff); return (err); }
int shfs_ref_read(shfs_ino_t *file, shbuf_t *buff) { shfs_t *fs; shfs_ino_t *ref; int err; err = shfs_ref_get(file, &fs, &ref); if (err) return (err); err = shfs_read(ref, buff); shfs_free(&fs); if (err) return (err); return (0); }
void *pstore_read(int tx_op, char *name) { SHFL *fl; shbuf_t *buff; char path[PATH_MAX+1]; char prefix[256]; unsigned char *data; size_t data_len; int err; pstore_init(); memset(prefix, 0, sizeof(prefix)); switch (tx_op) { case TX_ACCOUNT: strcpy(prefix, "account"); break; case TX_IDENT: strcpy(prefix, "id"); break; case TX_SESSION: strcpy(prefix, "session"); break; case TX_APP: strcpy(prefix, "app"); break; case TX_LEDGER: strcpy(prefix, "ledger"); break; default: strcpy(prefix, "default"); break; } buff = shbuf_init(); sprintf(path, "/sys/net/tx/%s/%s", prefix, name); fl = shfs_file_find(_pstore_fs, path); err = shfs_read(fl, buff); if (err) { shbuf_free(&buff); return (NULL); } return (shbuf_unmap(buff)); }
int shfs_file_read(shfs_ino_t *file, unsigned char *data, size_t data_len) { shbuf_t *buff; ssize_t r_len; int err; buff = shbuf_init(); err = shfs_read(file, buff); if (err) { shbuf_free(&buff); return (err); } r_len = MIN(shbuf_size(buff), data_len); if (shbuf_size(buff) != 0) memcpy(data, shbuf_data(buff), r_len); shbuf_free(&buff); return ((int)r_len); }
int shpam_pshadow_load(shfs_ino_t *file, uint64_t uid, shseed_t *ret_seed) { shbuf_t *buff; shseed_t *seeds; int total; int idx; int err; if (ret_seed) memset(ret_seed, 0, sizeof(shseed_t)); buff = shbuf_init(); err = shfs_read(file, buff); if (err) { shbuf_free(&buff); return (err); } seeds = (shseed_t *)shbuf_data(buff); total = shbuf_size(buff) / sizeof(shseed_t); if (!total) { shbuf_free(&buff); return (SHERR_NOENT); /* done */ } for (idx = 0; idx < total; idx++) { if (seeds[idx].seed_uid == uid) break; } if (idx == total) { shbuf_free(&buff); return (SHERR_NOENT); } if (ret_seed) memcpy(ret_seed, &seeds[idx], sizeof(shseed_t)); shbuf_free(&buff); return (0); }
int shpam_pshadow_store(shfs_ino_t *file, shseed_t *seed) { shbuf_t *buff; shseed_t *seeds; int total; int idx; int err; #if 0 /* ensure record exists. */ err = shpam_pshadow_load(file, seed->seed_uid, NULL); if (err) return (err); #endif buff = shbuf_init(); shfs_read(file, buff); seeds = (shseed_t *)shbuf_data(buff); total = shbuf_size(buff) / sizeof(shseed_t); for (idx = 0; idx < total; idx++) { if (seeds[idx].seed_uid == seed->seed_uid) { memcpy(&seeds[idx], seed, sizeof(shseed_t)); break; } } if (idx == total) { shbuf_cat(buff, seed, sizeof(shseed_t)); } err = shfs_write(file, buff); shbuf_free(&buff); if (err) return (err); return (0); }
int shfs_rev_commit(shfs_ino_t *file, shfs_ino_t **rev_p) { shstat st; shbuf_t *diff_buff; shbuf_t *work_buff; shbuf_t *head_buff; shfs_ino_t *base; shfs_ino_t *repo; /* SHINODE_REPOSITORY */ shfs_ino_t *new_rev; /* SHINODE_REVISION */ shfs_ino_t *delta; /* SHINODE_DELTA */ shkey_t *rev_key; shfs_t *fs; int err; if (rev_p) *rev_p = NULL; head_buff = work_buff = diff_buff = NULL; err = shfs_fstat(file, &st); if (err) return (err); work_buff = shbuf_init(); err = shfs_read(file, work_buff); if (err) goto done; base = shfs_rev_base(file); if (base) { /* obtain delta of current file data content against BASE revision's data content. */ head_buff = shbuf_init(); err = shfs_rev_ref_read(file, "tag", "BASE", head_buff); if (err) goto done; if (shbuf_size(work_buff) == shbuf_size(head_buff) && 0 == memcmp(shbuf_data(work_buff), shbuf_data(head_buff), shbuf_size(work_buff))) { /* no difference */ err = SHERR_AGAIN; goto done; } diff_buff = shbuf_init(); err = shdelta(work_buff, head_buff, diff_buff); shbuf_free(&head_buff); if (err) return (err); rev_key = shfs_token(base); } else { /* initial revision */ rev_key = ashkey_uniq(); } repo = shfs_inode(file, NULL, SHINODE_REPOSITORY); if (!repo) { err = SHERR_IO; goto done; } /* create a new revision using previous revision's inode name */ new_rev = shfs_inode(repo, (char *)shkey_hex(rev_key), SHINODE_REVISION); if (!new_rev) { err = SHERR_IO; goto done; } /* define revision's meta information. */ shfs_meta_set(new_rev, SHMETA_USER_NAME, (char *)get_libshare_account_name()); /* save delta to new revision */ err = shfs_rev_delta_write(new_rev, diff_buff); shbuf_free(&diff_buff); if (err) goto done; /* save new revision as BASE branch head */ err = shfs_rev_base_set(file, new_rev); if (err) goto done; /* save work-data to BASE tag. */ err = shfs_rev_ref_write(file, "tag", "BASE", work_buff); shbuf_free(&work_buff); if (err) goto done; if (base) { /* tag previous revision's key token onto revision inode. */ shfs_rev_tag(new_rev, "PREV", base); } if (rev_p) *rev_p = new_rev; done: shbuf_free(&work_buff); shbuf_free(&diff_buff); shbuf_free(&head_buff); return (err); }
int shfs_file_copy(shfs_ino_t *src_file, shfs_ino_t *dest_file) { shfs_t *ref_fs; shfs_ino_t *ref; shstat st; shbuf_t *buff; int err; if (!src_file || !dest_file) return (SHERR_INVAL); /* ensure there is something to copy */ err = shfs_fstat(src_file, &st); if (err) { fprintf(stderr, "DEBUG: shfs_file_copy: %d = shfs_fstat(src_file)\n", err); return (err); } if (shfs_type(dest_file) == SHINODE_DIRECTORY) { #if 0 /* extract tar archive */ if (shfs_format(dest_file) == SHINODE_BINARY && 0 == strcmp(shfs_meta_get(dest_file, "content.mime"), "application/x-tar")) { buff = shbuf_init(); err = shfs_read(src_file, buff); if (err) { shbuf_free(&buff); return (err); } err = shfs_unarch(buff, dest_file); shbuf_free(&buff); return (0); } #endif if (!(shfs_attr(src_file) & SHATTR_ARCH)) { if (IS_INODE_CONTAINER(shfs_type(src_file))) { dest_file = shfs_inode(dest_file, shfs_filename(src_file), shfs_type(src_file)); } else { dest_file = shfs_inode(dest_file, NULL, shfs_type(src_file)); } } } ref = NULL; ref_fs = NULL; if (shfs_format(dest_file) == SHINODE_REFERENCE) { /* apply operation to end-point inode. */ err = shfs_ref_get(dest_file, &ref_fs, &ref); if (err) { fprintf(stderr, "DEBUG: shfs_file_copy: %d = shfs_ref_get(dest_file)\n", err); return (err); } dest_file = ref; } if (shfs_format(dest_file) != SHINODE_EXTERNAL) { /* direct copy data content without conversion when applicable. */ switch (shfs_format(src_file)) { #if 0 case SHINODE_COMPRESS: err = shfs_zlib_copy(src_file, dest_file); if (err) return (err); return (0); #endif } } /* default case */ buff = shbuf_init(); err = shfs_read(src_file, buff); if (err) { fprintf(stderr, "DEBUG: shfs_file_copy: %d = shfs_read()\n", err); goto done; } err = shfs_write(dest_file, buff); shbuf_free(&buff); if (err) { fprintf(stderr, "DEBUG: shfs_file_copy: %d = shfs_write()\n", err); goto done; } /* success */ err = 0; done: shbuf_free(&buff); if (ref_fs) shfs_free(&ref_fs); return (err); }