Exemplo n.º 1
0
static void
goto_url_action(struct session *ses,
		unsigned char *(*get_url)(struct session *, unsigned char *, size_t))
{
	unsigned char url[MAX_STR_LEN];

	if (!get_url || !get_url(ses, url, sizeof(url)))
		url[0] = 0;

	dialog_goto_url(ses, url);
}
__attribute__ ((always_inline))  int GetC (int *c)  {

    A details_str;
    if (!get_url (&details_str))
      {
        incr ();
        return 1;
      }

    *c = get_time ();
    return -1;
  }
Exemplo n.º 3
0
static int w_dbquery_avps(struct sip_msg* msg, char* query,
													char* dest, char *url)
{
	struct db_url *parsed_url;

	if (get_url(msg, (struct db_url_container*)url, &parsed_url, 0) < 0) {
		LM_ERR("failed to get db url\n");
		return -1;
	}

	return ops_dbquery_avps ( msg, (pv_elem_t*)query,
		parsed_url, (pvname_list_t*)dest);
}
Exemplo n.º 4
0
static int w_async_dbquery_avps(struct sip_msg* msg, async_resume_module **rf,
		void **rparam, char* query, char* dest, char* url)
{
	struct db_url *parsed_url;

	if (get_url(msg, (struct db_url_container*)url, &parsed_url, 1) < 0) {
		LM_ERR("failed to get db url\n");
		return -1;
	}

	return ops_async_dbquery(msg, rf, rparam, (pv_elem_t *)query,
			parsed_url, (pvname_list_t *)dest);
}
Exemplo n.º 5
0
int main (int argc, const char * argv[])
{
    if (argc < 2) {
        usage();
        return 1;
    }

    std::string site_contents = get_url(argv[1]);
    
    write_file("wget.out", site_contents);
    
    return 0;
}
Exemplo n.º 6
0
Arquivo: cli.c Projeto: mkopec/4get
int main (int argc, char ** argv)
{
    CURL * myHandle;
    CURLcode success;
    struct string s;
    char * dest_dir;

    if (argc == 1) {
        printf("Usage: 4get [THREAD URL] [DESTINATION DIR]\n");
        return 0;
    }

    if (argc == 2) {
        dest_dir = "";
    } else {
        dest_dir = argv[2];
        if (dest_dir[strlen(dest_dir)-1] != '/') {
            strcat(dest_dir, "/");
        }
    }

    mkdir(argv[2], 0777);

    myHandle = curl_easy_init();
    init_string(&s);

    curl_easy_setopt(myHandle, CURLOPT_URL, argv[1]);
    curl_easy_setopt(myHandle, CURLOPT_WRITEFUNCTION, writefunc);
    curl_easy_setopt(myHandle, CURLOPT_WRITEDATA, &s);

    success = curl_easy_perform(myHandle);
    curl_easy_cleanup(myHandle);

    char prev_url[255];
    char url[255];
    int is_image;

    while ((s.ptr = strstr (s.ptr, "i.4cdn.org"))) {
        memset(&url[0], 0, sizeof(url));
        is_image = get_url(url, s.ptr);
        if (is_image && !strcmp(url, prev_url))
        get_image(url, dest_dir);

        strcpy(prev_url, url);
        s.ptr += 10;
    }


    free(s.ptr);
    return EXIT_SUCCESS;
}
Exemplo n.º 7
0
// https://wiki.london.hackspace.org.uk/view/Project:Tool_Access_Control/Solexious_Proposal#Get_card_permissions
int querycard(Card card)
{
  char path[11 + 10 + 14 + 1];
  int result = -100;
  sprintf(path, "/%d/card/", acsettings.nodeid);
  card.str(path + strlen(path));

  result = get_url(path);

  Serial.print("acserver said: ");
  Serial.println(result);

  return result;
}
Exemplo n.º 8
0
void process_cmd(int sockcnfd,char *cmd)
{
	char url[MAXSIZE]="./www";
	char buf[MAXSIZE];
	if(get_url(sockcnfd,cmd,url)!=-1){
		printf("get url is %s\n",url);
		if(is_noexit(url))
			send_404(sockcnfd);
		else if(is_dir(url))
			re_ls(sockcnfd,url);
		else
			re_file(sockcnfd,url);
	}
	close(sockcnfd);
}
Exemplo n.º 9
0
int main(int argc, char *argv[])
{
	int   ch;
	char  url[256], dump[256], proxy[256], method[32];
	/*
	const char *url1 = "http://127.0.0.1:80/";
	HTTP_UTIL *req = http_util_req_new(url1, "POST");
	printf(">>>host: %s\n", http_hdr_req_host(req->hdr_req));
	acl_assert(req);
	return (0);
	*/

	acl_init();  /* 初始化 acl 库 */

	ACL_SAFE_STRNCPY(method, "GET", sizeof(method));
	url[0] = 0;
	dump[0] = 0;
	proxy[0] = 0;
	while ((ch = getopt(argc, argv, "hr:t:f:X:")) > 0) {
		switch (ch) {
		case 'h':
			usage(argv[0]);
			return (0);
		case 'r':
			ACL_SAFE_STRNCPY(url, optarg, sizeof(url));
			break;
		case 't':
			ACL_SAFE_STRNCPY(method, optarg, sizeof(method));
			break;
		case 'f':
			ACL_SAFE_STRNCPY(dump, optarg, sizeof(dump));
			break;
		case 'X':
			ACL_SAFE_STRNCPY(proxy, optarg, sizeof(proxy));
			break;
		default:
			break;
		}
	}

	if (url[0] == 0) {
		usage(argv[0]);
		return (0);
	}

	get_url(method, url, proxy, dump);
	return (0);
}
/*----------------------------------------------------------------------*/
int main(int argc, char *argv[]){
	int rc;
	FILE *outfile;
	int index;
	char *outfilename=NULL;

	if(argc<2){
		ERROR1("Format: %s <http://server[:port]/path> [-o <outputfile>] [-u [email protected]] [-t max_time] [-i inter_time]",
			argv[0]);
	}

	/* parse args */
	for(index=1; index<argc; index++){
		if(strncmp(argv[index], "-t", 2)==0){
			max_time = atoi(argv[++index]);
		}
		else if(strncmp(argv[index], "-i", 2)==0){
			inter_time = atoi(argv[++index]);
		}
		else if(strncmp(argv[index], "-u", 2)==0){
			useraddr = argv[++index];
		}
		else if(strncmp(argv[index], "-o", 2)==0){
			outfilename = argv[++index];
		}
	}

	/* install the handler */
	signal(SIGALRM, alarm_handler);
	alarm(max_time);
	/* ### TO DO -- make it work okay with recursion */

	/* open the file */
	if(outfilename==NULL){
		outfile = stdout;
	}else{
		outfile = fopen(outfilename, "w");
		if(outfile==NULL){
			ERROR1("Cannot open outfile %s", argv[2]);
		}
	}

	rc = get_url(argv[1], outfile);

	if(rc<0){
		ERROR0("Cannot get page.");
	}
}
Exemplo n.º 11
0
/**
 * grl_net_wc_request_with_headers_hash_async:
 * @self: a #GrlNetWc instance
 * @uri: The URI of the resource to request
 * @headers: (allow-none) (element-type utf8 utf8): a set of additional HTTP
 * headers for this request or %NULL to ignore
 * @cancellable: (allow-none): a #GCancellable instance or %NULL to ignore
 * @callback: The callback when the result is ready
 * @user_data: User data set for the @callback
 *
 * Request the fetching of a web resource given the @uri. This request is
 * asynchronous, thus the result will be returned within the @callback.
 *
 * Since: 0.2.2
 * Rename to: grl_net_wc_request_with_headers_async
 */
