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 update_sexe_userdata(sexe_t *S)
{
SHFL *fl;
shjson_t *udata;
shfs_t *fs;
shbuf_t *buff;
shkey_t *k;
char path[PATH_MAX+1];
char *str;
int err;
k = &S->pname;
if (shkey_cmp(k, ashkey_blank())) {
fprintf(stderr, "DEBUG: update_sexe_userdata: no app key\n");
return (0); /* blank */
}
sprintf(path, "/sys/data/sexe/%s", shkey_hex(k));
lua_getglobal(S, "userdata");
udata = sexe_table_get(S);
if (!udata) {
fprintf(stderr, "DEBUG: update_sexe_userdata: no global 'userdata' variable.\n");
return (SHERR_INVAL);
}
str = shjson_print(udata);
if (!str) {
fprintf(stderr, "DEBUG: update_sexe_userdata: error encoding JSON.\n");
return (SHERR_INVAL);
}
shjson_free(&udata);
buff = shbuf_init();
shbuf_catstr(buff, str);
free(str);
fs = shfs_init(NULL);
fl = shfs_file_find(fs, path);
err = shfs_write(fl, buff);
shbuf_free(&buff);
shfs_free(&fs);
return (err);
}
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 pstore_write(int tx_op, char *name, unsigned char *data, size_t data_len)
{
SHFL *fl;
char prefix[256];
char path[PATH_MAX+1];
shbuf_t *buff;
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;
}
sprintf(path, "/sys/net/tx/%s/%s", prefix, name);
fl = shfs_file_find(_pstore_fs, path);
buff = shbuf_init();
shbuf_cat(buff, data, data_len);
err = shfs_write(fl, buff);
shbuf_free(&buff);
if (err)
return (err);
return (0);
}
int pstore_delete(int tx_op, char *hash)
{
char path[PATH_MAX+1];
char prefix[256];
shfs_ino_t *fl;
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;
case TX_LICENSE:
strcpy(prefix, "license");
break;
default:
strcpy(prefix, "default");
break;
}
sprintf(path, "/sys/net/tx/%s/%s", prefix, hash);
fl = shfs_file_find(_pstore_fs, path);
err = shfs_file_remove(fl);
if (err)
return (err);
return (0);
}
shfs_ino_t *shpam_shadow_file(shfs_t **fs_p)
{
shfs_ino_t *sys_dir;
shfs_ino_t *file;
shpeer_t *peer;
shfs_t *fs;
fs = *fs_p;
if (!fs) {
fs = shfs_sys_init(SHFS_DIR_PAM, "shadow", &file);
} else {
file = shfs_file_find(fs, shfs_sys_dir(SHFS_DIR_PAM, "shadow"));
}
/* ?? */
shfs_access_owner_set(file, shpam_ident_root(&fs->peer));
*fs_p = fs;
return (file);
}
int share_file_copy_recursive(SHFL *dest_file, char *fname)
{
shfs_dirent_t *ents;
shfs_t *fs;
SHFL **files;
SHFL *dir;
struct stat st;
char spec_prefix[SHFS_PATH_MAX];
char spec_dir[SHFS_PATH_MAX];
char spec_fname[SHFS_PATH_MAX];
char path[SHFS_PATH_MAX];
char work_path[SHFS_PATH_MAX];
char buf[4096];
char *list_fname;
char *ptr;
int ent_nr;
int err;
int i;
memset(spec_prefix, 0, sizeof(spec_prefix));
ptr = strstr(fname, ":/");
if (ptr) {
ptr += 2;
strncpy(spec_prefix, fname, MIN(sizeof(spec_prefix)-1, (ptr-fname)));
fname += strlen(spec_prefix);
}
if (!strchr(fname, '/') || 0 == strncmp(fname, "./", 2)) {
if (0 == strncmp(fname, "./", 2))
fname += 2;
strcpy(spec_prefix, "file:/");
getcwd(buf, sizeof(buf)-1);
strcat(buf, "/");
strcat(buf, fname);
ptr = strrchr(buf, '/');
strncpy(spec_dir, buf + 1, strlen(buf) - strlen(ptr));
sprintf(spec_fname, "%s%s", spec_dir, ptr+1);
list_fname = basename(spec_fname);
} else {
memset(spec_fname, 0, sizeof(spec_fname));
strncpy(spec_fname, fname, sizeof(spec_fname)-1);
list_fname = basename(spec_fname);
memset(spec_dir, 0, sizeof(spec_dir));
strncpy(spec_dir, fname, MIN(strlen(fname) - strlen(list_fname), sizeof(spec_dir)-1));
}
sprintf(path, "%s%s", spec_prefix, spec_dir);
fprintf(stderr, "DEBUG: file_recursive: shfs_uri_init(%s)\n", path);
fs = shfs_uri_init(path, 0, &dir);
if (!*list_fname) {
/* directory reference. */
ent_nr = 1;
files = (SHFL **)calloc(ent_nr+1, sizeof(SHFL *));
if (!files) return (SHERR_NOMEM);
files[0] = dir;
} else {
/* search files in directory */
err = 0;
ent_nr = shfs_list(dir, list_fname, &ents);
if (ent_nr <= 0)
return (ent_nr);
err = SHERR_NOENT;
files = (SHFL **)calloc(ent_nr+1, sizeof(SHFL *));
if (!files) return (SHERR_NOMEM);
for (i = 0; i < ent_nr; i++) {
ptr = strstr(spec_dir, ":/");
if (ptr) {
sprintf(path, "%s%s", ptr+2, ents[i].d_name);
} else {
sprintf(path, "%s%s", spec_dir, ents[i].d_name);
}
err = shfs_stat(fs, path, &st);
if (err)
break;
files[i] = shfs_file_find(fs, path);
}
shfs_list_free(&ents);
if (err) {
free(files);
return (err);
}
}
#if 0
/* handle recursive hierarchy */
if ((run_flags & PFLAG_RECURSIVE)) {
for (i = 0; i < ent_nr; i++) {
if (shfs_type(files[i]) != SHINODE_DIRECTORY)
continue;
/* .. */
}
}
#endif
for (i = 0; i < ent_nr; i++) {
/* perform file copy */
err = shfs_file_copy(files[i], dest_file);
if (err) {
fprintf(sharetool_fout, "%s: error copying \"%s\" to \"%s\": %s [sherr %d].\n",
process_path, shfs_filename(files[i]), shfs_filename(dest_file),
sherrstr(err), err);
return (err);
}
if (!(run_flags & PFLAG_QUIET) && (run_flags & PFLAG_VERBOSE)) {
fprintf(sharetool_fout, "%s: %s \"%s\" copied to %s \"%s\".\n",
process_path,
shfs_type_str(shfs_type(files[i])), shfs_filename(files[i]),
shfs_type_str(shfs_type(dest_file)), shfs_filename(dest_file));
}
}
free(files);
shfs_free(&fs);
return (0);
}
