static int flush_out(cstring *cstr, void *vdom, int end)
{
assert(vdom);
if (cstr == NULL || vdom == NULL)
return -1;
domain_run *dom = vdom;
size_t const size = cstr_length(cstr);
if (dom->out && size &&
fwrite(cstr_get(cstr), size, 1, dom->out) != 1)
cstr = NULL;
return flush_common(dom, cstr, end);
}
static void stag(xml_tree *xml, char const* tag)
{
assert(xml);
assert(xml->depth < sizeof xml->tag/sizeof xml->tag[0]);
assert(xml->depth > 0 || cstr_length(xml->cstr) == 0);
assert(xml->depth == 0 || xml->cstr != NULL);
if (xml->depth == 0)
{
if (xml->cstr == NULL)
xml->cstr = cstr_init(1024);
if (xml->cstr)
xml->cstr = cstr_setstr(xml->cstr,
"<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n");
}
indent(xml, xml->depth);
if (xml->cstr)
xml->cstr = cstr_printf(xml->cstr, "<%s>\n",
xml->tag[xml->depth++] = tag);
}
static int flush_out_z(cstring *cstr, void *vdom, int end)
// z implies base64
{
assert(vdom);
if (cstr == NULL || vdom == NULL)
return -1;
#define B64_BYTE(T) base64_symbol[(T) % 64]
static unsigned char base64_symbol[] =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
domain_run *dom = vdom;
if (dom->out)
{
z_stream *zout = &dom->b64.zout;
zout->avail_in = cstr_length(cstr);
zout->next_in = cstr->data;
unsigned char buf[4096];
size_t rest = dom->b64.rest, col = dom->b64.col;
if (rest) memcpy(buf, dom->b64.restbuf, rest);
do
{
zout->avail_out = sizeof buf - rest;
zout->next_out = buf + rest;
deflate(zout, end? Z_FINISH: Z_NO_FLUSH);
size_t have = sizeof buf - zout->avail_out;
if (have)
{
size_t size = 2 + 4*(have+2)/3;
size += (size + 75)/76;
char base64[size], *out = base64;
unsigned char *in = buf;
for (rest = have; rest >= 3; rest -= 3)
{
uint32_t const t =
(uint32_t)in[0] << 16 | (uint32_t)in[1] << 8 | in[2];
in += 3;
*out++ = B64_BYTE(t >> 18);
*out++ = B64_BYTE(t >> 12);
*out++ = B64_BYTE(t >> 6);
*out++ = B64_BYTE(t);
if ((col += 4) >= 76)
{
*out++ = '\n';
col = 0;
}
}
if (rest)
{
if (end && zout->avail_out != 0)
{
uint32_t t = (uint32_t)in[0] << 16;
if (rest > 1)
t |= (uint32_t)in[1] << 8;
*out++ = B64_BYTE(t >> 18);
*out++ = B64_BYTE(t >> 12);
*out++ = rest > 1? B64_BYTE(t >> 6): '=';
*out++ = '=';
rest = 0;
}
else
memmove(buf, in, rest);
}
if (end && col && zout->avail_out != 0)
*out++ = '\n';
assert(out <= &base64[size]);
if ((size = out - &base64[0]) > 0)
{
dom->total_out += size;
if (dom->addr[0].limit < dom->total_out &&
dom->child && dom->child_killed == 0)
{
if (dom->zag->z.verbose >= 1)
(*do_log)(LOG_ERR,
"limit %" PRIu64 " exceeded for %s, killing pipe",
dom->addr[0].limit, dom->domain);
if (kill(-dom->child, SIGTERM)) // process group
(*do_log)(LOG_ERR, "cannot kill pipe: %s",
strerror(errno));
else
dom->child_killed = 1;
return DEAD_CHILD;
}
if (fwrite(base64, size, 1, dom->out) != 1 || ferror(dom->out))
return flush_common(dom, NULL, end);
}
}
static void
array_tests(void)
{
int m[2][3][4] =
{
{{1, 2, 3, 4}, {-1, -3, -5, -7}, {0, 2, 4, 6}},
{{1, -2, 3, -4}, {2, 3, 5, 7}, {-4, -1, -14, 4114}}
};
int c[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
int c2[] = {10, 100, 200};
int c3[20];
vector_t vs[2] = {{1, -2, 3}, {4, -5, -6}};
cps_t cps;
cpsc_t cpsc;
cs_t *cs;
int n;
int ca[5] = {1, -2, 3, -4, 5};
doub_carr_t *dc;
int *pi;
pints_t api[5];
numbers_struct_t *ns;
refpint_t rpi[5];
if (!old_windows_version)
{
const char str1[25] = "Hello";
ok(cstr_length(str1, sizeof str1) == strlen(str1), "RPC cstr_length\n");
}
ok(sum_fixed_int_3d(m) == 4116, "RPC sum_fixed_int_3d\n");
ok(sum_conf_array(c, 10) == 45, "RPC sum_conf_array\n");
ok(sum_conf_array(&c[5], 2) == 11, "RPC sum_conf_array\n");
ok(sum_conf_array(&c[7], 1) == 7, "RPC sum_conf_array\n");
ok(sum_conf_array(&c[2], 0) == 0, "RPC sum_conf_array\n");
ok(sum_conf_ptr_by_conf_ptr(1, c2, c) == 45, "RPC sum_conf_ptr_by_conf_ptr\n");
ok(sum_conf_ptr_by_conf_ptr(3, c2, c) == 345, "RPC sum_conf_ptr_by_conf_ptr\n");
c2[0] = 0;
ok(sum_conf_ptr_by_conf_ptr(3, c2, c) == 300, "RPC sum_conf_ptr_by_conf_ptr\n");
ok(sum_unique_conf_array(ca, 4) == -2, "RPC sum_unique_conf_array\n");
ok(sum_unique_conf_ptr(ca, 5) == 3, "RPC sum_unique_conf_array\n");
ok(sum_unique_conf_ptr(NULL, 10) == 0, "RPC sum_unique_conf_array\n");
get_number_array(c3, &n);
ok(n == 10, "RPC get_num_array\n");
for (; n > 0; n--)
ok(c3[n-1] == c[n-1], "get_num_array returned wrong value %d @ %d\n",
c3[n-1], n);
ok(sum_var_array(c, 10) == 45, "RPC sum_conf_array\n");
ok(sum_var_array(&c[5], 2) == 11, "RPC sum_conf_array\n");
ok(sum_var_array(&c[7], 1) == 7, "RPC sum_conf_array\n");
ok(sum_var_array(&c[2], 0) == 0, "RPC sum_conf_array\n");
ok(dot_two_vectors(vs) == -4, "RPC dot_two_vectors\n");
cs = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(cs_t, ca[5]));
cs->n = 5;
cs->ca[0] = 3;
cs->ca[1] = 5;
cs->ca[2] = -2;
cs->ca[3] = -1;
cs->ca[4] = -4;
ok(sum_cs(cs) == 1, "RPC sum_cs\n");
HeapFree(GetProcessHeap(), 0, cs);
n = 5;
cps.pn = &n;
cps.ca1 = &c[2];
cps.n = 3;
cps.ca2 = &c[3];
ok(sum_cps(&cps) == 53, "RPC sum_cps\n");
cpsc.a = 4;
cpsc.b = 5;
cpsc.c = 1;
cpsc.ca = c;
ok(sum_cpsc(&cpsc) == 6, "RPC sum_cpsc\n");
cpsc.a = 4;
cpsc.b = 5;
cpsc.c = 0;
cpsc.ca = c;
ok(sum_cpsc(&cpsc) == 10, "RPC sum_cpsc\n");
ok(sum_toplev_conf_2n(c, 3) == 15, "RPC sum_toplev_conf_2n\n");
ok(sum_toplev_conf_cond(c, 5, 6, 1) == 10, "RPC sum_toplev_conf_cond\n");
ok(sum_toplev_conf_cond(c, 5, 6, 0) == 15, "RPC sum_toplev_conf_cond\n");
dc = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(doub_carr_t, a[2]));
dc->n = 2;
dc->a[0] = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(doub_carr_1_t, a[3]));
dc->a[0]->n = 3;
dc->a[0]->a[0] = 5;
dc->a[0]->a[1] = 1;
dc->a[0]->a[2] = 8;
dc->a[1] = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(doub_carr_1_t, a[2]));
dc->a[1]->n = 2;
dc->a[1]->a[0] = 2;
dc->a[1]->a[1] = 3;
ok(sum_doub_carr(dc) == 19, "RPC sum_doub_carr\n");
HeapFree(GetProcessHeap(), 0, dc->a[0]);
HeapFree(GetProcessHeap(), 0, dc->a[1]);
HeapFree(GetProcessHeap(), 0, dc);
dc = NULL;
make_pyramid_doub_carr(4, &dc);
ok(check_pyramid_doub_carr(dc), "RPC make_pyramid_doub_carr\n");
free_pyramid_doub_carr(dc);
ok(sum_L1_norms(2, vs) == 21, "RPC sum_L1_norms\n");
memset(api, 0, sizeof(api));
pi = HeapAlloc(GetProcessHeap(), 0, sizeof(*pi));
*pi = -1;
api[0].pi = pi;
get_numbers(1, 1, api);
ok(api[0].pi == pi, "RPC conformant varying array [out] pointer changed from %p to %p\n", pi, api[0].pi);
ok(*api[0].pi == 0, "pi unmarshalled incorrectly %d\n", *api[0].pi);
if (!old_windows_version)
{
ns = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, FIELD_OFFSET(numbers_struct_t, numbers[5]));
ns->length = 5;
ns->size = 5;
ns->numbers[0].pi = pi;
get_numbers_struct(&ns);
ok(ns->numbers[0].pi == pi, "RPC conformant varying struct embedded pointer changed from %p to %p\n", pi, ns->numbers[0].pi);
ok(*ns->numbers[0].pi == 5, "pi unmarshalled incorrectly %d\n", *ns->numbers[0].pi);
HeapFree(GetProcessHeap(), 0, ns);
}
HeapFree(GetProcessHeap(), 0, pi);
pi = HeapAlloc(GetProcessHeap(), 0, 5 * sizeof(*pi));
pi[0] = 3; rpi[0] = &pi[0];
pi[1] = 5; rpi[1] = &pi[1];
pi[2] = -2; rpi[2] = &pi[2];
pi[3] = -1; rpi[3] = &pi[3];
pi[4] = -4; rpi[4] = &pi[4];
ok(sum_complex_array(5, rpi) == 1, "RPC sum_complex_array\n");
HeapFree(GetProcessHeap(), 0, pi);
}
