NS_IMETHODIMP
nsChromeProtocolHandler::NewURI(const nsACString &aSpec,
const char *aCharset,
nsIURI *aBaseURI,
nsIURI **result)
{
nsresult rv;
// Chrome: URLs (currently) have no additional structure beyond that provided
// by standard URLs, so there is no "outer" given to CreateInstance
nsCOMPtr<nsIStandardURL> surl(do_CreateInstance(NS_STANDARDURL_CONTRACTID, &rv));
NS_ENSURE_SUCCESS(rv, rv);
rv = surl->Init(nsIStandardURL::URLTYPE_STANDARD, -1, aSpec, aCharset, aBaseURI);
if (NS_FAILED(rv))
return rv;
nsCOMPtr<nsIURL> url(do_QueryInterface(surl, &rv));
NS_ENSURE_SUCCESS(rv, rv);
// Canonify the "chrome:" URL; e.g., so that we collapse
// "chrome://navigator/content/" and "chrome://navigator/content"
// and "chrome://navigator/content/navigator.xul".
rv = nsChromeRegistry::Canonify(url);
if (NS_FAILED(rv))
return rv;
surl->SetMutable(false);
NS_ADDREF(*result = url);
return NS_OK;
}
void Http::findAllUrl(const char* str, std::unordered_set<std::string>& visitedUrl) {
if (str == NULL) {
return;
}
const char* tag = "href=\"";
const char* pos = strstr(str, tag);
size_t tagsize = strlen(tag);
while (pos) {
pos += tagsize;
if (pos == NULL) {
std::cout << "NULL" << std::endl;
break;
}
const char* next = strstr(pos, "\"");
if (next) {
char* url = new char[next - pos + 1];
memset(url, 0, next - pos + 1);
memcpy(url, pos, next - pos);
strlwr(url);
std::string surl(url);
addUrl(surl, visitedUrl);
delete[] url;
}
pos = strstr(pos, tag);
}
}
int file_request(
void *cls,
struct MHD_Connection *connection,
const char *url,
const char *method,
const char *version,
const char *upload_data,
size_t *upload_data_size,
void **con_cls)
{
static int aptr;
struct MHD_Response *response;
int ret;
FILE *file;
struct stat buf;
if (0 != strcmp(method, MHD_HTTP_METHOD_GET)) {
return MHD_NO; /* unexpected method */
}
if (&aptr != *con_cls) {
/* do never respond on first call */
*con_cls = &aptr;
return MHD_YES;
}
*con_cls = NULL; /* reset when done */
std::string surl(&url[1]);
const char* filepath = (path + surl).c_str();
if (0 == stat(filepath, &buf)) {
file = fopen(filepath, "rb");
} else {
file = NULL;
}
if (file == NULL) {
response = MHD_create_response_from_buffer(strlen(filepath),
(void *)filepath,
MHD_RESPMEM_PERSISTENT);
ret = MHD_queue_response(connection, MHD_HTTP_NOT_FOUND, response);
MHD_destroy_response(response);
} else {
/* 32k page size */
response = MHD_create_response_from_callback(
buf.st_size,
32 * 1024,
&file_reader,
file,
&free_callback);
if (response == NULL) {
fclose(file);
return MHD_NO;
}
ret = MHD_queue_response(connection, MHD_HTTP_OK, response);
MHD_destroy_response(response);
}
return ret;
}
NS_IMETHODIMP
AppProtocolHandler::NewURI(const nsACString &aSpec,
const char *aCharset, // ignore charset info
nsIURI *aBaseURI,
nsIURI **result)
{
nsresult rv;
nsCOMPtr<nsIStandardURL> surl(do_CreateInstance(NS_STANDARDURL_CONTRACTID, &rv));
NS_ENSURE_SUCCESS(rv, rv);
rv = surl->Init(nsIStandardURL::URLTYPE_STANDARD, -1, aSpec, aCharset, aBaseURI);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIURL> url(do_QueryInterface(surl, &rv));
NS_ENSURE_SUCCESS(rv, rv);
url.forget(result);
return NS_OK;
}
void storm::BolStatusRequest::loadFromDB(struct srm_dbfd* db){
srmlogit(STORM_LOG_DEBUG, "storm::BolStatusRequest::loadFromDB", "R_token: %s\n", m_requestToken.c_str());
std::string query("");
if(m_surls.size() > 0)
{
query += "SELECT r.client_dn, r.status, r.errstring, r.remainingTotalTime, "
" c.sourceSURL , s.fileSize , s.estimatedWaitTime , "
" s.remainingPinTime , s.statusCode , s.explanation"
" FROM request_queue r JOIN (request_BoL c, status_BoL s) ON "
"(c.request_queueID=r.ID AND s.request_BoLID=c.ID) "
"WHERE r.r_token=" + sqlFormat(m_requestToken) + " and c.sourceSURL in (";
bool first = true;
std::set<SurlPtr>::const_iterator const vectorEnd = m_surls.end();
for (std::set<SurlPtr>::const_iterator i = m_surls.begin(); i != vectorEnd; ++i) {
Surl* current = i->get();
if(first)
{
first = false;
}
else
{
query += " , ";
}
query += sqlFormat(current->getSurl());
}
query += ")";
}
else
{
query += "SELECT r.client_dn, r.status, r.errstring, r.remainingTotalTime, "
" c.sourceSURL , s.fileSize , s.estimatedWaitTime , "
" s.remainingPinTime , s.statusCode , s.explanation"
" FROM request_queue r JOIN (request_BoL c, status_BoL s) ON "
"(c.request_queueID=r.ID AND s.request_BoLID=c.ID) "
"WHERE r.r_token=" + sqlFormat(m_requestToken);
}
file_status_results_t results;
storm_db::vector_exec_query(db, query, results);
if (results.size() == 0)
{
if(m_surls.size() > 0)
{
srmlogit(STORM_LOG_INFO, "storm::BolStatusRequest::loadFromDB()",
"No tokens found for token %s and the requested SURLs\n", m_requestToken.c_str());
throw storm::token_not_found("No request found for token " + m_requestToken + " and the requested SURLs\n");
}
else
{
srmlogit(STORM_LOG_INFO, "storm::BolStatusRequest::loadFromDB()",
"No tokens found for token %s\n", m_requestToken.c_str());
throw storm::token_not_found("No request found for token " + m_requestToken + "\n");
}
}
fillCommonFields(results);
std::vector<file_status_result_t>::const_iterator const vectorEnd = results.end();
for (std::vector<file_status_result_t>::const_iterator i = results.begin(); i != vectorEnd; ++i) {
file_status_result_t currentResutl = *i;
storm::Surl surl(currentResutl["sourceSURL"].c_str());
BolTurl* turl;
if(currentResutl["fileSize"].empty())
{
turl = new BolTurl(surl);
}
else
{
turl = new BolTurl(surl, strtoull(currentResutl["fileSize"].c_str(),(char**)NULL,10));
}
if(currentResutl["statusCode"].empty())
{
srmlogit(STORM_LOG_ERROR, "storm::BolStatusRequest::loadFromDB()",
"Error,status code for SURL %s is empty. Continuing without filling SURLs informations.\n", currentResutl["targetSURL"].c_str());
delete turl;
continue;
}
turl->setStatus(static_cast<ns1__TStatusCode>(atoi(currentResutl["statusCode"].c_str())));
turl->setExplanation(currentResutl["explanation"]);
if(!currentResutl["estimatedWaitTime"].empty())
{
turl->setEstimatedWaitTime(atoi(currentResutl["estimatedWaitTime"].c_str()));
}
if(!currentResutl["remainingPinTime"].empty())
{
turl->setRemainingPinLifetime(atoi(currentResutl["remainingPinTime"].c_str()));
}
m_turls.insert(TurlPtr(turl));
}
}
void openFile(std::string path)
{
bool isAbs = true;
QString surl("file://");
#if defined(Q_OS_WIN)
/* check that it is an absolute path */
if (path.size() < 4)
{
std::cerr << "[WIN] openPath() Very Small path ignoring: " << path;
std::cerr << std::endl;
return;
}
if ((path[1] == ':') && ((path[2] == '\\') || (path[2] == '/')))
{
isAbs = true;
}
#else
/* check that it is an absolute path */
if (path.size() < 1)
{
std::cerr << "[UNIX] openPath() Very Small path ignoring: " << path;
std::cerr << std::endl;
return;
}
if (path[0] == '/')
{
isAbs = true;
}
#endif
if (!isAbs)
{
#define ROOT_PATH_SIZE 1024
char rootdir[ROOT_PATH_SIZE];
if (NULL == getcwd(rootdir, ROOT_PATH_SIZE))
{
std::cerr << "openPath() get Abs Failed: " << path;
std::cerr << std::endl;
return;
}
std::string rdir(rootdir);
surl += QString::fromStdString(rdir);
surl += '/';
}
surl += QString::fromStdString(path);
std::cerr << "openPath() opening AbsPath Url: " << surl.toStdString();
std::cerr << std::endl;
QUrl url(surl);
QDesktopServices::openUrl(url);
return;
}
