trunk/src/gcvote.c

/*
 * This file is part of GPXView.
 *
 * GPXView is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * GPXView is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with GPXView.  If not, see <http://www.gnu.org/licenses/>.
 */


/* curl command line example:
  curl -d version=2.0b -duserName=uglyDUMMYusernamesolution -d cacheIds=4e68a04e-161c-4351-9813-bec6f6a4ca8a -d password= http://dosensuche.de/GCVote/getVotes.php
*/

#include <curl/curl.h>
#include <curl/types.h>
#include <curl/easy.h>

#include <libxml/parser.h>
#include <libxml/tree.h>

#ifndef LIBXML_TREE_ENABLED
#error "Tree not enabled in libxml"
#endif

#include "gpxview.h"

#define ID_PATTERN  "guid="

typedef struct {
  char *ptr;
  int len;
} curl_mem_t;

static size_t mem_write(void *ptr, size_t size, size_t nmemb,
                        void *stream) {
  curl_mem_t *p = (curl_mem_t*)stream;

  p->ptr = g_realloc(p->ptr, p->len + size*nmemb + 1);
  if(p->ptr) {
    memcpy(p->ptr+p->len, ptr, size*nmemb);
    p->len += size*nmemb;
    p->ptr[p->len] = 0;
  }
  return nmemb;
}

#if 0
#define PROXY_KEY  "/system/http_proxy/"

typedef struct {
  char *authentication_password, *authentication_user;
  char *host;
  char *ignore_hosts;
  gint port;
  gboolean use_authentication;
} proxy_t;

void net_io_set_proxy(CURL *curl, proxy_t *proxy) {
 /* ------ overwrite with settings from gconf if present ------- */
  GConfClient *client = gconf_client_get_default();

  /* ------------- get proxy settings -------------------- */
  if(gconf_client_get_bool(client, PROXY_KEY "use_http_proxy", NULL)) {
    proxy_t *proxy = settings->proxy = g_new0(proxy_t, 1);
    
    /* get basic settings */
    proxy->host = gconf_client_get_string(client, PROXY_KEY "host", NULL);
    proxy->port = gconf_client_get_int(client, PROXY_KEY "port", NULL);
    proxy->ignore_hosts =
      gconf_client_get_string(client, PROXY_KEY "ignore_hosts", NULL);
    
    /* check for authentication */
    proxy->use_authentication =
      gconf_client_get_bool(client, PROXY_KEY "use_authentication", NULL);
    
    if(proxy->use_authentication) {
      proxy->authentication_user =
        gconf_client_get_string(client, PROXY_KEY "authentication_user", NULL);
      proxy->authentication_password =
        gconf_client_get_string(client, PROXY_KEY "authentication_password",
                                NULL);
    }
  }
  
  if(proxy) {
    if(proxy->ignore_hosts)
      printf("WARNING: Pproxy \"ignore_hosts\" unsupported!\n");

    printf("net_io: using proxy %s:%d\n", proxy->host, proxy->port);

    curl_easy_setopt(curl, CURLOPT_PROXY, proxy->host);
    curl_easy_setopt(curl, CURLOPT_PROXYPORT, proxy->port);

    if(proxy->use_authentication) {
      printf("net_io:   use auth for user %s\n", proxy->authentication_user);

      char *cred = g_strdup_printf("%s:%s",
                                   proxy->authentication_user,
                                   proxy->authentication_password);

      curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD, cred);
      g_free(cred);
    }
  }
}
#endif

/* parse root element */
static void parse_root(xmlDocPtr doc, xmlNode *a_node) {
  xmlNode *cur_node = NULL;

  for (cur_node = a_node; cur_node; cur_node = cur_node->next) {
    if (cur_node->type == XML_ELEMENT_NODE) {

      if(strcasecmp((char*)cur_node->name, "WMT_MS_Capabilities") == 0) {
        printf("xyz\n");

        //      wms_cap_parse(wms, doc, cur_node);
      } else 
        printf("found unhandled %s\n", cur_node->name);
    }
  }
}

static void parse_doc(xmlDocPtr doc) {
  /* Get the root element node */
  xmlNode *root_element = xmlDocGetRootElement(doc);

  parse_root(doc, root_element);  

  /*free the document */
  xmlFreeDoc(doc);

  /*
   * Free the global variables that may
   * have been allocated by the parser.
   */
  xmlCleanupParser();
}