void
grl_net_wc_request_with_headers_hash_async (GrlNetWc *self,
                                            const char *uri,
                                            GHashTable *headers,
                                            GCancellable *cancellable,
                                            GAsyncReadyCallback callback,
                                            gpointer user_data)
{
  GSimpleAsyncResult *result;

  result = g_simple_async_result_new (G_OBJECT (self),
                                      callback,
                                      user_data,
                                      grl_net_wc_request_async);

  get_url (self, uri, headers, G_ASYNC_RESULT (result), cancellable);
}
Exemplo n.º 12
0
 Promise fetch()
 {
   auto request = Http::Request::get(get_url());
   
   request->set_headers({{"Accept",Archive::mimetype}});
   return request->send().then([this, request]()
   {
     auto response = request->get_response();
     
     if (response->ok())
     {
       if (response->has_body())
         parse(response->get_response_text());
       synced.trigger();
     }
   });
 }
Exemplo n.º 13
0
static HRESULT get_url_components(HTMLLocation *This, URL_COMPONENTSW *url)
{
    const WCHAR *doc_url;
    HRESULT hres;

    hres = get_url(This, &doc_url);
    if(FAILED(hres))
        return hres;

    if(!InternetCrackUrlW(doc_url, 0, 0, url)) {
        FIXME("InternetCrackUrlW failed: 0x%08x\n", GetLastError());
        SetLastError(0);
        return E_FAIL;
    }

    return S_OK;
}
Exemplo n.º 14
0
void xeta::Curl::perform()
{
	static curlpp::easy handle;
	try {
		std::ofstream output( get_local_filename().c_str() );
		handle.url( get_url() );
		curlpp::ostream_trait o_trait( &output );
		handle.m_body_storage.trait( &o_trait );

		set_state( xeta::FileTransfer::Downloading );
		handle.perform();
		set_state( xeta::FileTransfer::Downloaded );
	}
	catch( curlpp::exception & e) 
	{
		set_error( e.what() );
	}

}
Exemplo n.º 15
0
std::string mesos_http::make_uri(const std::string& path)
{
	uri url = get_url();
	std::string target_uri = url.get_scheme();
	target_uri.append("://");
	std::string user = url.get_user();
	if(!user.empty())
	{
		target_uri.append(user).append(1, ':').append(url.get_password()).append(1, '@');
	}
	target_uri.append(url.get_host());
	int port = url.get_port();
	if(port)
	{
		target_uri.append(1, ':').append(std::to_string(port));
	}
	target_uri.append(path);
	return target_uri;
}
Exemplo n.º 16
0
static gboolean
favicon_web_done_idle_cb (gpointer vfav)
{
    GdkPixbuf * pixbuf = NULL;
    gboolean finished = FALSE;
    struct favicon_data * fav = vfav;

    if (fav->len > 0) /* we got something... try to make a pixbuf from it */
    {
        favicon_save_to_cache (fav->host, fav->contents, fav->len);
        pixbuf = favicon_load_from_cache (fav->host);
        finished = pixbuf != NULL;
    }

    if (!finished) /* no pixbuf yet... */
    {
        if (++fav->type == IMAGE_TYPES) /* failure */
        {
            finished = TRUE;
        }
        else /* keep trying */
        {
            char * url = get_url (fav->host, fav->type);

            g_free (fav->contents);
            fav->contents = NULL;
            fav->len = 0;

            tr_webRun (fav->session, url, NULL, NULL, favicon_web_done_cb, fav);
            g_free (url);
        }
    }

    if (finished)
    {
        fav->func (pixbuf, fav->data);
        g_free (fav->host);
        g_free (fav->contents);
        g_free (fav);
    }

    return FALSE;
}
Exemplo n.º 17
0
int Get_MultiTask::svc ()
{
  ACE_DEBUG ((LM_INFO, ACE_TEXT ("(%P|%t) multitask started\n")));

  ACE::HTTP::URL http_url;
  const char* url = get_url ();

  ACE_DEBUG ((LM_INFO, ACE_TEXT ("(%P|%t) parsing URL %C\n"), url));

  if (http_url.parse (url))
    {
      ACE::HTTP::ClientRequestHandler rh;
      http_url.open (rh);
      if (rh.response_stream ())
          ACE_DEBUG ((LM_INFO, ACE_TEXT ("(%P|%t) opened URL %C\n"), http_url.to_string ().c_str ()));
      else
          ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) failed to open URL %C\n"), http_url.to_string ().c_str ()));
      wait_for_all ();
      if (rh.response_stream ())
        {
          ACE::IOS::CString_OStream sos;
          sos << rh.response_stream ().rdbuf ();
          ACE_DEBUG ((LM_INFO, ACE_TEXT ("(%P|%t) result downloaded\n")));
          if (!sos.bad ())
            {
              ACE_GUARD_RETURN (ACE_SYNCH_MUTEX,
                                guard_,
                                lock_,
                                0);
              ACE_DEBUG ((LM_INFO, ACE_TEXT ("(%P|%t) marking result\n")));
              --n_fails_;
            }
        }
      shutdown ();
    }

  ACE_DEBUG ((LM_INFO, ACE_TEXT ("(%P|%t) task finished\n")));

  return 0;
}
Exemplo n.º 18
0
static gboolean
builder_source_git_download (BuilderSource *source,
                             gboolean update_vcs,
                             BuilderContext *context,
                             GError **error)
{
  BuilderSourceGit *self = BUILDER_SOURCE_GIT (source);
  g_autofree char *url = NULL;

  url = get_url (self, context, error);
  if (url == NULL)
    return FALSE;

  if (!git_mirror_repo (url,
                        update_vcs,
                        get_branch (self),
                        context,
                        error))
    return FALSE;

  return TRUE;
}
Exemplo n.º 19
0
static void *url_worker(void *arg){
    url_data *data = arg;
    buf_data *bdata = malloc(sizeof(buf_data));
    bdata->offset = 0;
    bdata->size = 0;
    bdata->buf = NULL;
    bdata->postData = data->postData;

    data->data = bdata;

    if(data->httpType == CURL_HTTP_GET){
        //printf("%s\n", data->url);
        data->npcode = get_url(data->url, bdata, g_hash_table_lookup(g_FRManager.hash_table, data->instance));
    }else{
        data->npcode = post_url(data->url, bdata, g_hash_table_lookup(g_FRManager.hash_table, data->instance));
    }

    //TODO
    gdk_threads_add_idle(stream_write, arg);

    return NULL;
}
Exemplo n.º 20
0
BOOL install_wine_gecko(void)
{
    if(!*ARCH_STRING)
        return FALSE;

    /*
     * Try to find Gecko .cab file in following order:
     * - directory stored in GeckoCabDir value of HKCU/Wine/Software/MSHTML key
     * - $datadir/gecko/
     * - $INSTALL_DATADIR/wine/gecko/
     * - /usr/share/wine/gecko/
     * - download from URL stored in GeckoUrl value of HKCU/Wine/Software/MSHTML key
     */
    if(!install_from_registered_dir()
            && !install_from_default_dir()
            && (url = get_url()))
        DialogBoxW(hInst, MAKEINTRESOURCEW(ID_DWL_DIALOG), 0, installer_proc);

    heap_free(url);
    url = NULL;
    return TRUE;
}
Exemplo n.º 21
0
static gboolean
builder_source_git_extract (BuilderSource *source,
                            GFile *dest,
                            BuilderContext *context,
                            GError **error)
{
  BuilderSourceGit *self = BUILDER_SOURCE_GIT (source);
  g_autoptr(GFile) mirror_dir = NULL;
  g_autofree char *mirror_dir_path = NULL;
  g_autofree char *dest_path = NULL;
  g_autofree char *url = NULL;

  url = get_url (self, context, error);
  if (url == NULL)
    return FALSE;

  mirror_dir = git_get_mirror_dir (url, context);

  mirror_dir_path = g_file_get_path (mirror_dir);
  dest_path = g_file_get_path (dest);

  if (!git (NULL, NULL, error,
            "clone", mirror_dir_path, dest_path, NULL))
    return FALSE;

  if (!git (dest, NULL, error,
            "checkout", get_branch (self), NULL))
    return FALSE;

  if (!git_extract_submodule (url, dest, context, error))
    return FALSE;

  if (!git (dest, NULL, error,
            "config", "--local", "remote.origin.url", url, NULL))
    return FALSE;

  return TRUE;
}
Exemplo n.º 22
0
pfc::string8 get_track_info(const metadb_handle_ptr track, abort_callback &p_abort) {
	pfc::string8 api_key = "803d3cbea0bbe50c61ab81c4fe5fe20f";
	pfc::string8 url, page, artist_enc, title_enc;
	const file_info *file_info;
	const char *artist;
	const char *title;
	bool meta;

	static_api_ptr_t<metadb> db;
	db->database_lock();
	meta = track->get_info_async_locked(file_info);
	db->database_unlock();

	if (meta && file_info->meta_exists("artist") &&
	    file_info->meta_exists("title")) {
		artist = file_info->meta_get("artist", 0);
		title  = file_info->meta_get("title",  0);
	} else {
		throw pfc::exception("Unknown track");
	}

	pfc::urlEncode(artist_enc, artist);
	pfc::urlEncode(title_enc, title);

	url << "http://ws.audioscrobbler.com/2.0/?method=track.getInfo"
	    << "&api_key=" << api_key << "&artist=" << artist_enc << "&track=" << title_enc;

	console::print(url);

	page = get_url(url, p_abort);

	if (page.get_length() < 10) {
		throw pfc::exception("Last.fm returned an empty page");
	}

	return page;
}
Exemplo n.º 23
0
BOOL install_addon(addon_t addon_type)
{
    if(!*ARCH_STRING)
        return FALSE;

    addon = addons_info+addon_type;

    /*
     * Try to find addon .msi file in following order:
     * - directory stored in $dir_config_key value of HKCU/Wine/Software/$config_key key
     * - $datadir/$addon_subdir/
     * - $INSTALL_DATADIR/wine/$addon_subdir/
     * - /usr/share/wine/$addon_subdir/
     * - download from URL stored in $url_config_key value of HKCU/Wine/Software/$config_key key
     */
    if(!install_from_registered_dir()
       && !install_from_default_dir()
       && (url = get_url()))
        DialogBoxW(hInst, MAKEINTRESOURCEW(ID_DWL_DIALOG), 0, installer_proc);

    heap_free(url);
    url = NULL;
    return TRUE;
}
		TITANIUM_PROPERTY_GETTER(WebView, url)
		{
			return get_context().CreateString(get_url());
		}
