void ex_com()
{
struct item* q;
fetch2();
q = sp[-2];
comk(q->rank - 1);
}
void ex_comk()
{
int k;
k = topfix() - iorigin;
fetch2();
comk(k);
}
ex_dtrn()
{
struct item *p, *q;
int i;
p = fetch2();
q = sp[-2];
if(p->rank > 1 || p->size != q->rank) error("tranpose C");
for(i=0; i<p->size; i++) idx.idx[i] = fix(getdat(p)) - thread.iorg;
pop();
trn0();
}
TEST_F(CachingCorrectnessTest, PostToSameURLTwice)
{
ResourceRequest request1(KURL(ParsedURLString, kResourceURL));
request1.setHTTPMethod(HTTPNames::POST);
ResourcePtr<Resource> resource1 = new Resource(ResourceRequest(request1.url()), Resource::Raw);
resource1->setLoading(true);
memoryCache()->add(resource1.get());
ResourceRequest request2(KURL(ParsedURLString, kResourceURL));
request2.setHTTPMethod(HTTPNames::POST);
FetchRequest fetch2(request2, FetchInitiatorInfo());
ResourcePtr<Resource> resource2 = RawResource::fetchSynchronously(fetch2, fetcher());
EXPECT_EQ(resource2, memoryCache()->resourceForURL(request2.url()));
EXPECT_NE(resource1, resource2);
}
void ex_ddom()
{
struct item *p, *q;
int a, b, m, n, o, *in;
data *d1, *dmn, *dn1, *dn2, *dn3, *dm;
char* al;
p = fetch2();
q = sp[-2];
if (p->itemType != DA || q->itemType != DA)
error(ERR_domain, "domino - incorrect types");
if ((p->rank != 1 && p->rank != 2) || q->rank != 2)
error(ERR_rank, "domino - unexpected ranks");
m = q->dim[0];
n = q->dim[1];
if (m < n || m != p->dim[0])
error(ERR_rank, "domino - mismatch");
o = 1;
if (p->rank == 2)
o = p->dim[1];
al = (char*)alloc(n * (SINT + SDAT * m + SDAT * 3) + SDAT * m);
if (al == 0)
error(ERR, "domino - unable to allocate memory");
dmn = (data*)al;
dn1 = dmn + m * n;
dn2 = dn1 + n;
dn3 = dn2 + n;
dm = dn3 + n;
in = (int*)(dm + m);
d1 = q->datap;
for (b = 0; b < m; b++) {
for (a = 0; a < n; a++)
dmn[a * m + b] = *d1++;
}
a = lsq(dmn, dn1, dn2, dn3, dm, in, m, n, o, p->datap, q->datap);
aplfree((int*)dmn);
if (a)
error(ERR, "domino - could not solve");
sp--;
pop();
*sp++ = p;
p->dim[0] = n;
p->size = n * o;
}
ex_drho()
{
struct item *p, *q, *r;
int s, i;
data *dp;
char *cp;
p = fetch2();
q = sp[-2];
if(p->type != DA || p->rank > 1 || q->size < 0) error("rho C");
/* Allow null vector to be reshaped if one of the
* dimensions is null.
*/
if (!q->size) {
dp = p->datap;
for(i=0; i < p->size; i++) if (fix(*dp++) == 0) goto null_ok;
error("rho C");
}
null_ok:
s = 1;
dp = p->datap;
for(i=0; i<p->size; i++) {
if (*dp < 0) error("rho C"); /* Negative dimensions illegal */
s *= fix(*dp++);
}
r = newdat(q->type, p->size, s);
dp = p->datap;
for(i=0; i<p->size; i++) r->dim[i] = fix(*dp++);
cp = (char *)r->datap;
while(s > 0) {
i = s;
if(i > q->size) i = q->size;
cp += copy(q->type, q->datap, cp, i);
s -= i;
}
pop();
pop();
*sp++ = r;
}
static struct isakmp_payload *parse_isakmp_payload(uint8_t type,
const uint8_t ** data_p, size_t * data_len_p, int * reject, enum isakmp_ipsec_proto_enum decode_proto)
{
const uint8_t *data = *data_p, *tmpdata;
size_t data_len = *data_len_p;
struct isakmp_payload *r;
uint8_t next_type;
size_t length, olength;
static const uint16_t min_payload_len[ISAKMP_PAYLOAD_MODECFG_ATTR + 1] = {
4, 12, 8, 8, 4, 8, 5, 5, 4, 4, 4, 12, 12, 4, 8
};
hex_dump("PARSING PAYLOAD type", &type, DUMP_UINT8, isakmp_payload_enum_array);
if (type == 0)
return NULL;
if (type <= ISAKMP_PAYLOAD_MODECFG_ATTR) {
if (data_len < min_payload_len[type]) {
*reject = ISAKMP_N_PAYLOAD_MALFORMED;
return NULL;
}
} else if (data_len < 4) {
*reject = ISAKMP_N_PAYLOAD_MALFORMED;
return NULL;
}
r = new_isakmp_payload(type);
next_type = fetch1();
hex_dump("next_type", &next_type, DUMP_UINT8, isakmp_payload_enum_array);
if (fetch1() != 0) {
*reject = ISAKMP_N_PAYLOAD_MALFORMED;
return r;
}
length = fetch2();
hex_dump("length", &length, DUMP_UINT16, NULL);
if (length > data_len + 4
|| ((type <= ISAKMP_PAYLOAD_MODECFG_ATTR)&&(length < min_payload_len[type]))
|| (length < 4)) {
*reject = ISAKMP_N_PAYLOAD_MALFORMED;
return r;
}
olength = length;
switch (type) {
case ISAKMP_PAYLOAD_SA:
r->u.sa.doi = fetch4();
hex_dump("sa.doi", &r->u.sa.doi, DUMP_UINT32, isakmp_doi_enum_array);
if (r->u.sa.doi != ISAKMP_DOI_IPSEC) {
*reject = ISAKMP_N_DOI_NOT_SUPPORTED;
return r;
}
r->u.sa.situation = fetch4();
hex_dump("sa.situation", &r->u.sa.situation, DUMP_UINT32, isakmp_ipsec_sit_enum_array);
if (r->u.sa.situation != ISAKMP_IPSEC_SIT_IDENTITY_ONLY) {
*reject = ISAKMP_N_SITUATION_NOT_SUPPORTED;
return r;
}
*reject = 0;
length -= 12;
r->u.sa.proposals = parse_isakmp_payload(ISAKMP_PAYLOAD_P, &data, &length, reject, decode_proto);
if (*reject != 0)
return r;
/* Allow trailing garbage at end of payload. */
data_len -= olength - 12;
break;
case ISAKMP_PAYLOAD_P:
if (next_type != ISAKMP_PAYLOAD_P && next_type != 0) {
*reject = ISAKMP_N_INVALID_PAYLOAD_TYPE;
return r;
}
{
uint8_t num_xform;
struct isakmp_payload *xform;
r->u.p.number = fetch1();
hex_dump("p.number", &r->u.p.number, DUMP_UINT8, NULL);
r->u.p.prot_id = fetch1();
hex_dump("p.prot_id", &r->u.p.prot_id, DUMP_UINT8, isakmp_ipsec_proto_enum_array);
r->u.p.spi_size = fetch1();
hex_dump("p.spi_size", &r->u.p.spi_size, DUMP_UINT8, NULL);
num_xform = fetch1();
hex_dump("length", &num_xform, DUMP_UINT8, NULL);
if (data_len < r->u.p.spi_size) {
*reject = ISAKMP_N_PAYLOAD_MALFORMED;
return r;
}
r->u.p.spi = xallocc(r->u.p.spi_size);
fetchn(r->u.p.spi, r->u.p.spi_size);
hex_dump("p.spi", r->u.p.spi, r->u.p.spi_size, NULL);
length -= 8 + r->u.p.spi_size;
r->u.p.transforms = parse_isakmp_payload(ISAKMP_PAYLOAD_T,
&data, &length, reject, r->u.p.prot_id);
for (xform = r->u.p.transforms; xform; xform = xform->next)
if (num_xform-- == 0)
break;
if (num_xform != 0) {
*reject = ISAKMP_N_BAD_PROPOSAL_SYNTAX;
return r;
}
/* Allow trailing garbage at end of payload. */
data_len -= olength - 8 - r->u.p.spi_size;
}
break;
case ISAKMP_PAYLOAD_T:
if (next_type != ISAKMP_PAYLOAD_T && next_type != 0) {
*reject = ISAKMP_N_INVALID_PAYLOAD_TYPE;
return r;
}
r->u.t.number = fetch1();
hex_dump("t.number", &r->u.t.number, DUMP_UINT8, NULL);
r->u.t.id = fetch1();
hex_dump("t.id", &r->u.t.id, DUMP_UINT8, transform_id_to_debug_strings(decode_proto));
if (fetch2() != 0) {
*reject = ISAKMP_N_BAD_PROPOSAL_SYNTAX;
return r;
}
length -= 8;
r->u.t.attributes = parse_isakmp_attributes(&data, length, reject, decode_proto);
data_len -= olength - 8;
break;
case ISAKMP_PAYLOAD_KE:
case ISAKMP_PAYLOAD_HASH:
case ISAKMP_PAYLOAD_SIG:
case ISAKMP_PAYLOAD_NONCE:
case ISAKMP_PAYLOAD_VID:
case ISAKMP_PAYLOAD_NAT_D:
case ISAKMP_PAYLOAD_NAT_D_OLD:
r->u.ke.length = length - 4;
r->u.ke.data = xallocc(r->u.ke.length);
fetchn(r->u.ke.data, r->u.ke.length);
hex_dump("ke.data", r->u.ke.data, r->u.ke.length, NULL);
break;
case ISAKMP_PAYLOAD_ID:
r->u.id.type = fetch1();
hex_dump("id.type", &r->u.id.type, DUMP_UINT8, isakmp_ipsec_id_enum_array);
r->u.id.protocol = fetch1();
hex_dump("id.protocol", &r->u.id.protocol, DUMP_UINT8, NULL); /* IP protocol nr */
r->u.id.port = fetch2();
hex_dump("id.port", &r->u.id.port, sizeof(r->u.id.port), NULL);
r->u.id.length = length - 8;
r->u.id.data = xallocc(r->u.id.length);
fetchn(r->u.id.data, r->u.id.length);
hex_dump("id.data", r->u.id.data, r->u.id.length, NULL);
break;
case ISAKMP_PAYLOAD_CERT:
case ISAKMP_PAYLOAD_CR:
r->u.cert.encoding = fetch1();
hex_dump("cert.encoding", &r->u.cert.encoding, DUMP_UINT8, NULL);
r->u.cert.length = length - 5;
fetchn(r->u.cert.data, r->u.cert.length);
hex_dump("cert.data", r->u.cert.data, r->u.cert.length, NULL);
break;
case ISAKMP_PAYLOAD_N:
r->u.n.doi = fetch4();
hex_dump("n.doi", &r->u.n.doi, DUMP_UINT32, isakmp_doi_enum_array);
r->u.n.protocol = fetch1();
hex_dump("n.protocol", &r->u.n.protocol, DUMP_UINT8, isakmp_ipsec_proto_enum_array);
r->u.n.spi_length = fetch1();
hex_dump("n.spi_length", &r->u.n.spi_length, DUMP_UINT8, NULL);
r->u.n.type = fetch2();
hex_dump("n.type", &r->u.n.type, DUMP_UINT16, isakmp_notify_enum_array);
if (r->u.n.spi_length + 12u > length) {
*reject = ISAKMP_N_PAYLOAD_MALFORMED;
return r;
}
r->u.n.spi = xallocc(r->u.n.spi_length);
fetchn(r->u.n.spi, r->u.n.spi_length);
hex_dump("n.spi", r->u.n.spi, r->u.n.spi_length, NULL);
r->u.n.data_length = length - 12 - r->u.n.spi_length;
r->u.n.data = xallocc(r->u.n.data_length);
fetchn(r->u.n.data, r->u.n.data_length);
hex_dump("n.data", r->u.n.data, r->u.n.data_length, NULL);
if ((r->u.n.doi == ISAKMP_DOI_IPSEC)&&(r->u.n.type == ISAKMP_N_IPSEC_RESPONDER_LIFETIME)) {
tmpdata = r->u.n.data;
r->u.n.attributes = parse_isakmp_attributes(&tmpdata, r->u.n.data_length, reject,
r->u.n.protocol);
}
break;
case ISAKMP_PAYLOAD_D:
r->u.d.doi = fetch4();
hex_dump("d.doi", &r->u.d.doi, DUMP_UINT32, isakmp_doi_enum_array);
r->u.d.protocol = fetch1();
hex_dump("d.protocol", &r->u.d.protocol, DUMP_UINT8, isakmp_ipsec_proto_enum_array);
r->u.d.spi_length = fetch1();
hex_dump("d.spi_length", &r->u.d.spi_length, DUMP_UINT8, NULL);
r->u.d.num_spi = fetch2();
hex_dump("d.num_spi", &r->u.d.num_spi, DUMP_UINT16, NULL);
if (r->u.d.num_spi * r->u.d.spi_length + 12u != length) {
*reject = ISAKMP_N_PAYLOAD_MALFORMED;
return r;
}
r->u.d.spi = xallocc(sizeof(uint8_t *) * r->u.d.num_spi);
{
int i;
for (i = 0; i < r->u.d.num_spi; i++) {
r->u.d.spi[i] = xallocc(r->u.d.spi_length);
fetchn(r->u.d.spi[i], r->u.d.spi_length);
hex_dump("d.spi", r->u.d.spi[i], r->u.d.spi_length, NULL);
}
}
break;
case ISAKMP_PAYLOAD_MODECFG_ATTR:
r->u.modecfg.type = fetch1();
hex_dump("modecfg.type", &r->u.modecfg.type, DUMP_UINT8, isakmp_modecfg_cfg_enum_array);
if (fetch1() != 0) {
*reject = ISAKMP_N_PAYLOAD_MALFORMED;
return r;
}
r->u.modecfg.id = fetch2();
hex_dump("modecfg.id", &r->u.modecfg.id, DUMP_UINT16, NULL);
length -= 8;
r->u.modecfg.attributes = parse_isakmp_attributes(&data, length, reject,
ISAKMP_IPSEC_PROTO_MODECFG); /* this "proto" is a hack for simplicity */
data_len -= olength - 8;
break;
default:
r->u.ke.length = length - 4;
r->u.ke.data = xallocc(r->u.ke.length);
fetchn(r->u.ke.data, r->u.ke.length);
hex_dump("UNKNOWN.data", r->u.ke.data, r->u.ke.length, NULL);
break;
}
*data_p = data;
*data_len_p = data_len;
hex_dump("DONE PARSING PAYLOAD type", &type, DUMP_UINT8, isakmp_payload_enum_array);
r->next = parse_isakmp_payload(next_type, data_p, data_len_p, reject, decode_proto);
return r;
}
static struct isakmp_attribute *parse_isakmp_attributes(const uint8_t ** data_p,
size_t data_len, int * reject, enum isakmp_ipsec_proto_enum decode_proto)
{
const uint8_t *data = *data_p;
struct isakmp_attribute *r;
uint16_t type, length;
int i;
if (data_len < 4)
return NULL;
r = new_isakmp_attribute(0, NULL);
type = fetch2();
length = fetch2();
if (type & 0x8000) {
r->type = type & ~0x8000;
hex_dump("t.attributes.type", &r->type, DUMP_UINT16, attr_type_to_debug_strings(decode_proto));
r->af = isakmp_attr_16;
r->u.attr_16 = length;
if ((ISAKMP_XAUTH_ATTRIB_TYPE <= r->type)
&& (r->type <= ISAKMP_XAUTH_ATTRIB_ANSWER)
&& (opt_debug < 99))
DEBUG(3, printf("(not dumping xauth data)\n"));
else
hex_dump("t.attributes.u.attr_16", &r->u.attr_16, DUMP_UINT16,
attr_val_to_debug_strings(decode_proto, r->type));
} else {
r->type = type;
hex_dump("t.attributes.type", &r->type, DUMP_UINT16, attr_type_to_debug_strings(decode_proto));
r->af = isakmp_attr_lots;
r->u.lots.length = length;
if ((ISAKMP_XAUTH_ATTRIB_TYPE <= r->type) && (r->type <= ISAKMP_XAUTH_ATTRIB_ANSWER)
&& (opt_debug < 99))
DEBUG(3, printf("(not dumping xauth data length)\n"));
else
hex_dump("t.attributes.u.lots.length", &r->u.lots.length, DUMP_UINT16, NULL);
if (data_len < length) {
*reject = ISAKMP_N_PAYLOAD_MALFORMED;
return r;
}
if (r->type == ISAKMP_MODECFG_ATTRIB_CISCO_SPLIT_INC) {
r->af = isakmp_attr_acl;
r->u.acl.count = length / (4+4+2+2+2);
if (r->u.acl.count * (4+4+2+2+2) != length) {
*reject = ISAKMP_N_PAYLOAD_MALFORMED;
return r;
}
r->u.acl.acl_ent = xallocc(r->u.acl.count * sizeof(struct acl_ent_s));
for (i = 0; i < r->u.acl.count; i++) {
fetchn(&r->u.acl.acl_ent[i].addr.s_addr, 4);
fetchn(&r->u.acl.acl_ent[i].mask.s_addr, 4);
r->u.acl.acl_ent[i].protocol = fetch2();
r->u.acl.acl_ent[i].sport = fetch2();
r->u.acl.acl_ent[i].dport = fetch2();
hex_dump("t.attributes.u.acl.addr", &r->u.acl.acl_ent[i].addr.s_addr, 4, NULL);
hex_dump("t.attributes.u.acl.mask", &r->u.acl.acl_ent[i].mask.s_addr, 4, NULL);
hex_dump("t.attributes.u.acl.protocol", &r->u.acl.acl_ent[i].protocol, DUMP_UINT16, NULL);
hex_dump("t.attributes.u.acl.sport", &r->u.acl.acl_ent[i].sport, DUMP_UINT16, NULL);
hex_dump("t.attributes.u.acl.dport", &r->u.acl.acl_ent[i].dport, DUMP_UINT16, NULL);
}
} else {
r->u.lots.data = xallocc(length);
fetchn(r->u.lots.data, length);
if ((ISAKMP_XAUTH_ATTRIB_TYPE <= type) && (type <= ISAKMP_XAUTH_ATTRIB_ANSWER)
&& (opt_debug < 99))
DEBUG(3, printf("(not dumping xauth data)\n"));
else
hex_dump("t.attributes.u.lots.data", r->u.lots.data, r->u.lots.length, NULL);
}
}
r->next = parse_isakmp_attributes(&data, data_len, reject, decode_proto);
*data_p = data;
return r;
}
void ex_com0()
{
fetch2();
comk(0);
}
