static
int
report_checkN(int rv, int error, int *right_errors, int right_num)
{
int i, goterror;
int result = 1;
if (rv==-1) {
goterror = error;
}
else {
goterror = 0;
}
for (i=0; i<right_num; i++) {
if (goterror == right_errors[i]) {
report_result(rv, error);
report_passed(&result);
return result;
}
}
if (goterror == ENOSYS) {
report_saw_enosys();
say("(unimplemented) ");
report_skipped(&result);
}
else {
report_result(rv, error);
report_failure(&result);
}
return result;
}
static
int
exec_common_fork(int *result)
{
int pid, rv, status, err;
/*
* This does not happen in a test context (from the point of
* view of report.c) so we have to fiddle a bit.
*/
pid = fork();
if (pid<0) {
err = errno;
report_begin("forking for test");
report_result(pid, err);
report_aborted(result);
return -1;
}
if (pid==0) {
/* child */
return 0;
}
rv = waitpid(pid, &status, 0);
if (rv == -1) {
err = errno;
report_begin("waiting for test subprocess");
report_result(rv, err);
report_failure(result);
return -1;
}
if (WIFEXITED(status) && WEXITSTATUS(status) == MAGIC_STATUS) {
*result = SUCCESS;
return 1;
}
/* Oops... */
report_begin("exit code of subprocess; should be %d", MAGIC_STATUS);
if (WIFSIGNALED(status)) {
report_warnx("signal %d", WTERMSIG(status));
}
else {
report_warnx("exit %d", WEXITSTATUS(status));
}
report_failure(result);
return -1;
}
int test_test(global_options *options, int fatal)
{
report_result(options, "test-test", "main", RESULT_SUCCESS, 0, OPER_EQUAL, 0);
return 0;
}
static HRESULT write_post_stream(Protocol *protocol)
{
BYTE buf[0x20000];
DWORD written;
ULONG size;
BOOL res;
HRESULT hres;
protocol->flags &= ~FLAG_REQUEST_COMPLETE;
while(1) {
size = 0;
hres = IStream_Read(protocol->post_stream, buf, sizeof(buf), &size);
if(FAILED(hres) || !size)
break;
res = InternetWriteFile(protocol->request, buf, size, &written);
if(!res) {
FIXME("InternetWriteFile failed: %u\n", GetLastError());
hres = E_FAIL;
break;
}
}
if(SUCCEEDED(hres)) {
IStream_Release(protocol->post_stream);
protocol->post_stream = NULL;
hres = protocol->vtbl->end_request(protocol);
}
if(FAILED(hres))
return report_result(protocol, hres);
return S_OK;
}
void
report_survival(int rv, int error, int *result)
{
/* allow any error as long as we survive */
report_result(rv, error);
report_passed(result);
}
// called at update check TOD, on each user logout in case update is pending or on demand by admin UI
void check_for_update(update_check_e type, conn_t *conn)
{
bool force = (type != WAIT_UNTIL_NO_USERS);
if (no_net) {
lprintf("UPDATE: not checked because no-network-mode set\n");
return;
}
if (!force && admcfg_bool("update_check", NULL, CFG_REQUIRED) == false) {
lprintf("UPDATE: exiting because admin update check not enabled\n");
return;
}
if (force) {
lprintf("UPDATE: force %s by admin\n", (type == FORCE_CHECK)? "update check" : "build");
assert(conn != NULL);
if (update_task_running) {
lprintf("UPDATE: update task already running\n");
report_result(conn);
return;
} else {
conn->update_check = type;
}
}
if ((force || (update_pending && rx_count_server_conns(EXTERNAL_ONLY) == 0)) && !update_task_running) {
update_task_running = true;
CreateTask(update_task, TO_VOID_PARAM(conn), ADMIN_PRIORITY);
}
}
static void all_data_read(Protocol *protocol)
{
protocol->flags |= FLAG_ALL_DATA_READ;
report_data(protocol);
report_result(protocol, S_OK);
}
static HRESULT start_downloading(Protocol *protocol)
{
HRESULT hres;
hres = protocol->vtbl->start_downloading(protocol);
if(FAILED(hres)) {
protocol_close_connection(protocol);
report_result(protocol, hres);
return hres;
}
if(protocol->bindf & BINDF_NEEDFILE) {
WCHAR cache_file[MAX_PATH];
DWORD buflen = sizeof(cache_file);
if(InternetQueryOptionW(protocol->request, INTERNET_OPTION_DATAFILE_NAME, cache_file, &buflen)) {
report_progress(protocol, BINDSTATUS_CACHEFILENAMEAVAILABLE, cache_file);
}else {
FIXME("Could not get cache file\n");
}
}
protocol->flags |= FLAG_FIRST_CONTINUE_COMPLETE;
return S_OK;
}
/**
* If you have extra command line parameters, you may use this method to start CPUnit
* after you have done your own. You should use {@link #get_cmd_line_parser()} to obtain
* a parser which is already set up to accept the CPUnit specific command line parameters,
* and then use CmdLineParser.add_legal to specify the arguments you expect in addition.
*
* @param parser A parser contaiing the command line arguments, excluding the program name.
* I.e. from main(int& argc,char** args), the parser would be called as
* {@link CmdLineParser#parse(const int, const char**) parser.parse(arcg-1,args+1)}.
* @return 0 if all tests succeed, and >0 elsewise.
*/
int main(const CmdLineParser &parser) {
AutoDisposer ad;
try {
CPUNIT_ITRACE("EntryPoint - Actual arguments:"<<parser.to_string());
std::vector<std::string> patterns = parser.program_input();
if (patterns.size() == 0) {
patterns.push_back("*");
}
if(parser.has_one_of("-h --help")) {
usage();
return 0;
}
if(parser.has_one_of("-L --list")) {
list_tests(patterns);
return 0;
}
if(parser.has_one_of("-V --version")) {
print_version_info();
return 0;
}
const bool verbose = parser.has("-v") || parser.has("--verbose");
const bool robust = parser.has("-a") || parser.has("--all");
const bool conformity = parser.has("--conformity");
CPUNIT_ITRACE("EntryPoint - verbose="<<verbose<<" robust="<<robust<<" conformity="<<conformity);
bool conform = true;
if (conformity) {
std::vector<std::string> conf_patterns = get_conformity_format(parser);
const int num_conformity_breaches = conformity_report(patterns, conf_patterns[0], conf_patterns[1], conf_patterns[2], verbose, std::cout);
std::cout<<"There where "<<num_conformity_breaches<<" conformity breaches."<<std::endl;
conform = num_conformity_breaches == 0;
}
const std::string report_format = parser.value_of<std::string>(error_format_token);
const double max_time = parser.value_of<double>(max_time_token);
const std::vector<cpunit::ExecutionReport> result = cpunit::TestExecutionFacade().execute(patterns, max_time, verbose, robust);
bool all_well = report_result(result, report_format, std::cout);
int exit_value = 0;
if (!all_well) {
exit_value |= 0x1;
}
if(!conform) {
exit_value |= 0x2;
}
return exit_value;
} catch (AssertionException &e) {
std::cout<<"Terminated due to AssertionException: "<<std::endl<<e.what()<<std::endl;
return 1;
}
}
HRESULT protocol_abort(Protocol *protocol, HRESULT reason)
{
if(!protocol->protocol_sink)
return S_OK;
if(protocol->flags & FLAG_RESULT_REPORTED)
return INET_E_RESULT_DISPATCHED;
report_result(protocol, reason);
return S_OK;
}
void
piglit_init(int argc, char **argv)
{
unsigned i;
/* Parse first param. */
if (argc < 3)
print_usage_and_exit(argv[0]);
for (i = 0; i < ARRAY_SIZE(tests); i++) {
if (strcmp(argv[1], tests[i].name) == 0) {
test = &tests[i];
break;
}
}
if (test == NULL)
print_usage_and_exit(argv[0]);
/* Parse options. */
for (i = 3; i < argc; i++) {
if (strcmp(argv[i], "interface") == 0)
use_interface_blocks = true;
else
print_usage_and_exit(argv[0]);
}
/* Parse second param and setup test */
if (strcmp(argv[2], "error") == 0) {
report_result(test_errors());
} else if (strcmp(argv[2], "get") == 0) {
link_shaders(true);
report_result(test_gets());
} else if (strcmp(argv[2], "run") == 0) {
link_shaders(true);
/* Testing will occur in piglit_display */
} else if (strcmp(argv[2], "run-no-fs") == 0) {
link_shaders(false);
report_result(test_xfb(true));
} else {
print_usage_and_exit(argv[0]);
}
}
void usage(char *prog_name, int status)
{
FILE *output = NULL;
if (prog_name == NULL)
prog_name = "cpu-hog";
if (status)
output = stderr;
else
output = stdout;
fprintf(output, USAGE, prog_name);
if (status)
report_result("2\n");
else
report_result("1\n");
exit(status);
}
/**
* Link the appropriate set of shaders for running a positive test,
* calling glTransformFeedbackVaryings() to set up transform feedback.
*/
static void
link_shaders(bool use_fs)
{
GLuint vs;
const char **varyings;
prog = glCreateProgram();
vs = compile_shader(GL_VERTEX_SHADER, test->vs);
glAttachShader(prog, vs);
glDeleteShader(vs);
if (use_fs) {
GLuint fs = compile_shader(GL_FRAGMENT_SHADER, test->fs);
glAttachShader(prog, fs);
glDeleteShader(fs);
} else {
#ifdef PIGLIT_USE_OPENGL_ES3
GLuint fs = compile_shader(GL_FRAGMENT_SHADER, generic_gles3_fs_text);
glAttachShader(prog, fs);
glDeleteShader(fs);
#endif
}
if (use_interface_blocks)
varyings = prepend_varyings("Blk.", test->good_varyings);
else
varyings = test->good_varyings;
glTransformFeedbackVaryings(prog, count_strings(test->good_varyings),
(const GLchar **) varyings,
GL_INTERLEAVED_ATTRIBS);
if (use_interface_blocks)
free_varyings(varyings);
if (!piglit_check_gl_error(GL_NO_ERROR)) {
glDeleteProgram(prog);
report_result(PIGLIT_FAIL);
}
glBindAttribLocation(prog, VERTEX_ATTRIB_POS, "pos");
glLinkProgram(prog);
if (!piglit_link_check_status(prog)) {
glDeleteProgram(prog);
report_result(PIGLIT_FAIL);
}
}
static HRESULT open_file(FileProtocol *This, const WCHAR *path, IInternetProtocolSink *protocol_sink)
{
LARGE_INTEGER size;
HANDLE file;
file = CreateFileW(path, GENERIC_READ, FILE_SHARE_READ, NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if(file == INVALID_HANDLE_VALUE)
return report_result(protocol_sink, INET_E_RESOURCE_NOT_FOUND, GetLastError());
if(!GetFileSizeEx(file, &size)) {
CloseHandle(file);
return report_result(protocol_sink, INET_E_RESOURCE_NOT_FOUND, GetLastError());
}
This->file = file;
This->size = size.u.LowPart;
IInternetProtocolSink_ReportProgress(protocol_sink,
BINDSTATUS_CACHEFILENAMEAVAILABLE, path);
return S_OK;
}
HRESULT protocol_start(Protocol *protocol, IInternetProtocol *prot, IUri *uri,
IInternetProtocolSink *protocol_sink, IInternetBindInfo *bind_info)
{
DWORD request_flags;
HRESULT hres;
protocol->protocol = prot;
IInternetProtocolSink_AddRef(protocol_sink);
protocol->protocol_sink = protocol_sink;
memset(&protocol->bind_info, 0, sizeof(protocol->bind_info));
protocol->bind_info.cbSize = sizeof(BINDINFO);
hres = IInternetBindInfo_GetBindInfo(bind_info, &protocol->bindf, &protocol->bind_info);
if(hres != S_OK) {
WARN("GetBindInfo failed: %08x\n", hres);
return report_result(protocol, hres);
}
if(!(protocol->bindf & BINDF_FROMURLMON))
report_progress(protocol, BINDSTATUS_DIRECTBIND, NULL);
if(!get_internet_session(bind_info))
return report_result(protocol, INET_E_NO_SESSION);
request_flags = INTERNET_FLAG_KEEP_CONNECTION;
if(protocol->bindf & BINDF_NOWRITECACHE)
request_flags |= INTERNET_FLAG_NO_CACHE_WRITE;
if(protocol->bindf & BINDF_NEEDFILE)
request_flags |= INTERNET_FLAG_NEED_FILE;
hres = protocol->vtbl->open_request(protocol, uri, request_flags, internet_session, bind_info);
if(FAILED(hres)) {
protocol_close_connection(protocol);
return report_result(protocol, hres);
}
return S_OK;
}
void checkopt(int argc, char **argv)
{
char c = '\0';
char *endptr = NULL;
long nr_cpus = 0;
long opt_value = 0;
if (argc == 1)
return;
nr_cpus = sysconf(_SC_NPROCESSORS_ONLN);
if (nr_cpus <= 0) {
fprintf(stderr, "Error: sysconf failed\n");
report_result("2\n");
exit(1);
}
while ((c = getopt(argc, argv, "p:h")) != -1) {
switch (c) {
case 'p':
if (optarg[0] == '-' && !isdigit(optarg[1]))
OPT_MISSING(argv[0], c);
else {
opt_value = strtol(optarg, &endptr, DECIMAL);
if (errno || (endptr != NULL && *endptr != '\0')
|| opt_value <= 0 || opt_value > MAX_NPROCS)
ARG_WRONG(argv[0], c, optarg);
nprocs = atoi(optarg);
}
break;
case 'h': /* usage message */
usage(argv[0], 0);
break;
default:
usage(argv[0], 1);
break;
}
}
if (nprocs == 0)
nprocs = 2 * nr_cpus;
}
enum piglit_result
piglit_display(void)
{
static const float green[4] = {0.0, 1.0, 0.0, 1.0};
enum piglit_result result;
glClear(GL_COLOR_BUFFER_BIT);
result = test_xfb(false);
/* test_xfb() sends a set of vertices down the pipeline that
* should cause the entire window to be drawn, so all we need
* to do to make sure that the correct data got to the
* fragment shader is verify that it painted a green window.
*/
if (!piglit_probe_rect_rgba(0, 0, piglit_width, piglit_height, green))
result = PIGLIT_FAIL;
piglit_present_results();
report_result(result);
return result;
}
static HRESULT WINAPI FileProtocol_StartEx(IInternetProtocolEx *iface, IUri *pUri,
IInternetProtocolSink *pOIProtSink, IInternetBindInfo *pOIBindInfo,
DWORD grfPI, HANDLE *dwReserved)
{
FileProtocol *This = impl_from_IInternetProtocolEx(iface);
WCHAR path[MAX_PATH], *ptr;
LARGE_INTEGER file_size;
HANDLE file_handle;
BINDINFO bindinfo;
DWORD grfBINDF = 0;
DWORD scheme, size;
LPWSTR mime = NULL;
WCHAR null_char = 0;
BSTR ext;
HRESULT hres;
TRACE("(%p)->(%p %p %p %08x %p)\n", This, pUri, pOIProtSink,
pOIBindInfo, grfPI, dwReserved);
if(!pUri)
return E_INVALIDARG;
scheme = 0;
hres = IUri_GetScheme(pUri, &scheme);
if(FAILED(hres))
return hres;
if(scheme != URL_SCHEME_FILE)
return E_INVALIDARG;
memset(&bindinfo, 0, sizeof(bindinfo));
bindinfo.cbSize = sizeof(BINDINFO);
hres = IInternetBindInfo_GetBindInfo(pOIBindInfo, &grfBINDF, &bindinfo);
if(FAILED(hres)) {
WARN("GetBindInfo failed: %08x\n", hres);
return hres;
}
ReleaseBindInfo(&bindinfo);
if(!(grfBINDF & BINDF_FROMURLMON))
IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_DIRECTBIND, NULL);
if(This->file != INVALID_HANDLE_VALUE) {
IInternetProtocolSink_ReportData(pOIProtSink,
BSCF_FIRSTDATANOTIFICATION|BSCF_LASTDATANOTIFICATION,
This->size, This->size);
return S_OK;
}
IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_SENDINGREQUEST, &null_char);
size = 0;
hres = CoInternetParseIUri(pUri, PARSE_PATH_FROM_URL, 0, path, sizeof(path)/sizeof(WCHAR), &size, 0);
if(FAILED(hres)) {
WARN("CoInternetParseIUri failed: %08x\n", hres);
return report_result(pOIProtSink, hres, 0);
}
file_handle = CreateFileW(path, GENERIC_READ, FILE_SHARE_READ, NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if(file_handle == INVALID_HANDLE_VALUE && (ptr = strrchrW(path, '#'))) {
/* If path contains fragment part, try without it. */
*ptr = 0;
file_handle = CreateFileW(path, GENERIC_READ, FILE_SHARE_READ, NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
}
if(file_handle == INVALID_HANDLE_VALUE)
return report_result(pOIProtSink, INET_E_RESOURCE_NOT_FOUND, GetLastError());
if(!GetFileSizeEx(file_handle, &file_size)) {
CloseHandle(file_handle);
return report_result(pOIProtSink, INET_E_RESOURCE_NOT_FOUND, GetLastError());
}
This->file = file_handle;
This->size = file_size.u.LowPart;
IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_CACHEFILENAMEAVAILABLE, path);
hres = IUri_GetExtension(pUri, &ext);
if(SUCCEEDED(hres)) {
if(hres == S_OK && *ext) {
if((ptr = strchrW(ext, '#')))
*ptr = 0;
hres = find_mime_from_ext(ext, &mime);
if(SUCCEEDED(hres)) {
IInternetProtocolSink_ReportProgress(pOIProtSink,
(grfBINDF & BINDF_FROMURLMON) ?
BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE : BINDSTATUS_MIMETYPEAVAILABLE,
mime);
CoTaskMemFree(mime);
}
}
SysFreeString(ext);
}
IInternetProtocolSink_ReportData(pOIProtSink,
BSCF_FIRSTDATANOTIFICATION|BSCF_LASTDATANOTIFICATION,
This->size, This->size);
return report_result(pOIProtSink, S_OK, 0);
}
static void update_task(void *param)
{
conn_t *conn = (conn_t *) FROM_VOID_PARAM(param);
bool force_check = (conn && conn->update_check == FORCE_CHECK);
bool force_build = (conn && conn->update_check == FORCE_BUILD);
bool ver_changed, update_install;
lprintf("UPDATE: checking for updates\n");
// Run curl in a Linux child process otherwise this thread will block and cause trouble
// if the check is invoked from the admin page while there are active user connections.
int status = child_task("kiwi.upd", POLL_MSEC(1000), curl_makefile_ctask, NULL);
if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
lprintf("UPDATE: curl Makefile error, no Internet access? status=0x%08x WIFEXITED=%d WEXITSTATUS=%d\n",
status, WIFEXITED(status), WEXITSTATUS(status));
if (force_check) report_result(conn);
goto common_return;
}
FILE *fp;
scallz("fopen Makefile.1", (fp = fopen("/root/" REPO_NAME "/Makefile.1", "r")));
int n1, n2;
n1 = fscanf(fp, "VERSION_MAJ = %d\n", &pending_maj);
n2 = fscanf(fp, "VERSION_MIN = %d\n", &pending_min);
fclose(fp);
ver_changed = (n1 == 1 && n2 == 1 && (pending_maj > version_maj || (pending_maj == version_maj && pending_min > version_min)));
update_install = (admcfg_bool("update_install", NULL, CFG_REQUIRED) == true);
if (force_check) {
if (ver_changed)
lprintf("UPDATE: version changed (current %d.%d, new %d.%d), but check only\n",
version_maj, version_min, pending_maj, pending_min);
else
lprintf("UPDATE: running most current version\n");
report_result(conn);
goto common_return;
} else
if (ver_changed && !update_install && !force_build) {
lprintf("UPDATE: version changed (current %d.%d, new %d.%d), but update install not enabled\n",
version_maj, version_min, pending_maj, pending_min);
} else
if (ver_changed || force_build) {
lprintf("UPDATE: version changed%s, current %d.%d, new %d.%d\n",
force_build? " (forced)":"",
version_maj, version_min, pending_maj, pending_min);
lprintf("UPDATE: building new version..\n");
update_in_progress = true;
rx_server_user_kick(-1); // kick everyone off to speed up build
sleep(5);
// Run build in a Linux child process so the server can continue to respond to connection requests
// and display a "software update in progress" message.
// This is because the calls to system() in update_build_ctask() block for the duration of the build.
u4_t build_time = timer_sec();
status = child_task("kiwi.bld", POLL_MSEC(1000), update_build_ctask, TO_VOID_PARAM(force_build));
if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
lprintf("UPDATE: build error, no Internet access? status=0x%08x WIFEXITED=%d WEXITSTATUS=%d\n",
status, WIFEXITED(status), WEXITSTATUS(status));
goto common_return;
}
lprintf("UPDATE: build took %d secs\n", timer_sec() - build_time);
lprintf("UPDATE: switching to new version %d.%d\n", pending_maj, pending_min);
if (admcfg_int("update_restart", NULL, CFG_REQUIRED) == 0) {
xit(0);
} else {
lprintf("UPDATE: rebooting Beagle..\n");
system("sleep 3; reboot");
}
} else {
lprintf("UPDATE: version %d.%d is current\n", version_maj, version_min);
}
if (daily_restart) {
lprintf("UPDATE: daily restart..\n");
xit(0);
}
common_return:
if (conn) conn->update_check = WAIT_UNTIL_NO_USERS; // restore default
update_pending = update_task_running = update_in_progress = false;
}
// Returns the number of satisfied pairs
int join_bucket_knn(struct query_op &stop, struct query_temp &sttemp)
{
IStorageManager *storage = NULL;
ISpatialIndex *spidx = NULL;
bool selfjoin = stop.join_cardinality == 1 ? true : false;
/* Indicates where original data is mapped to */
int idx1 = SID_1;
int idx2 = selfjoin ? SID_1 : SID_2;
int pairs = 0; // number of satisfied results
double low[2], high[2]; // Temporary value placeholders for MBB
double tmp_distance; // Temporary distance for nearest neighbor query
double def_search_radius = -1; // Default search radius
//for nearest neighbor (NN) with unknown bounds
double max_search_radius; // max_radius to search for NN
try {
vector<Geometry*> & poly_set_one = sttemp.polydata[idx1];
vector<Geometry*> & poly_set_two = sttemp.polydata[idx2];
int len1 = poly_set_one.size();
int len2 = poly_set_two.size();
#ifdef DEBUG
cerr << "Bucket size: " << len1 << " joining with " << len2 << endl;
#endif
cerr << "Bucket size: " << len1 << " joining with " << len2 << endl;
if (len1 <= 0 || len2 <= 0) {
return 0;
}
/* Build index on the "second data set */
map<int, Geometry*> geom_polygons2;
geom_polygons2.clear();
// Make a copy of the vector to map to build index (API restriction)
for (int j = 0; j < len2; j++) {
geom_polygons2[j] = poly_set_two[j];
}
/* Handling for special nearest neighbor query */
if (stop.join_predicate == ST_NEAREST_2) {
// Updating bucket information
if (len2 > 0) {
const Envelope * envtmp = poly_set_two[0]->getEnvelopeInternal();
sttemp.bucket_min_x = envtmp->getMinX();
sttemp.bucket_min_y = envtmp->getMinY();
sttemp.bucket_max_x = envtmp->getMaxX();
sttemp.bucket_max_y = envtmp->getMaxY();
}
for (int j = 0; j < len1; j++) {
update_bucket_dimension(stop, sttemp, poly_set_one[j]->getEnvelopeInternal());
}
if (!selfjoin) {
for (int j = 0; j < len2; j++) {
update_bucket_dimension(stop, sttemp, poly_set_two[j]->getEnvelopeInternal());
}
}
max_search_radius = max(sttemp.bucket_max_x - sttemp.bucket_min_x,
sttemp.bucket_max_y - sttemp.bucket_min_y);
def_search_radius = min(sqrt((sttemp.bucket_max_x - sttemp.bucket_min_x)
* (sttemp.bucket_max_y - sttemp.bucket_min_y)
* stop.k_neighbors / len2), max_search_radius);
if (def_search_radius == 0) {
def_search_radius = DistanceOp::distance(poly_set_one[0], poly_set_two[0]);
}
#ifdef DEBUG
cerr << "Bucket dimension min-max: " << sttemp.bucket_min_x << TAB
<< sttemp.bucket_min_y << TAB << sttemp.bucket_max_x
<< TAB << sttemp.bucket_max_y << endl;
cerr << "Width and height (x-y span) "
<< sttemp.bucket_max_x - sttemp.bucket_min_x
<< TAB << sttemp.bucket_max_y - sttemp.bucket_min_y << endl;
#endif
}
// build the actual spatial index for input polygons from idx2
if (! build_index_geoms(geom_polygons2, spidx, storage)) {
#ifdef DEBUG
cerr << "Building index on geometries from set 2 has failed" << endl;
#endif
return -1;
}
cerr << "done building indices" << endl;
for (int i = 0; i < len1; i++) {
/* Extract minimum bounding box */
const Geometry* geom1 = poly_set_one[i];
const Envelope * env1 = geom1->getEnvelopeInternal();
low[0] = env1->getMinX();
low[1] = env1->getMinY();
high[0] = env1->getMaxX();
high[1] = env1->getMaxY();
/* Handle the buffer expansion for R-tree in
the case of Dwithin and nearest neighbor predicate */
if (stop.join_predicate == ST_NEAREST_2) {
/* Nearest neighbor when max search radius
is not determined */
stop.expansion_distance = def_search_radius;
// Initial value
}
if (stop.join_predicate == ST_DWITHIN ||
stop.join_predicate == ST_NEAREST) {
low[0] -= stop.expansion_distance;
low[1] -= stop.expansion_distance;
high[0] += stop.expansion_distance;
high[1] += stop.expansion_distance;
}
/* Regular handling */
Region r(low, high, 2);
MyVisitor vis;
vis.matches.clear();
/* R-tree intersection check */
spidx->intersectsWithQuery(r, vis);
/* Retrieve enough candidate neighbors */
if (stop.join_predicate == ST_NEAREST_2) {
double search_radius = def_search_radius;
while (vis.matches.size() <= stop.k_neighbors + 1
&& vis.matches.size() <= len2 // there can't be more neighbors than number of objects in the bucket
&& search_radius <= sqrt(2) * max_search_radius) {
// Increase the radius to find more neighbors
// Stopping criteria when there are not enough neighbors in a tile
low[0] = env1->getMinX() - search_radius;
low[1] = env1->getMinY() - search_radius;
high[0] = env1->getMaxX() + search_radius;
high[1] = env1->getMaxY() + search_radius;
Region r2(low, high, 2);
vis.matches.clear();
spidx->intersectsWithQuery(r2, vis);
#ifdef DEBUG
cerr << "Search radius:" << search_radius << " hits: " << vis.matches.size() << endl;
#endif
search_radius *= sqrt(2);
}
sttemp.nearest_distances.clear();
/* Handle the special case of rectangular/circle expansion -sqrt(2) expansion */
vis.matches.clear();
low[0] = env1->getMinX() - search_radius;
low[1] = env1->getMinY() - search_radius;
high[0] = env1->getMaxX() + search_radius;
high[1] = env1->getMaxY() + search_radius;
Region r3(low, high, 2);
spidx->intersectsWithQuery(r3, vis);
}
for (uint32_t j = 0; j < vis.matches.size(); j++)
{
const Geometry* geom2 = poly_set_two[vis.matches[j]];
const Envelope * env2 = geom2->getEnvelopeInternal();
if (stop.join_predicate == ST_NEAREST
&& (!selfjoin || vis.matches[j] != i)) { // remove selfjoin candidates
/* Handle nearest neighbor candidate */
tmp_distance = DistanceOp::distance(geom1, geom2);
if (tmp_distance < stop.expansion_distance) {
update_nn(stop, sttemp, vis.matches[j], tmp_distance);
}
}
else if (stop.join_predicate == ST_NEAREST_2
&& (!selfjoin || vis.matches[j] != i)) {
tmp_distance = DistanceOp::distance(geom1, geom2);
update_nn(stop, sttemp, vis.matches[j], tmp_distance);
// cerr << "updating: " << vis.matches[j] << " " << tmp_distance << endl;
}
}
/* Nearest neighbor outputting */
for (std::list<struct query_nn_dist *>::iterator
it = sttemp.nearest_distances.begin();
it != sttemp.nearest_distances.end(); it++)
{
sttemp.distance = (*it)->distance;
report_result(stop, sttemp, i, (*it)->object_id);
pairs++;
/* Cleaning up memory */
delete *it;
}
sttemp.nearest_distances.clear();
}
} // end of try
catch (Tools::Exception& e) {
//catch (...) {
std::cerr << "******ERROR******" << std::endl;
#ifdef DEBUG
cerr << e.what() << std::endl;
#endif
return -1;
} // end of catch
cerr << "Done with tile" << endl;
delete spidx;
delete storage;
return pairs ;
}
HRESULT protocol_read(Protocol *protocol, void *buf, ULONG size, ULONG *read_ret)
{
ULONG read = 0;
BOOL res;
HRESULT hres = S_FALSE;
if(protocol->flags & FLAG_ALL_DATA_READ) {
*read_ret = 0;
return S_FALSE;
}
if(!(protocol->flags & FLAG_SYNC_READ) && (!(protocol->flags & FLAG_REQUEST_COMPLETE) || !protocol->available_bytes)) {
*read_ret = 0;
return E_PENDING;
}
while(read < size && protocol->available_bytes) {
ULONG len;
res = InternetReadFile(protocol->request, ((BYTE *)buf)+read,
protocol->available_bytes > size-read ? size-read : protocol->available_bytes, &len);
if(!res) {
WARN("InternetReadFile failed: %d\n", GetLastError());
hres = INET_E_DOWNLOAD_FAILURE;
report_result(protocol, hres);
break;
}
if(!len) {
all_data_read(protocol);
break;
}
read += len;
protocol->current_position += len;
protocol->available_bytes -= len;
TRACE("current_position %d, available_bytes %d\n", protocol->current_position, protocol->available_bytes);
if(!protocol->available_bytes) {
/* InternetQueryDataAvailable may immediately fork and perform its asynchronous
* read, so clear the flag _before_ calling so it does not incorrectly get cleared
* after the status callback is called */
protocol->flags &= ~FLAG_REQUEST_COMPLETE;
res = InternetQueryDataAvailable(protocol->request, &protocol->query_available, 0, 0);
if(!res) {
if (GetLastError() == ERROR_IO_PENDING) {
hres = E_PENDING;
}else {
WARN("InternetQueryDataAvailable failed: %d\n", GetLastError());
hres = INET_E_DATA_NOT_AVAILABLE;
report_result(protocol, hres);
}
break;
}
if(!protocol->query_available) {
all_data_read(protocol);
break;
}
protocol->available_bytes = protocol->query_available;
}
}
*read_ret = read;
if (hres != E_PENDING)
protocol->flags |= FLAG_REQUEST_COMPLETE;
if(FAILED(hres))
return hres;
return read ? S_OK : S_FALSE;
}
HRESULT protocol_continue(Protocol *protocol, PROTOCOLDATA *data)
{
BOOL is_start;
HRESULT hres;
is_start = !data || data->pData == UlongToPtr(BINDSTATUS_DOWNLOADINGDATA);
if(!protocol->request) {
WARN("Expected request to be non-NULL\n");
return S_OK;
}
if(!protocol->protocol_sink) {
WARN("Expected IInternetProtocolSink pointer to be non-NULL\n");
return S_OK;
}
if(protocol->flags & FLAG_ERROR) {
protocol->flags &= ~FLAG_ERROR;
protocol->vtbl->on_error(protocol, PtrToUlong(data->pData));
return S_OK;
}
if(protocol->post_stream)
return write_post_stream(protocol);
if(is_start) {
hres = start_downloading(protocol);
if(FAILED(hres))
return S_OK;
}
if(!data || data->pData >= UlongToPtr(BINDSTATUS_DOWNLOADINGDATA)) {
if(!protocol->available_bytes) {
if(protocol->query_available) {
protocol->available_bytes = protocol->query_available;
}else {
BOOL res;
/* InternetQueryDataAvailable may immediately fork and perform its asynchronous
* read, so clear the flag _before_ calling so it does not incorrectly get cleared
* after the status callback is called */
protocol->flags &= ~FLAG_REQUEST_COMPLETE;
res = InternetQueryDataAvailable(protocol->request, &protocol->query_available, 0, 0);
if(res) {
TRACE("available %u bytes\n", protocol->query_available);
if(!protocol->query_available) {
if(is_start) {
TRACE("empty file\n");
all_data_read(protocol);
}else {
WARN("unexpected end of file?\n");
report_result(protocol, INET_E_DOWNLOAD_FAILURE);
}
return S_OK;
}
protocol->available_bytes = protocol->query_available;
}else if(GetLastError() != ERROR_IO_PENDING) {
protocol->flags |= FLAG_REQUEST_COMPLETE;
WARN("InternetQueryDataAvailable failed: %d\n", GetLastError());
report_result(protocol, INET_E_DATA_NOT_AVAILABLE);
return S_OK;
}
}
protocol->flags |= FLAG_REQUEST_COMPLETE;
}
report_data(protocol);
}
return S_OK;
}
int main(int argc, char **argv)
{
int i = 0;
pid_t pid;
pid_t *childpids = NULL;
sigset_t sigset;
int status = 0;
int ret = 0;
checkopt(argc, argv);
if (initialize()) {
warn("initialize failed");
report_result("2\n");
exit(EXIT_FAILURE);
}
if (sigemptyset(&sigset) < 0) {
warn("sigemptyset failed");
report_result("2\n");
exit(EXIT_FAILURE);
}
childpids = malloc((nprocs) * sizeof(pid_t));
if (childpids == NULL) {
warn("alloc for child pids failed");
report_result("2\n");
exit(EXIT_FAILURE);
}
memset(childpids, 0, (nprocs) * sizeof(pid_t));
report_result("0\n");
sigsuspend(&sigset);
for (; i < nprocs; i++) {
pid = fork();
if (pid == -1) {
while (--i >= 0)
kill(childpids[i], SIGKILL);
warn("fork test tasks failed");
report_result("2\n");
exit(EXIT_FAILURE);
} else if (!pid) {
ret = cpu_hog();
exit(ret);
}
childpids[i] = pid;
}
report_result("0\n");
while (!end) {
if (sigemptyset(&sigset) < 0)
ret = -1;
else
sigsuspend(&sigset);
if (ret || end) {
for (i = 0; i < nprocs; i++) {
kill(childpids[i], SIGUSR2);
}
break;
} else {
for (i = 0; i < nprocs; i++) {
kill(childpids[i], SIGUSR1);
}
}
}
for (i = 0; i < nprocs; i++) {
wait(&status);
if (status)
ret = EXIT_FAILURE;
}
free(childpids);
return ret;
}
// performs spatial join on the current tile (bucket)
int join_bucket_spjoin(struct query_op &stop, struct query_temp &sttemp) {
IStorageManager *storage = NULL;
ISpatialIndex *spidx = NULL;
bool selfjoin = stop.join_cardinality == 1 ? true : false;
/* Indicates where original data is mapped to */
int idx1 = SID_1;
int idx2 = selfjoin ? SID_1 : SID_2;
int pairs = 0; // number of satisfied results
double low[2], high[2]; // Temporary value placeholders for MBB
try {
vector<Geometry*> & poly_set_one = sttemp.polydata[idx1];
vector<Geometry*> & poly_set_two = sttemp.polydata[idx2];
int len1 = poly_set_one.size();
int len2 = poly_set_two.size();
#ifdef DEBUG
cerr << "Bucket size: " << len1 << " joining with " << len2 << endl;
#endif
cerr << "Bucket size: " << len1 << " joining with " << len2 << endl;
if (len1 <= 0 || len2 <= 0) {
return 0;
}
/* Build index on the "second data set */
map<int, Geometry*> geom_polygons2;
geom_polygons2.clear();
// Make a copy of the vector to map to build index (API restriction)
for (int j = 0; j < len2; j++) {
geom_polygons2[j] = poly_set_two[j];
}
/* Handling for special nearest neighbor query */
// build the actual spatial index for input polygons from idx2
if (! build_index_geoms(geom_polygons2, spidx, storage)) {
#ifdef DEBUG
cerr << "Building index on geometries from set 2 has failed" << endl;
#endif
return -1;
}
for (int i = 0; i < len1; i++) {
/* Extract minimum bounding box */
const Geometry* geom1 = poly_set_one[i];
const Envelope * env1 = geom1->getEnvelopeInternal();
low[0] = env1->getMinX();
low[1] = env1->getMinY();
high[0] = env1->getMaxX();
high[1] = env1->getMaxY();
if (stop.join_predicate == ST_DWITHIN) {
low[0] -= stop.expansion_distance;
low[1] -= stop.expansion_distance;
high[0] += stop.expansion_distance;
high[1] += stop.expansion_distance;
}
/* Regular handling */
Region r(low, high, 2);
MyVisitor vis;
vis.matches.clear();
/* R-tree intersection check */
spidx->intersectsWithQuery(r, vis);
for (uint32_t j = 0; j < vis.matches.size(); j++)
{
/* Skip results that have been seen before (self-join case) */
if (selfjoin && ((vis.matches[j] == i) || // same objects in self-join
(!stop.result_pair_duplicate && vis.matches[j] <= i))) { // duplicate pairs
#ifdef DEBUG
cerr << "skipping (selfjoin): " << j << " " << vis.matches[j] << endl;
#endif
continue;
}
const Geometry* geom2 = poly_set_two[vis.matches[j]];
const Envelope * env2 = geom2->getEnvelopeInternal();
if (join_with_predicate(stop, sttemp, geom1, geom2, env1, env2,
stop.join_predicate)) {
report_result(stop, sttemp, i, vis.matches[j]);
pairs++;
}
}
}
} // end of try
catch (Tools::Exception& e) {
//catch (...) {
std::cerr << "******ERROR******" << std::endl;
#ifdef DEBUG
cerr << e.what() << std::endl;
#endif
return -1;
} // end of catch
cerr << "Done with tile" << endl;
delete spidx;
delete storage;
return pairs ;
}
static HRESULT WINAPI FileProtocol_StartEx(IInternetProtocolEx *iface, IUri *pUri,
IInternetProtocolSink *pOIProtSink, IInternetBindInfo *pOIBindInfo,
DWORD grfPI, HANDLE *dwReserved)
{
FileProtocol *This = impl_from_IInternetProtocolEx(iface);
WCHAR path[MAX_PATH];
BINDINFO bindinfo;
DWORD grfBINDF = 0;
DWORD scheme, size;
LPWSTR mime = NULL;
WCHAR null_char = 0;
BSTR url;
HRESULT hres;
TRACE("(%p)->(%p %p %p %08x %p)\n", This, pUri, pOIProtSink,
pOIBindInfo, grfPI, dwReserved);
if(!pUri)
return E_INVALIDARG;
scheme = 0;
hres = IUri_GetScheme(pUri, &scheme);
if(FAILED(hres))
return hres;
if(scheme != URL_SCHEME_FILE)
return E_INVALIDARG;
memset(&bindinfo, 0, sizeof(bindinfo));
bindinfo.cbSize = sizeof(BINDINFO);
hres = IInternetBindInfo_GetBindInfo(pOIBindInfo, &grfBINDF, &bindinfo);
if(FAILED(hres)) {
WARN("GetBindInfo failed: %08x\n", hres);
return hres;
}
ReleaseBindInfo(&bindinfo);
if(!(grfBINDF & BINDF_FROMURLMON))
IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_DIRECTBIND, NULL);
if(This->file != INVALID_HANDLE_VALUE) {
IInternetProtocolSink_ReportData(pOIProtSink,
BSCF_FIRSTDATANOTIFICATION|BSCF_LASTDATANOTIFICATION,
This->size, This->size);
return S_OK;
}
IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_SENDINGREQUEST, &null_char);
size = 0;
hres = CoInternetParseIUri(pUri, PARSE_PATH_FROM_URL, 0, path, sizeof(path)/sizeof(WCHAR), &size, 0);
if(FAILED(hres)) {
WARN("CoInternetParseIUri failed: %08x\n", hres);
return report_result(pOIProtSink, hres, 0);
}
hres = open_file(This, path, pOIProtSink);
if(FAILED(hres))
return hres;
hres = IUri_GetDisplayUri(pUri, &url);
if(hres == S_OK) {
hres = FindMimeFromData(NULL, url, NULL, 0, NULL, 0, &mime, 0);
SysFreeString(url);
if(SUCCEEDED(hres)) {
IInternetProtocolSink_ReportProgress(pOIProtSink,
(grfBINDF & BINDF_FROMURLMON) ?
BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE : BINDSTATUS_MIMETYPEAVAILABLE,
mime);
CoTaskMemFree(mime);
}
}
IInternetProtocolSink_ReportData(pOIProtSink,
BSCF_FIRSTDATANOTIFICATION|BSCF_LASTDATANOTIFICATION,
This->size, This->size);
return report_result(pOIProtSink, S_OK, 0);
}
void main_tick()
{
SDL_Event event;
while (SDL_PollEvent(&event)) {
switch(event.type) {
case SDL_MOUSEWHEEL:
printf("SDL_MOUSEWHEEL: timestamp: %u, windowID: %u, which: %u, x: %d, y: %d\n", event.wheel.timestamp, event.wheel.windowID, event.wheel.which, event.wheel.x, event.wheel.y);
if (!gotWheelUp)
{
if (event.wheel.y > 0) { gotWheelUp = 1; instruction(); }
else if (event.wheel.y < 0) { printf("You scrolled to the wrong direction (downwards)!\n"); report_result(1); }
}
else if (!gotWheelDown)
{
if (event.wheel.y < 0) { gotWheelDown = 1; instruction(); }
}
break;
case SDL_MOUSEBUTTONDOWN:
printf("SDL_MOUSEBUTTONDOWN: button: %d\n", event.button.button);
if (event.button.button == SDL_BUTTON_WHEELDOWN) { printf("SDL_BUTTON_WHEELDOWN\n"); gotWheelButtonDown = 1; instruction(); }
else if (event.button.button == SDL_BUTTON_WHEELUP) { printf("SDL_BUTTON_WHEELUP\n"); gotWheelButtonUp = 1; instruction(); }
else if (event.button.button == SDL_BUTTON_MIDDLE) { printf("SDL_BUTTON_MIDDLE\n"); gotWheelClick = 1; instruction(); }
break;
}
}
}
void instruction()
{
if (!gotWheelUp || !gotWheelButtonUp) printf("Please scroll the mouse wheel upwards (move your finger away from you towards the display).\n");
else if (!gotWheelDown || !gotWheelButtonDown) printf("Please scroll the mouse wheel downwards (move your finger towards you).\n");
else if (!gotWheelClick) printf("Please click the wheel button.\n");
else if (gotWheelUp && gotWheelButtonUp && gotWheelDown && gotWheelButtonDown && gotWheelClick) report_result(0);
}
HRESULT protocol_continue(Protocol *protocol, PROTOCOLDATA *data)
{
HRESULT hres;
if (!data) {
WARN("Expected pProtocolData to be non-NULL\n");
return S_OK;
}
if(!protocol->request) {
WARN("Expected request to be non-NULL\n");
return S_OK;
}
if(!protocol->protocol_sink) {
WARN("Expected IInternetProtocolSink pointer to be non-NULL\n");
return S_OK;
}
if(protocol->flags & FLAG_ERROR) {
protocol->flags &= ~FLAG_ERROR;
protocol->vtbl->on_error(protocol, (DWORD)data->pData);
return S_OK;
}
if(protocol->post_stream)
return write_post_stream(protocol);
if(data->pData == (LPVOID)BINDSTATUS_DOWNLOADINGDATA) {
hres = protocol->vtbl->start_downloading(protocol);
if(FAILED(hres)) {
protocol_close_connection(protocol);
report_result(protocol, hres);
return S_OK;
}
if(protocol->bindf & BINDF_NEEDFILE) {
WCHAR cache_file[MAX_PATH];
DWORD buflen = sizeof(cache_file);
if(InternetQueryOptionW(protocol->request, INTERNET_OPTION_DATAFILE_NAME,
cache_file, &buflen)) {
report_progress(protocol, BINDSTATUS_CACHEFILENAMEAVAILABLE, cache_file);
}else {
FIXME("Could not get cache file\n");
}
}
protocol->flags |= FLAG_FIRST_CONTINUE_COMPLETE;
}
if(data->pData >= (LPVOID)BINDSTATUS_DOWNLOADINGDATA) {
BOOL res;
/* InternetQueryDataAvailable may immediately fork and perform its asynchronous
* read, so clear the flag _before_ calling so it does not incorrectly get cleared
* after the status callback is called */
protocol->flags &= ~FLAG_REQUEST_COMPLETE;
res = InternetQueryDataAvailable(protocol->request, &protocol->available_bytes, 0, 0);
if(res) {
protocol->flags |= FLAG_REQUEST_COMPLETE;
report_data(protocol);
}else if(GetLastError() != ERROR_IO_PENDING) {
protocol->flags |= FLAG_REQUEST_COMPLETE;
WARN("InternetQueryDataAvailable failed: %d\n", GetLastError());
report_result(protocol, INET_E_DATA_NOT_AVAILABLE);
}
}
return S_OK;
}
static HRESULT WINAPI ITSProtocol_Start(IInternetProtocol *iface, LPCWSTR szUrl,
IInternetProtocolSink *pOIProtSink, IInternetBindInfo *pOIBindInfo,
DWORD grfPI, HANDLE_PTR dwReserved)
{
ITSProtocol *This = impl_from_IInternetProtocol(iface);
BINDINFO bindinfo;
DWORD bindf = 0, len;
LPWSTR file_name, mime, object_name, p;
LPCWSTR ptr;
struct chmFile *chm_file;
struct chmUnitInfo chm_object;
int res;
HRESULT hres;
static const WCHAR separator[] = {':',':',0};
TRACE("(%p)->(%s %p %p %08x %lx)\n", This, debugstr_w(szUrl), pOIProtSink,
pOIBindInfo, grfPI, dwReserved);
ptr = skip_schema(szUrl);
if(!ptr)
return INET_E_USE_DEFAULT_PROTOCOLHANDLER;
memset(&bindinfo, 0, sizeof(bindinfo));
bindinfo.cbSize = sizeof(BINDINFO);
hres = IInternetBindInfo_GetBindInfo(pOIBindInfo, &bindf, &bindinfo);
if(FAILED(hres)) {
WARN("GetBindInfo failed: %08x\n", hres);
return hres;
}
ReleaseBindInfo(&bindinfo);
len = strlenW(ptr)+3;
file_name = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
memcpy(file_name, ptr, len*sizeof(WCHAR));
hres = UrlUnescapeW(file_name, NULL, &len, URL_UNESCAPE_INPLACE);
if(FAILED(hres)) {
WARN("UrlUnescape failed: %08x\n", hres);
HeapFree(GetProcessHeap(), 0, file_name);
return hres;
}
p = strstrW(file_name, separator);
if(!p) {
WARN("invalid url\n");
HeapFree(GetProcessHeap(), 0, file_name);
return report_result(pOIProtSink, STG_E_FILENOTFOUND);
}
*p = 0;
chm_file = chm_openW(file_name);
if(!chm_file) {
WARN("Could not open chm file\n");
HeapFree(GetProcessHeap(), 0, file_name);
return report_result(pOIProtSink, STG_E_FILENOTFOUND);
}
object_name = p+2;
len = strlenW(object_name);
if(*object_name != '/' && *object_name != '\\') {
memmove(object_name+1, object_name, (len+1)*sizeof(WCHAR));
*object_name = '/';
len++;
}
if(object_name[len-1] == '/')
object_name[--len] = 0;
for(p=object_name; *p; p++) {
if(*p == '\\')
*p = '/';
}
remove_dot_segments(object_name);
TRACE("Resolving %s\n", debugstr_w(object_name));
memset(&chm_object, 0, sizeof(chm_object));
res = chm_resolve_object(chm_file, object_name, &chm_object);
if(res != CHM_RESOLVE_SUCCESS) {
WARN("Could not resolve chm object\n");
HeapFree(GetProcessHeap(), 0, file_name);
chm_close(chm_file);
return report_result(pOIProtSink, STG_E_FILENOTFOUND);
}
IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_SENDINGREQUEST,
strrchrW(object_name, '/')+1);
/* FIXME: Native doesn't use FindMimeFromData */
hres = FindMimeFromData(NULL, object_name, NULL, 0, NULL, 0, &mime, 0);
HeapFree(GetProcessHeap(), 0, file_name);
if(SUCCEEDED(hres)) {
IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_MIMETYPEAVAILABLE, mime);
CoTaskMemFree(mime);
}
release_chm(This); /* Native leaks handle here */
This->chm_file = chm_file;
This->chm_object = chm_object;
hres = IInternetProtocolSink_ReportData(pOIProtSink,
BSCF_FIRSTDATANOTIFICATION|BSCF_DATAFULLYAVAILABLE,
chm_object.length, chm_object.length);
if(FAILED(hres)) {
WARN("ReportData failed: %08x\n", hres);
release_chm(This);
return report_result(pOIProtSink, hres);
}
hres = IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_BEGINDOWNLOADDATA, NULL);
return report_result(pOIProtSink, hres);
}
static HRESULT WINAPI MkProtocol_StartEx(IInternetProtocolEx *iface, IUri *pUri,
IInternetProtocolSink *pOIProtSink, IInternetBindInfo *pOIBindInfo,
DWORD grfPI, HANDLE *dwReserved)
{
MkProtocol *This = impl_from_IInternetProtocolEx(iface);
LPWSTR mime, progid, display_name, colon_ptr;
DWORD bindf=0, eaten=0, scheme=0, len;
BSTR url, path = NULL;
IParseDisplayName *pdn;
BINDINFO bindinfo;
STATSTG statstg;
IMoniker *mon;
HRESULT hres;
CLSID clsid;
TRACE("(%p)->(%p %p %p %08x %p)\n", This, pUri, pOIProtSink,
pOIBindInfo, grfPI, dwReserved);
hres = IUri_GetScheme(pUri, &scheme);
if(FAILED(hres))
return hres;
if(scheme != URL_SCHEME_MK)
return INET_E_INVALID_URL;
memset(&bindinfo, 0, sizeof(bindinfo));
bindinfo.cbSize = sizeof(BINDINFO);
hres = IInternetBindInfo_GetBindInfo(pOIBindInfo, &bindf, &bindinfo);
if(FAILED(hres)) {
WARN("GetBindInfo failed: %08x\n", hres);
return hres;
}
ReleaseBindInfo(&bindinfo);
IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_SENDINGREQUEST, NULL);
hres = IUri_GetDisplayUri(pUri, &url);
if(FAILED(hres))
return hres;
hres = FindMimeFromData(NULL, url, NULL, 0, NULL, 0, &mime, 0);
SysFreeString(url);
if(SUCCEEDED(hres)) {
IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_MIMETYPEAVAILABLE, mime);
CoTaskMemFree(mime);
}
hres = IUri_GetPath(pUri, &path);
if(FAILED(hres))
return hres;
len = SysStringLen(path)+1;
hres = UrlUnescapeW(path, NULL, &len, URL_UNESCAPE_INPLACE);
if (FAILED(hres)) {
SysFreeString(path);
return report_result(pOIProtSink, INET_E_RESOURCE_NOT_FOUND, ERROR_INVALID_PARAMETER);
}
progid = path+1; /* skip '@' symbol */
colon_ptr = strchrW(path, ':');
if(!colon_ptr) {
SysFreeString(path);
return report_result(pOIProtSink, INET_E_RESOURCE_NOT_FOUND, ERROR_INVALID_PARAMETER);
}
len = strlenW(path);
display_name = heap_alloc((len+1)*sizeof(WCHAR));
memcpy(display_name, path, (len+1)*sizeof(WCHAR));
progid[colon_ptr-progid] = 0; /* overwrite ':' with NULL terminator */
hres = CLSIDFromProgID(progid, &clsid);
SysFreeString(path);
if(FAILED(hres))
{
heap_free(display_name);
return report_result(pOIProtSink, INET_E_RESOURCE_NOT_FOUND, ERROR_INVALID_PARAMETER);
}
hres = CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
&IID_IParseDisplayName, (void**)&pdn);
if(FAILED(hres)) {
WARN("Could not create object %s\n", debugstr_guid(&clsid));
heap_free(display_name);
return report_result(pOIProtSink, hres, ERROR_INVALID_PARAMETER);
}
hres = IParseDisplayName_ParseDisplayName(pdn, NULL /* FIXME */, display_name, &eaten, &mon);
heap_free(display_name);
IParseDisplayName_Release(pdn);
if(FAILED(hres)) {
WARN("ParseDisplayName failed: %08x\n", hres);
return report_result(pOIProtSink, hres, ERROR_INVALID_PARAMETER);
}
if(This->stream) {
IStream_Release(This->stream);
This->stream = NULL;
}
hres = IMoniker_BindToStorage(mon, NULL /* FIXME */, NULL, &IID_IStream, (void**)&This->stream);
IMoniker_Release(mon);
if(FAILED(hres)) {
WARN("BindToStorage failed: %08x\n", hres);
return report_result(pOIProtSink, hres, ERROR_INVALID_PARAMETER);
}
hres = IStream_Stat(This->stream, &statstg, STATFLAG_NONAME);
if(FAILED(hres)) {
WARN("Stat failed: %08x\n", hres);
return report_result(pOIProtSink, hres, ERROR_INVALID_PARAMETER);
}
IInternetProtocolSink_ReportData(pOIProtSink,
BSCF_FIRSTDATANOTIFICATION | BSCF_LASTDATANOTIFICATION,
statstg.cbSize.u.LowPart, statstg.cbSize.u.LowPart);
return report_result(pOIProtSink, S_OK, ERROR_SUCCESS);
}