char *xcap_uri_for_rls_resource(const str_t *xcap_root, const str_t *uri)
{
dstring_t s;
int l;
str_t c_uri;
char *dst = NULL;
if (!xcap_root) return NULL;
dstr_init(&s, 2 * xcap_root->len + 32);
dstr_append_str(&s, xcap_root);
if (xcap_root->s[xcap_root->len - 1] != '/') dstr_append(&s, "/", 1);
dstr_append_zt(&s, "rls-services/global/index/~~/rls-services/service[@uri=%22");
canonicalize_uri(uri, &c_uri);
dstr_append_str(&s, &c_uri);
if (c_uri.s) cds_free(c_uri.s);
dstr_append_zt(&s, "%22]");
l = dstr_get_data_length(&s);
if (l > 0) {
dst = (char *)cds_malloc(l + 1);
if (dst) {
dstr_get_data(&s, dst);
dst[l] = 0;
}
}
dstr_destroy(&s);
return dst;
}
static size_t write_data_func(void *ptr, size_t size, size_t nmemb, void *stream)
{
int s = size * nmemb;
/* TRACE_LOG("%d bytes writen\n", s);*/
if (s != 0) {
if (dstr_append((dstring_t*)stream, ptr, s) != 0) {
ERROR_LOG("can't append %d bytes into data buffer\n", s);
return 0;
}
}
return s;
}
// set new content for a dstr
dstr* dstr_set(dstr* ds, const char* s)
{
size_t len = strlen(s);
if (ds->max_len <= len) {
memcpy(ds->data, s, ds->max_len);
ds->data[ds->max_len] = 0;
ds->len = ds->max_len;
dstr_append(ds, &s[ds->max_len]);
}else{
memcpy(ds->data, s, len);
ds->len = len;
}
return ds;
}
static inline int add_subs_state_hf(dstring_t *buf, watcher_status_t _s, time_t _e)
{
char* num;
int len;
str s = STR_NULL;
static str timeout = STR_STATIC_INIT("timeout");
static str rejected = STR_STATIC_INIT("rejected");
switch(_s) {
case WS_ACTIVE:
;
s = watcher_status_names[WS_ACTIVE];
break;
case WS_REJECTED:
case WS_PENDING_TERMINATED:
case WS_TERMINATED:
s = watcher_status_names[WS_TERMINATED];
break;
case WS_PENDING:
s = watcher_status_names[WS_PENDING];
break;
}
dstr_append_zt(buf, "Subscription-State: ");
dstr_append_str(buf, &s);
switch(_s) {
case WS_PENDING:
;
case WS_ACTIVE:
dstr_append_zt(buf, ";expires=");
num = int2str((unsigned int)_e, &len);
dstr_append(buf, num, len);
break;
case WS_REJECTED:
case WS_PENDING_TERMINATED:
case WS_TERMINATED:
dstr_append_zt(buf, ";reason=");
if (_e <= 0) dstr_append_str(buf, &timeout);
else dstr_append_str(buf, &rejected);
break;
}
dstr_append_zt(buf, "\r\n");
return 0;
}
char *xcap_uri_for_rls_services(const str_t *xcap_root)
{
dstring_t s;
int l;
char *dst = NULL;
if (!xcap_root) return NULL;
dstr_init(&s, 2 * xcap_root->len + 32);
dstr_append_str(&s, xcap_root);
if (xcap_root->s[xcap_root->len - 1] != '/') dstr_append(&s, "/", 1);
dstr_append_zt(&s, "rls-services/global/index");
l = dstr_get_data_length(&s);
if (l > 0) {
dst = (char *)cds_malloc(l + 1);
if (dst) {
dstr_get_data(&s, dst);
dst[l] = 0;
}
}
dstr_destroy(&s);
return dst;
}
/*
* NAME: process()
* DESCRIPTION: sort and display results
*/
static
int process(hfsvol *vol, darray *dirs, darray *files,
int flags, int options, int width)
{
int i, dsz, fsz;
queueent *ents;
int result = 0;
dsz = darr_size(dirs);
fsz = darr_size(files);
if (fsz)
{
sortfiles(files, flags, options);
if (showfiles(files, flags, options, width) == -1)
result = -1;
flags |= HLS_NAME | HLS_SPACE;
}
else if (dsz > 1)
flags |= HLS_NAME;
ents = darr_array(dirs);
for (i = 0; i < dsz; ++i)
{
const char *path;
hfsdir *dir;
queueent ent;
darr_shrink(files, 0);
path = PATH(ents[i]);
dir = hfs_opendir(vol, path);
if (dir == 0)
{
hfsutil_perrorp(path);
result = -1;
continue;
}
while (hfs_readdir(dir, &ent.dirent) != -1)
{
if ((ent.dirent.fdflags & HFS_FNDR_ISINVISIBLE) &&
! (flags & HLS_ALL_FILES))
continue;
ent.path = 0;
ent.free = 0;
if (darr_append(files, &ent) == 0)
{
fprintf(stderr, "%s: not enough memory\n", argv0);
result = -1;
break;
}
if ((ent.dirent.flags & HFS_ISDIR) && (flags & HLS_RECURSIVE))
{
dstring str;
dstr_init(&str);
if (strchr(path, ':') == 0 &&
dstr_append(&str, ":", 1) == -1)
result = -1;
if (dstr_append(&str, path, -1) == -1)
result = -1;
if (path[strlen(path) - 1] != ':' &&
dstr_append(&str, ":", 1) == -1)
result = -1;
if (dstr_append(&str, ent.dirent.name, -1) == -1)
result = -1;
ent.path = strdup(dstr_string(&str));
if (ent.path)
ent.free = dpfree;
else
result = -1;
dstr_free(&str);
if (darr_append(dirs, &ent) == 0)
{
result = -1;
if (ent.path)
free(ent.path);
}
if (result)
{
fprintf(stderr, "%s: not enough memory\n", argv0);
break;
}
dsz = darr_size(dirs);
ents = darr_array(dirs);
}
}
hfs_closedir(dir);
if (result)
break;
if (flags & HLS_SPACE)
printf("\n");
if (flags & HLS_NAME)
printf("%s%s", path,
path[strlen(path) - 1] == ':' ? "\n" : ":\n");
sortfiles(files, flags, options);
if (showfiles(files, flags, options, width) == -1)
result = -1;
flags |= HLS_NAME | HLS_SPACE;
}
return result;
}
/*
* NAME: outpath()
* DESCRIPTION: modulate an output string given current flags
*/
static
int outpath(dstring *str, queueent *ent, int flags)
{
const char *path;
path = PATH(*ent);
dstr_shrink(str, 0);
if ((flags & HLS_QUOTE) &&
dstr_append(str, "\"", 1) == -1)
return -1;
if (flags & (HLS_ESCAPE | HLS_QUOTE | HLS_QMARK_CTRL))
{
const char *ptr;
for (ptr = path; *ptr; ++ptr)
{
const char *add;
char buf[5];
if (flags & HLS_ESCAPE)
{
switch (*ptr)
{
case '\\':
add = "\\\\";
break;
case '\n':
add = "\\n";
break;
case '\b':
add = "\\b";
break;
case '\r':
add = "\\r";
break;
case '\t':
add = "\\t";
break;
case '\f':
add = "\\f";
break;
case ' ':
add = "\\ ";
break;
case '\"':
add = "\\\"";
break;
default:
if (isgraph(*ptr))
{
sprintf(buf, "%c", *ptr);
add = buf;
}
else
{
sprintf(buf, "\\%03o", (unsigned char) *ptr);
add = buf;
}
}
}
else /* ! (flags & HLS_ESCAPE) */
{
if (isprint(*ptr) || ! (flags & HLS_QMARK_CTRL))
{
sprintf(buf, "%c", *ptr);
add = buf;
}
else
{
sprintf(buf, "?");
add = buf;
}
}
if (dstr_append(str, add, -1) == -1)
return -1;
}
}
else
{
if (dstr_append(str, path, -1) == -1)
return -1;
}
if ((flags & HLS_QUOTE) &&
dstr_append(str, "\"", 1) == -1)
return -1;
if (flags & HLS_INDICATOR)
{
char c = 0;
if (ent->dirent.flags & HFS_ISDIR)
c = ':';
else if (strcmp(ent->dirent.u.file.type, "APPL") == 0)
c = '*';
if (c && dstr_append(str, &c, 1) == -1)
return -1;
}
return 0;
}
// create a new dstr by concatenate a dstr and a C string
dstr* dstr_concat(dstr* ds, const char* s)
{
dstr* new_ds = dstr_copy(ds);
return dstr_append(new_ds, s);
}
int sstream_put(sstream_t *ss, const char *s, int len)
{
/* if (!is_input_sstream(ss)) return -1; */ /* dangerous optimalization */
return dstr_append(&ss->out, s, len);
}