int gcvote_get(appdata_t *appdata, char *url) {
  CURL *curl;
  struct curl_httppost *formpost=NULL;
  struct curl_httppost *lastptr=NULL;
  CURLcode res;
  curl_mem_t mem = { NULL, 0 };

  char *id = NULL;

  if(!url) return GCVOTE_NONE;

  id = strstr(url, ID_PATTERN);
  if(!id) return GCVOTE_NONE;

  id += strlen(ID_PATTERN);

  printf("request to get votes for id %s\n", id);

  curl_formadd(&formpost, &lastptr,
               CURLFORM_COPYNAME, "version",
               CURLFORM_COPYCONTENTS, APP VERSION,
               CURLFORM_END);
  
  curl_formadd(&formpost, &lastptr,
               CURLFORM_COPYNAME, "cacheIds",
               CURLFORM_COPYCONTENTS, id,
               CURLFORM_END);
 
  curl = curl_easy_init();
  if(!curl) return GCVOTE_NONE;

  /* play nice and report some user agent */
  curl_easy_setopt(curl, CURLOPT_USERAGENT, APP " " VERSION);

  /* download to memory */
  curl_easy_setopt(curl, CURLOPT_WRITEDATA, &mem);
  curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, mem_write);
  
  /* what URL that receives this POST */ 
  curl_easy_setopt(curl, CURLOPT_URL, "http://dosensuche.de/GCVote/getVotes.php");
  curl_easy_setopt(curl, CURLOPT_HTTPPOST, formpost);
  res = curl_easy_perform(curl);
  
  /* always cleanup */ 
  curl_easy_cleanup(curl);
  
  /* then cleanup the formpost chain */ 
  curl_formfree(formpost);

  printf("received %d bytes\n", mem.len);
  printf("data: %s\n", mem.ptr);

  /* start XML parser */
  LIBXML_TEST_VERSION;
    
  /* parse the file and get the DOM */
  xmlDoc *doc = xmlReadMemory(mem.ptr, mem.len, NULL, NULL, 0);
  if(!doc) {
    g_free(mem.ptr);
    return GCVOTE_NONE;
  }

  printf("ok, parse doc tree\n");
  parse_doc(doc);
  

  return 0;
}
1	/*
2	* This file is part of GPXView.
3	*
4	* GPXView is free software: you can redistribute it and/or modify
5	* it under the terms of the GNU General Public License as published by
6	* the Free Software Foundation, either version 3 of the License, or
7	* (at your option) any later version.
8	*
9	* GPXView is distributed in the hope that it will be useful,
10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12	* GNU General Public License for more details.
13	*
14	* You should have received a copy of the GNU General Public License
15	* along with GPXView. If not, see <http://www.gnu.org/licenses/>.
16	*/
17
18
19	/* curl command line example:
20	curl -d version=2.0b -duserName=uglyDUMMYusernamesolution -d cacheIds=4e68a04e-161c-4351-9813-bec6f6a4ca8a -d password= http://dosensuche.de/GCVote/getVotes.php
21	*/
22
23	#include <curl/curl.h>
24	#include <curl/types.h>
25	#include <curl/easy.h>
26
27	#include <libxml/parser.h>
28	#include <libxml/tree.h>
29
30	#ifndef LIBXML_TREE_ENABLED
31	#error "Tree not enabled in libxml"
32	#endif
33
34	#include "gpxview.h"
35
36	#define ID_PATTERN "guid="
37
38	typedef struct {
39	char *ptr;
40	int len;
41	} curl_mem_t;
42
43	static size_t mem_write(void *ptr, size_t size, size_t nmemb,
44	void *stream) {
45	curl_mem_t p = (curl_mem_t)stream;
46
47	p->ptr = g_realloc(p->ptr, p->len + size*nmemb + 1);
48	if(p->ptr) {
49	memcpy(p->ptr+p->len, ptr, size*nmemb);
50	p->len += size*nmemb;
51	p->ptr[p->len] = 0;
52	}
53	return nmemb;
54	}
55
56	#if 0
57	#define PROXY_KEY "/system/http_proxy/"
58
59	typedef struct {
60	char authentication_password, authentication_user;
61	char *host;
62	char *ignore_hosts;
63	gint port;
64	gboolean use_authentication;
65	} proxy_t;
66
67	void net_io_set_proxy(CURL curl, proxy_t proxy) {
68	/* ------ overwrite with settings from gconf if present ------- */
69	GConfClient *client = gconf_client_get_default();
70
71	/* ------------- get proxy settings -------------------- */
72	if(gconf_client_get_bool(client, PROXY_KEY "use_http_proxy", NULL)) {
73	proxy_t *proxy = settings->proxy = g_new0(proxy_t, 1);
74
75	/* get basic settings */
76	proxy->host = gconf_client_get_string(client, PROXY_KEY "host", NULL);
77	proxy->port = gconf_client_get_int(client, PROXY_KEY "port", NULL);
78	proxy->ignore_hosts =
79	gconf_client_get_string(client, PROXY_KEY "ignore_hosts", NULL);
80
81	/* check for authentication */
82	proxy->use_authentication =
83	gconf_client_get_bool(client, PROXY_KEY "use_authentication", NULL);
84
85	if(proxy->use_authentication) {
86	proxy->authentication_user =
87	gconf_client_get_string(client, PROXY_KEY "authentication_user", NULL);
88	proxy->authentication_password =
89	gconf_client_get_string(client, PROXY_KEY "authentication_password",
90	NULL);
91	}
92	}
93
94	if(proxy) {
95	if(proxy->ignore_hosts)
96	printf("WARNING: Pproxy \"ignore_hosts\" unsupported!\n");
97
98	printf("net_io: using proxy %s:%d\n", proxy->host, proxy->port);
99
100	curl_easy_setopt(curl, CURLOPT_PROXY, proxy->host);
101	curl_easy_setopt(curl, CURLOPT_PROXYPORT, proxy->port);
102
103	if(proxy->use_authentication) {
104	printf("net_io: use auth for user %s\n", proxy->authentication_user);
105
106	char *cred = g_strdup_printf("%s:%s",
107	proxy->authentication_user,
108	proxy->authentication_password);
109
110	curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD, cred);
111	g_free(cred);
112	}
113	}
114	}
115	#endif
116
117	/* parse root element */
118	static void parse_root(xmlDocPtr doc, xmlNode *a_node) {
119	xmlNode *cur_node = NULL;
120
121	for (cur_node = a_node; cur_node; cur_node = cur_node->next) {
122	if (cur_node->type == XML_ELEMENT_NODE) {
123
124	if(strcasecmp((char*)cur_node->name, "WMT_MS_Capabilities") == 0) {
125	printf("xyz\n");
126
127	// wms_cap_parse(wms, doc, cur_node);
128	} else
129	printf("found unhandled %s\n", cur_node->name);
130	}
131	}
132	}
133
134	static void parse_doc(xmlDocPtr doc) {
135	/* Get the root element node */
136	xmlNode *root_element = xmlDocGetRootElement(doc);
137
138	parse_root(doc, root_element);
139
140	/free the document /
141	xmlFreeDoc(doc);
142
143	/*
144	* Free the global variables that may
145	* have been allocated by the parser.
146	*/
147	xmlCleanupParser();
148	}
149
150	int gcvote_get(appdata_t appdata, char url) {
151	CURL *curl;
152	struct curl_httppost *formpost=NULL;
153	struct curl_httppost *lastptr=NULL;
154	CURLcode res;
155	curl_mem_t mem = { NULL, 0 };
156
157	char *id = NULL;
158
159	if(!url) return GCVOTE_NONE;
160
161	id = strstr(url, ID_PATTERN);
162	if(!id) return GCVOTE_NONE;
163
164	id += strlen(ID_PATTERN);
165
166	printf("request to get votes for id %s\n", id);
167
168	curl_formadd(&formpost, &lastptr,
169	CURLFORM_COPYNAME, "version",
170	CURLFORM_COPYCONTENTS, APP VERSION,
171	CURLFORM_END);
172
173	curl_formadd(&formpost, &lastptr,
174	CURLFORM_COPYNAME, "cacheIds",
175	CURLFORM_COPYCONTENTS, id,
176	CURLFORM_END);
177
178	curl = curl_easy_init();
179	if(!curl) return GCVOTE_NONE;
180
181	/* play nice and report some user agent */
182	curl_easy_setopt(curl, CURLOPT_USERAGENT, APP " " VERSION);
183
184	/* download to memory */
185	curl_easy_setopt(curl, CURLOPT_WRITEDATA, &mem);
186	curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, mem_write);
187
188	/* what URL that receives this POST */
189	curl_easy_setopt(curl, CURLOPT_URL, "http://dosensuche.de/GCVote/getVotes.php");
190	curl_easy_setopt(curl, CURLOPT_HTTPPOST, formpost);
191	res = curl_easy_perform(curl);
192
193	/* always cleanup */
194	curl_easy_cleanup(curl);
195
196	/* then cleanup the formpost chain */
197	curl_formfree(formpost);
198
199	printf("received %d bytes\n", mem.len);
200	printf("data: %s\n", mem.ptr);
201
202	/* start XML parser */
203	LIBXML_TEST_VERSION;
204
205	/* parse the file and get the DOM */
206	xmlDoc *doc = xmlReadMemory(mem.ptr, mem.len, NULL, NULL, 0);
207	if(!doc) {
208	g_free(mem.ptr);
209	return GCVOTE_NONE;
210	}
211
212	printf("ok, parse doc tree\n");
213	parse_doc(doc);
214
215
216	return 0;
217	}