/**
* perform SIP message sanity check
* @param _msg - SIP message structure
* @param msg_checks - bitmask of sanity tests to perform over message
* @param uri_checks - bitmask of sanity tests to perform over uri
* @return -1 on error, 0 on tests failure, 1 on success
*/
int sanity_check(struct sip_msg* _msg, int msg_checks, int uri_checks)
{
int ret;
ret = SANITY_CHECK_PASSED;
if (SANITY_RURI_SIP_VERSION & msg_checks &&
(ret = check_ruri_sip_version(_msg)) != SANITY_CHECK_PASSED) {
goto done;
}
if (SANITY_RURI_SCHEME & msg_checks &&
(ret = check_ruri_scheme(_msg)) != SANITY_CHECK_PASSED) {
goto done;
}
if (SANITY_REQUIRED_HEADERS & msg_checks &&
(ret = check_required_headers(_msg)) != SANITY_CHECK_PASSED) {
goto done;
}
if (SANITY_VIA_SIP_VERSION & msg_checks &&
(ret = check_via_sip_version(_msg)) != SANITY_CHECK_PASSED) {
goto done;
}
if (SANITY_VIA_PROTOCOL & msg_checks &&
(ret = check_via_protocol(_msg)) != SANITY_CHECK_PASSED) {
goto done;
}
if (SANITY_CSEQ_METHOD & msg_checks &&
(ret = check_cseq_method(_msg)) != SANITY_CHECK_PASSED) {
goto done;
}
if (SANITY_CSEQ_VALUE & msg_checks &&
(ret = check_cseq_value(_msg)) != SANITY_CHECK_PASSED) {
goto done;
}
if (SANITY_CL & msg_checks &&
(ret = check_cl(_msg)) != SANITY_CHECK_PASSED) {
goto done;
}
if (SANITY_EXPIRES_VALUE & msg_checks &&
(ret = check_expires_value(_msg)) != SANITY_CHECK_PASSED) {
goto done;
}
if (SANITY_PROXY_REQUIRE & msg_checks &&
(ret = check_proxy_require(_msg)) != SANITY_CHECK_PASSED) {
goto done;
}
if (SANITY_PARSE_URIS & msg_checks &&
(ret = check_parse_uris(_msg, uri_checks)) != SANITY_CHECK_PASSED) {
goto done;
}
if (SANITY_CHECK_DIGEST & msg_checks &&
(ret = check_digest(_msg, uri_checks)) != SANITY_CHECK_PASSED) {
goto done;
}
done:
return ret;
}
void captureOctTree(Point3f camera, Point3f target, Point3f up, int width, int height, float *data)
{
//normalize vectors
target = vectNormalize(target);
up = vectNormalize(up);
Point3f right = vectNormalize(vectMul(target, up));
Point3f relative_up = vectNormalize(vectMul(right, camera_target));
target = vectDiv(target, tanf(AOV / 2.f));
Point3f bottom_left_vec = vectSum(target, vectDiv(relative_up, -2), vectDiv(right, -2));
Point3f dright = vectDiv(right, (float)width);
Point3f dup = vectDiv(relative_up, (float)height);
cl_int status;
status = clEnqueueAcquireGLObjects(queue, 1, &image, 0, NULL, NULL);
check_cl(status, "enqueue gl");
// find the camera
Point3f origin = camera;
OctTreeNode *tree = mainOctTree;
int dx, dy, dz;
float radius = 1.f;
Point3f center = (Point3f) { 0.f, 0.f, 0.f };
Point3f local = vectMulScalar(origin, center, -1);
cl_int offset = 0;
while (tree->type >= 0) {
dx = local.x > 0;
dy = local.y > 0;
dz = local.z > 0;
offset = tree->nodes[dx][dy][dz];
tree = mainOctTree + offset;
radius /= 2.f;
center = (Point3f) {
center.x + (2 * dx - 1) * radius,
center.y + (2 * dy - 1) * radius,
center.z + (2 * dz - 1) * radius
};
local = vectMulScalar(origin, center, -1);
}
Point3f camera111 = vectMulScalar(origin, (Point3f) { 1.f, 1.f, 1.f }, 1.f);
Point3f light111 = vectMulScalar(light, (Point3f) { 1.f, 1.f, 1.f }, 1.f);
// cl_float3 is bigger than Point3f but we're only passing stack-allocated stuff, so reading garbage is safe
status = clSetKernelArg(kernel, 0, sizeof(cl_float3), &camera111);
check_cl(status, "set arg 0");
status = clSetKernelArg(kernel, 1, sizeof(cl_float3), &light111);
check_cl(status, "set arg 1");
status = clSetKernelArg(kernel, 2, sizeof(cl_float3), &bottom_left_vec);
check_cl(status, "set arg 2");
status = clSetKernelArg(kernel, 3, sizeof(cl_float3), &dup);
check_cl(status, "set arg 3");
status = clSetKernelArg(kernel, 4, sizeof(cl_float3), &dright);
check_cl(status, "set arg 4");
status = clSetKernelArg(kernel, 5, sizeof(cl_mem), &mainOctCL);
check_cl(status, "set arg 5");
status = clSetKernelArg(kernel, 6, sizeof(cl_mem), &image);
check_cl(status, "set arg 6");
status = clSetKernelArg(kernel, 7, sizeof(cl_int), &offset);
check_cl(status, "set arg 7");
// run kernel
size_t global_work_size[] = {width, height};
size_t local_work_size[] = {8, 8};
status = clEnqueueNDRangeKernel(queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
check_cl(status, "enqueue kernel");
status = clEnqueueReleaseGLObjects(queue, 1, &image, 0, NULL, NULL);
check_cl(status, "release gl");
status = clFinish(queue);
check_cl(status, "finish");
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClear(GL_COLOR_BUFFER_BIT);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, texture);
glBegin(GL_QUADS);
glTexCoord2i(0, 1);
glVertex2f(-1, 1.0f);
glTexCoord2i(1, 1);
glVertex2f(1.0f, 1.0f);
glTexCoord2i(1, 0);
glVertex2f(1.0f, -1.f);
glTexCoord2i(0, 0);
glVertex2f(-1, -1.f);
glEnd();
glDisable(GL_TEXTURE_2D);
glFinish();
}
static int sanity_check(struct sip_msg* _msg, char* _number, char* _arg) {
int ret, check, arg;
if (_number == NULL) {
check = default_checks;
}
else {
check = (int)(long)_number;
}
if (_arg == NULL) {
arg = uri_checks;
}
else {
arg = (int)(long)_arg;
}
if (SANITY_RURI_SIP_VERSION & check &&
(ret = check_ruri_sip_version(_msg)) != SANITY_CHECK_PASSED) {
return ret;
}
if (SANITY_RURI_SCHEME & check &&
(ret = check_ruri_scheme(_msg)) != SANITY_CHECK_PASSED) {
return ret;
}
if (SANITY_REQUIRED_HEADERS & check &&
(ret = check_required_headers(_msg)) != SANITY_CHECK_PASSED) {
return ret;
}
if (SANITY_VIA_SIP_VERSION & check &&
(ret = check_via_sip_version(_msg)) != SANITY_CHECK_PASSED) {
return ret;
}
if (SANITY_VIA_PROTOCOL & check &&
(ret = check_via_protocol(_msg)) != SANITY_CHECK_PASSED) {
return ret;
}
if (SANITY_CSEQ_METHOD & check &&
(ret = check_cseq_method(_msg)) != SANITY_CHECK_PASSED) {
return ret;
}
if (SANITY_CSEQ_VALUE & check &&
(ret = check_cseq_value(_msg)) != SANITY_CHECK_PASSED) {
return ret;
}
if (SANITY_CL & check &&
(ret = check_cl(_msg)) != SANITY_CHECK_PASSED) {
return ret;
}
if (SANITY_EXPIRES_VALUE & check &&
(ret = check_expires_value(_msg)) != SANITY_CHECK_PASSED) {
return ret;
}
if (SANITY_PROXY_REQUIRE & check &&
(ret = check_proxy_require(_msg)) != SANITY_CHECK_PASSED) {
return ret;
}
if (SANITY_PARSE_URIS & check &&
(ret = check_parse_uris(_msg, arg)) != SANITY_CHECK_PASSED) {
return ret;
}
if (SANITY_CHECK_DIGEST & check &&
(ret = check_digest(_msg, arg)) != SANITY_CHECK_PASSED) {
return ret;
}
DBG("all sanity checks passed\n");
/* nobody complained so everything is fine */
return 1;
}
static void check(const struct sdparm_mode_page_item * mpi,
const struct sdparm_mode_page_item * mpi_b)
{
unsigned char mask;
const struct sdparm_mode_page_item * kp = mpi;
const struct sdparm_mode_page_item * jp = mpi;
const char * acron;
int res, prev_mp, prev_msp, prev_pdt, sbyte, sbit, nbits;
int second_k = 0;
int second_j = 0;
clear_cl();
for (prev_mp = 0, prev_msp = 0, prev_pdt = -1; ; ++kp) {
if (NULL == kp->acron) {
if ((NULL == mpi_b) || second_k)
break;
prev_mp = 0;
prev_msp = 0;
kp = mpi_b;
second_k = 1;
}
acron = kp->acron ? kp->acron : "?";
if ((prev_mp != kp->page_num) || (prev_msp != kp->subpage_num)) {
if (prev_mp > kp->page_num)
printf(" mode page 0x%x,0x%x out of order\n", kp->page_num,
kp->subpage_num);
if ((prev_mp == kp->page_num) && (prev_msp > kp->subpage_num))
printf(" mode subpage 0x%x,0x%x out of order, previous msp "
"was 0x%x\n", kp->page_num, kp->subpage_num, prev_msp);
prev_mp = kp->page_num;
prev_msp = kp->subpage_num;
prev_pdt = kp->pdt;
clear_cl();
} else if ((prev_pdt >= 0) && (prev_pdt != kp->pdt)) {
if (prev_pdt > kp->pdt)
printf(" mode page 0x%x,0x%x pdt out of order, pdt was "
"%d, now %d\n", kp->page_num, kp->subpage_num,
prev_pdt, kp->pdt);
prev_pdt = kp->pdt;
}
for (jp = kp + 1, second_j = second_k; ; ++jp) {
if (NULL == jp->acron) {
if ((NULL == mpi_b) || second_j)
break;
jp = mpi_b;
second_j = 1;
}
if ((0 == strcmp(acron, jp->acron)) &&
(! (jp->flags & MF_CLASH_OK)))
printf(" acronym '%s' with this description: '%s'\n "
"clashes with '%s'\n", acron, kp->description,
jp->description);
}
sbyte = kp->start_byte;
if ((unsigned)sbyte + 8 > MAX_MP_LEN) {
printf(" acronym: %s start byte too large: %d\n", kp->acron,
sbyte);
continue;
}
sbit = kp->start_bit;
if ((unsigned)sbit > 7) {
printf(" acronym: %s start bit too large: %d\n", kp->acron,
sbit);
continue;
}
nbits = kp->num_bits;
if (nbits > 64) {
printf(" acronym: %s number of bits too large: %d\n",
kp->acron, nbits);
continue;
}
if (nbits < 1) {
printf(" acronym: %s number of bits too small: %d\n",
kp->acron, nbits);
continue;
}
mask = (1 << (sbit + 1)) - 1;
if ((nbits - 1) < sbit)
mask &= ~((1 << (sbit + 1 - nbits)) - 1);
res = check_cl(sbyte, kp->pdt, mask);
if (res) {
if (1 == res)
printf(" 0x%x,0x%x: clash at start_byte: %d, bit: %d "
"[latest acron: %s, this pdt]\n", prev_mp, prev_msp,
sbyte, sbit, acron);
else if (2 == res)
printf(" 0x%x,0x%x: clash at start_byte: %d, bit: %d "
"[latest acron: %s, another pdt]\n", prev_mp,
prev_msp, sbyte, sbit, acron);
else
printf(" 0x%x,0x%x: clash, bad data at start_byte: %d, "
"bit: %d [latest acron: %s]\n", prev_mp,
prev_msp, sbyte, sbit, acron);
}
set_cl(sbyte, kp->pdt, mask);
if ((nbits - 1) > sbit) {
nbits -= (sbit + 1);
if ((nbits > 7) && (0 != (nbits % 8)))
printf(" 0x%x,0x%x: check nbits: %d, start_byte: %d, bit: "
"%d [acron: %s]\n", prev_mp, prev_msp, kp->num_bits,
sbyte, sbit, acron);
do {
++sbyte;
mask = 0xff;
if (nbits > 7)
nbits -= 8;
else {
mask &= ~((1 << (8 - nbits)) - 1);
nbits = 0;
}
res = check_cl(sbyte, kp->pdt, mask);
if (res) {
if (1 == res)
printf(" 0x%x,0x%x: clash at start_byte: %d, "
"bit: %d [latest acron: %s, this pdt]\n",
prev_mp, prev_msp, sbyte, sbit, acron);
else if (2 == res)
printf(" 0x%x,0x%x: clash at start_byte: %d, "
"bit: %d [latest acron: %s, another pdt]\n",
prev_mp, prev_msp, sbyte, sbit, acron);
else
printf(" 0x%x,0x%x: clash, bad at start_byte: "
"%d, bit: %d [latest acron: %s]\n",
prev_mp, prev_msp, sbyte, sbit, acron);
}
set_cl(sbyte, kp->pdt, mask);
} while (nbits > 0);
}
}
}
/**
* perform SIP message sanity check
* @param _msg - SIP message structure
* @param msg_checks - bitmask of sanity tests to perform over message
* @param uri_checks - bitmask of sanity tests to perform over uri
* @return -1 on error, 0 on tests failure, 1 on success
*/
int sanity_check(struct sip_msg* _msg, int msg_checks, int uri_checks)
{
int ret;
if(ksr_sanity_noreply!=0) {
ksr_sanity_info_init();
}
ret = SANITY_CHECK_PASSED;
if (SANITY_RURI_SIP_VERSION & msg_checks &&
(ret = check_ruri_sip_version(_msg)) != SANITY_CHECK_PASSED) {
goto done;
}
if (SANITY_RURI_SCHEME & msg_checks &&
(ret = check_ruri_scheme(_msg)) != SANITY_CHECK_PASSED) {
goto done;
}
if (SANITY_REQUIRED_HEADERS & msg_checks &&
(ret = check_required_headers(_msg)) != SANITY_CHECK_PASSED) {
goto done;
}
if (SANITY_VIA1_HEADER & msg_checks &&
(ret = check_via1_header(_msg)) != SANITY_CHECK_PASSED) {
goto done;
}
if (SANITY_VIA_SIP_VERSION & msg_checks &&
(ret = check_via_sip_version(_msg)) != SANITY_CHECK_PASSED) {
goto done;
}
if (SANITY_VIA_PROTOCOL & msg_checks &&
(ret = check_via_protocol(_msg)) != SANITY_CHECK_PASSED) {
goto done;
}
if (SANITY_CSEQ_METHOD & msg_checks &&
(ret = check_cseq_method(_msg)) != SANITY_CHECK_PASSED) {
goto done;
}
if (SANITY_CSEQ_VALUE & msg_checks &&
(ret = check_cseq_value(_msg)) != SANITY_CHECK_PASSED) {
goto done;
}
if (SANITY_CL & msg_checks &&
(ret = check_cl(_msg)) != SANITY_CHECK_PASSED) {
goto done;
}
if (SANITY_EXPIRES_VALUE & msg_checks &&
(ret = check_expires_value(_msg)) != SANITY_CHECK_PASSED) {
goto done;
}
if (SANITY_PROXY_REQUIRE & msg_checks &&
(ret = check_proxy_require(_msg)) != SANITY_CHECK_PASSED) {
goto done;
}
if (SANITY_PARSE_URIS & msg_checks &&
(ret = check_parse_uris(_msg, uri_checks)) != SANITY_CHECK_PASSED) {
goto done;
}
if (SANITY_CHECK_DIGEST & msg_checks &&
(ret = check_digest(_msg, uri_checks)) != SANITY_CHECK_PASSED) {
goto done;
}
if (SANITY_CHECK_AUTHORIZATION & msg_checks &&
(ret = check_authorization(_msg, uri_checks)) != SANITY_CHECK_PASSED) {
goto done;
}
if (SANITY_CHECK_DUPTAGS & msg_checks &&
(ret = check_duptags(_msg)) != SANITY_CHECK_PASSED) {
goto done;
}
done:
return ret;
}