Exemplo n.º 25
0
void k8s_event_handler::handle_json(Json::Value&& root)
{
	/*if(g_logger.get_severity() >= sinsp_logger::SEV_TRACE)
	{
		g_logger.log(json_as_string(root), sinsp_logger::SEV_TRACE);
	}*/

	if(!m_state)
	{
		throw sinsp_exception("k8s_handler (" + get_id() + "), state is null for " + get_url() + ").");
	}
	const Json::Value& type = root["type"];
	if(!type.isNull())
	{
		if(type.isConvertibleTo(Json::stringValue))
		{
			const Json::Value& kind = root["kind"];
			if(!kind.isNull())
			{
				if(kind.isConvertibleTo(Json::stringValue))
				{
					std::string t = type.asString();
					std::string k = kind.asString();
					for(const Json::Value& item : root["items"])
					{
						msg_data data = get_msg_data(t, k, item);
						std::string reason_type = data.get_reason_desc();
						if(data.m_reason != k8s_component::COMPONENT_ADDED &&
							data.m_reason != k8s_component::COMPONENT_MODIFIED &&
							data.m_reason != k8s_component::COMPONENT_DELETED &&
							data.m_reason != k8s_component::COMPONENT_ERROR)
						{
							g_logger.log(std::string("Unsupported K8S " + name() + " event reason: ") +
										 std::to_string(data.m_reason), sinsp_logger::SEV_ERROR);
							continue;
						}
						/*if(g_logger.get_severity() >= sinsp_logger::SEV_TRACE)
						{
							g_logger.log("K8s handling event:\n" + json_as_string(item), sinsp_logger::SEV_TRACE);
						}*/
						if(handle_component(item, &data))
						{
							std::ostringstream os;
							os << "K8s [" + reason_type + ", " << data.m_kind <<
								", " << data.m_name << ", " << data.m_uid << "]";
							g_logger.log(os.str(), sinsp_logger::SEV_INFO);
						}
						else if(!m_event_ignored)
						{
							g_logger.log("K8s: error occurred while handling " + reason_type +
										 " event for " + data.m_kind + ' ' + data.m_name + " [" +
										 data.m_uid + ']', sinsp_logger::SEV_ERROR);
						}
						m_event_ignored = false;
					} // end for items
				}
			}
		}
		else
		{
			g_logger.log(std::string("K8S event type is not string."), sinsp_logger::SEV_ERROR);
		}
	}
	else
	{
		g_logger.log(std::string("K8S event type is null."), sinsp_logger::SEV_ERROR);
	}
}
int feed_main(match_data **feed_matches, int *feed_matches_counter) {
	omnibet_match_data omnibet_match;
	GSList *cookies;
	char tmp_file[1024];
	char tmp_file2[1024];
	char tmp_file3[1024];

	memset(&omnibet_match.match_time[0], '\0', sizeof(omnibet_match.match_time));
	memset(&omnibet_match.team_home[0], '\0', sizeof(omnibet_match.team_home));
	memset(&omnibet_match.team_away[0], '\0', sizeof(omnibet_match.team_away));
	omnibet_match.score_home = 0;
	omnibet_match.score_away = 0;
	omnibet_match.stage = -1;
	omnibet_match.skip = FALSE;

	struct passwd *pw = getpwuid(getuid());
	snprintf(&tmp_file[0], sizeof(tmp_file), "%s-%u", OMNIBET_FILENAME, pw->pw_uid);
	snprintf(&tmp_file2[0], sizeof(tmp_file), "%s-%u-a", OMNIBET_FILENAME, pw->pw_uid);

	// Get our cookie from main page
	if (get_url(OMNIBET_URL1, OMNIBET_USER_AGENT, &tmp_file[0], NULL, &cookies))
		return 1;

	// Fetch actual page
	if (get_url(OMNIBET_URL2, OMNIBET_USER_AGENT, &tmp_file[0], cookies, NULL)) {
		if (cookies)
			soup_cookies_free(cookies);
		return 1;
	}

	if (cookies)
		soup_cookies_free(cookies);

	char *orig_xml = omnibet_load_file(&tmp_file[0]);
	if (!orig_xml)
		return 0;
	
	char *fixed_xml2 = omnibet_replace(orig_xml, "<strong>", "<strong custom=livescore>");
	if (!fixed_xml2)
		return 0;

	FILE *fp = fopen (&tmp_file2[0], "w");
	if (!fp) {
		printf("Cannot open output file!\n");
		return 0;
	}
	fprintf(fp, "%s\n", fixed_xml2);
	fclose(fp);

	htmlDocPtr parser = htmlReadFile(&tmp_file2[0], OMNIBET_CHARSET, 
		HTML_PARSE_RECOVER |
		//HTML_PARSE_NOBLANKS | 
		HTML_PARSE_NOERROR | 
		HTML_PARSE_NOWARNING |
#ifdef HAVE_MATE
		HTML_PARSE_NOIMPLIED | 
#endif
		HTML_PARSE_COMPACT);

	omnibet_walk_tree(xmlDocGetRootElement(parser), &omnibet_match, feed_matches, feed_matches_counter);

	xmlFreeDoc(parser);
	free(orig_xml);
	free(fixed_xml2);

	return 1;
}
Exemplo n.º 27
0
int proxy_server()
{
    int rx_bytes = 0, post_data_size = 0;
    int lsock = 0, csock = 0, client_data_size = 0;
    int result_size = 0, err_code = 0, id = 0;
    int addrlen = sizeof(struct sockaddr_in);
    struct sockaddr_in clientaddr;
    char *buffer = NULL, *post_data = NULL;
    char *host = NULL, *url = NULL;
    char *query = NULL, *fifo_file = NULL;
    char *get_data = NULL;
    char *client_data = NULL, *headers = NULL;
    char *server_ip = NULL;

    memset((void *) &clientaddr,0,addrlen);

    server_ip = config_get_server_ip();

    /* Create TCP socket */
    if((lsock = create_socket(server_ip,PROXY_PORT,SOCK_STREAM)) == SOCK_FAIL) {
        glog("Failed to create TCP socket for proxy server",LOG_ERROR_TYPE);
        if(server_ip) free(server_ip);
        return EXIT_FAILURE;
    }
    if(server_ip) free(server_ip);

    /* Infinite receive loop */
    while(1) {

        /* Accept incoming connection */
        if((csock = accept(lsock,(struct sockaddr *) &clientaddr,(socklen_t *) &addrlen)) < 0) {
            glog("Failed to accept TCP connection to proxy server",LOG_ERROR_TYPE);
            if(buffer) free(buffer);
            return EXIT_FAILURE;
        }

        if(!fork()) {
            /* Receive client request */
            if((buffer = receive(lsock,SOCK_STREAM,&rx_bytes,csock,&clientaddr)) == NULL) {
                glog("Failed to read data from client request sent to proxy server",LOG_ERROR_TYPE);
                exit(EXIT_FAILURE);
            }

            if(is_using_proxy(buffer)) {

                /* Get the target's IP address */
                host = get_host_name(buffer);

                /* Get the target URL path */
                url = get_url(buffer);

                /* Get POST data, if any */
                post_data = get_post_data(buffer,rx_bytes,&post_data_size);

                /* Get HTTP headers from request */
                headers = get_headers(buffer);

                /* If the CONSOLE_HOST is requested, then display the Web console interface */
                if(memcmp(host,CONSOLE_HOST,CONSOLE_HOST_SIZE) == 0) {
                    show_web_ui(csock,url);
                    close_socket(csock);
                } else {

                    /* Make sure the requested host is in our clients list */
                    query = sqlite3_mprintf("SELECT id FROM %s WHERE strftime('%%s',callback_time) >= strftime('%%s','now') AND ip = %Q LIMIT 1",CLIENTS_TABLE,host);
                    sql_exec(query,&result_size,&err_code);
                    sqlite3_free(query);

                    if(result_size > 0) {
                        /* Don't allow requests for filtered file extensions */
                        if(!is_url_filtered(url)) {

                            fifo_file = create_fifo(host);
                            if(!fifo_file) {
                                glog("Failed to create fifo file",LOG_ERROR_TYPE);
                            } else {
                                /* Insert query into queue table */
                                query = sqlite3_mprintf("INSERT INTO %s (fifo,host,url,headers,pdata,sent) VALUES (%Q,%Q,%Q,%Q,%Q,0)",QUEUE_TABLE,fifo_file,host,url,headers,post_data);
                                sql_exec(query,&result_size,&err_code);
                                sqlite3_free(query);
                                if(err_code != SQLITE_OK) {
                                    sql_log_error();
                                } else {

                                    /* When the client data has returned, the callback server will write the ID of the callback to the FIFO */
                                    id = read_from_fifo(fifo_file);

                                    /* Extract the data from the DB */
                                    get_data = sqlite3_mprintf("SELECT rdata FROM %s WHERE id = '%d'",QUEUE_TABLE,id);
                                    client_data = sql_exec(get_data,&client_data_size,&err_code);
                                    sqlite3_free(get_data);

                                    if(err_code != SQLITE_OK) {
                                        sql_log_error();
                                    } else {

                                        /* Write data to socket */
                                        if(write(csock,client_data,client_data_size) != client_data_size) {
                                            glog("Proxy socket write failed",LOG_ERROR_TYPE);
                                        }
                                    }
                                    if(client_data) free(client_data);

                                    /* Make sure the fifo gets deleted */
                                    destroy_fifo(fifo_file);
                                }
                            }
                        }
                    }
                }
            }

            /* Exit the child process */
            close_socket(csock);
            if(fifo_file) free(fifo_file);
            if(buffer) free(buffer);
            if(host) free(host);
            if(url) free(url);
            if(post_data) free(post_data);
            if(headers) free(headers);
            exit(EXIT_SUCCESS);
        }
    }

    /* Close up shop */
    close_socket(csock);
    close_socket(lsock);

    return EXIT_FAILURE;
}
Exemplo n.º 28
0
static void
get_url (const char *url)
{
	const char *name;
	SoupMessage *msg;
	const char *header;
	FILE *output_file = NULL;

	msg = soup_message_new (head ? "HEAD" : "GET", url);
	soup_message_set_flags (msg, SOUP_MESSAGE_NO_REDIRECT);

	if (loop) {
		g_object_ref (msg);
		soup_session_queue_message (session, msg, finished, loop);
		g_main_loop_run (loop);
	} else
		soup_session_send_message (session, msg);

	name = soup_message_get_uri (msg)->path;

	if (!debug) {
		if (msg->status_code == SOUP_STATUS_SSL_FAILED) {
			GTlsCertificateFlags flags;

			if (soup_message_get_https_status (msg, NULL, &flags))
				g_print ("%s: %d %s (0x%x)\n", name, msg->status_code, msg->reason_phrase, flags);
			else
				g_print ("%s: %d %s (no handshake status)\n", name, msg->status_code, msg->reason_phrase);
		} else if (!quiet || SOUP_STATUS_IS_TRANSPORT_ERROR (msg->status_code))
			g_print ("%s: %d %s\n", name, msg->status_code, msg->reason_phrase);
	}

	if (SOUP_STATUS_IS_REDIRECTION (msg->status_code)) {
		header = soup_message_headers_get_one (msg->response_headers,
						       "Location");
		if (header) {
			SoupURI *uri;
			char *uri_string;

			if (!debug && !quiet)
				g_print ("  -> %s\n", header);

			uri = soup_uri_new_with_base (soup_message_get_uri (msg), header);
			uri_string = soup_uri_to_string (uri, FALSE);
			get_url (uri_string);
			g_free (uri_string);
			soup_uri_free (uri);
		}
	} else if (!head && SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {
		if (output_file_path) {
			output_file = fopen (output_file_path, "w");
			if (!output_file)
				g_printerr ("Error trying to create file %s.\n", output_file_path);
		} else if (!quiet)
			output_file = stdout;

		if (output_file) {
			fwrite (msg->response_body->data,
				1,
				msg->response_body->length,
				output_file);

			if (output_file_path)
				fclose (output_file);
		}
	}
}
Exemplo n.º 29
0
int
main (int argc, char **argv)
{
	GOptionContext *opts;
	const char *url;
	SoupURI *proxy_uri, *parsed;
	GError *error = NULL;
	SoupLogger *logger = NULL;

	opts = g_option_context_new (NULL);
	g_option_context_add_main_entries (opts, entries, NULL);
	if (!g_option_context_parse (opts, &argc, &argv, &error)) {
		g_printerr ("Could not parse arguments: %s\n",
			    error->message);
		g_printerr ("%s",
			    g_option_context_get_help (opts, TRUE, NULL));
		exit (1);
	}

	if (argc != 2) {
		g_printerr ("%s",
			    g_option_context_get_help (opts, TRUE, NULL));
		exit (1);
	}
	g_option_context_free (opts);

	url = argv[1];
	parsed = soup_uri_new (url);
	if (!parsed) {
		g_printerr ("Could not parse '%s' as a URL\n", url);
		exit (1);
	}
	soup_uri_free (parsed);

	session = g_object_new (SOUP_TYPE_SESSION,
				SOUP_SESSION_SSL_CA_FILE, ca_file,
				SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_CONTENT_DECODER,
				SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_COOKIE_JAR,
				SOUP_SESSION_USER_AGENT, "get ",
				SOUP_SESSION_ACCEPT_LANGUAGE_AUTO, TRUE,
				NULL);
	if (ntlm)
		soup_session_add_feature_by_type (session, SOUP_TYPE_AUTH_NTLM);

	if (debug) {
		logger = soup_logger_new (SOUP_LOGGER_LOG_BODY, -1);
		soup_session_add_feature (session, SOUP_SESSION_FEATURE (logger));
		g_object_unref (logger);
	}

	if (proxy) {
		proxy_uri = soup_uri_new (proxy);
		if (!proxy_uri) {
			g_printerr ("Could not parse '%s' as URI\n",
				    proxy);
			exit (1);
		}

		g_object_set (G_OBJECT (session),
			      SOUP_SESSION_PROXY_URI, proxy_uri,
			      NULL);
		soup_uri_free (proxy_uri);
	}

	if (!synchronous)
		loop = g_main_loop_new (NULL, TRUE);

	get_url (url);

	if (!synchronous)
		g_main_loop_unref (loop);

	return 0;
}
Exemplo n.º 30
0
int main(int argc, char * argv[])
{
	if (argc == 3) {

		//check if 1st arg is file
		if (!IsFile(argv[1])) {
			fprintf(stderr, "ERROR: Sorry, %s is not a file.", argv[1]);
			return 1;
		}
		//check if 2nd arg is directory
		if (!IsDir(argv[2])) {
			fprintf(stderr, "ERROR: Sorry, %s is not a directory.", argv[2]);
			return 1;
		}

		// make indexer
		HashTable * index = ReadFile(argv[1]);
		if (index == NULL){
			return 1;
		}

		char buffer[QUERY_MAX];

		printf("QUERY>: ");
		while( fgets(buffer, QUERY_MAX , stdin) != NULL ) /* break with ^D or ^Z */
		{ 
			WordNode * search_results = processQuery(buffer, index);

			if (!search_results) {
				// an error that must exit. 
				return 1;
			}
			if (search_results->head == NULL) {
				printf("No results found.");
			
			} else {
				// order by frequency, mergesort returns the head (top-ranking url) of search_results
				DocNode * doc = mergesort(search_results->head);
				//set the search_results head to the doc, for freeing purposes. 
				search_results->head = doc; 
				// go through every doc node
				while ( doc!= NULL){
					char * docName = (char *)calloc(5,sizeof(char)); //assuming
					int ret = snprintf(docName, 5, "%d", doc->docID);
					if (ret == -1){
						fprintf(stderr, "WOW you have tons of files. I cannot handle this. Sorry \n");
						free(docName);
						continue;
					}

					char * url = get_url(docName, argv[2]);
					if (!url){
						fprintf(stderr, "Getting the url of doc %s failed. \n", docName);
						continue;
					}

					printf("Document ID: %d URL: %s", doc->docID, url);
					free(url);
					free(docName);

					doc = doc->next;
				}

			}

			//next iteration
			printf("\nQUERY>: ");
			free_list(search_results);
		}

		printf("done");

		free_table(index);
		return 0;

	} else {

		fprintf(stderr,"ERROR: Sorry, you entered in an incorrect number of input arguments. You must have 2 (index filename to read from, directory of html files)");
		return 1;
	}
}