--- /dev/null
+/*
+ * Conky, a system monitor, based on torsmo
+ *
+ * Please see COPYING for details
+ *
+ * Copyright (c) 2005-2009 Brenden Matthews, Philip Kovacs, et. al.
+ * (see AUTHORS)
+ * All rights reserved.
+ *
+ * This program 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.
+ *
+ * This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "conky.h"
+#include "logging.h"
+#include "ccurl_thread.h"
+
+#ifdef DEBUG
+#include <assert.h>
+#endif /* DEBUG */
+
+#include <curl/curl.h>
+#include <curl/types.h>
+#include <curl/easy.h>
+
+typedef struct _ccurl_memory_t {
+ char *memory;
+ size_t size;
+} ccurl_memory_t;
+
+ccurl_location_t *ccurl_find_location(ccurl_location_t **locations_head, char *uri)
+{
+ ccurl_location_t *tail = *locations_head;
+ ccurl_location_t *new = 0;
+ while (tail) {
+ if (tail->uri &&
+ strcmp(tail->uri, uri) == EQUAL) {
+ return tail;
+ }
+ tail = tail->next;
+ }
+ if (!tail) { /* new location!!!!!!! */
+ new = malloc(sizeof(ccurl_location_t));
+ memset(new, 0, sizeof(ccurl_location_t));
+ new->uri = strndup(uri, text_buffer_size);
+ tail = *locations_head;
+ while (tail && tail->next) {
+ tail = tail->next;
+ }
+ if (!tail) {
+ /* omg the first one!!!!!!! */
+ *locations_head = new;
+ } else {
+ tail->next = new;
+ }
+ }
+ return new;
+}
+
+void ccurl_free_locations(ccurl_location_t **locations_head)
+{
+ ccurl_location_t *tail = *locations_head;
+ ccurl_location_t *last = 0;
+
+ while (tail) {
+ if (tail->uri) free(tail->uri);
+ if (tail->result) free(tail->result);
+ last = tail;
+ tail = tail->next;
+ free(last);
+ }
+ *locations_head = 0;
+}
+
+size_t ccurl_write_memory_callback(void *ptr, size_t size, size_t nmemb, void *data)
+{
+ size_t realsize = size * nmemb;
+ ccurl_memory_t *mem = (ccurl_memory_t*)data;
+
+ mem->memory = (char *) realloc(mem->memory, mem->size + realsize + 1);
+ if (mem->memory) {
+ memcpy(&(mem->memory[mem->size]), ptr, realsize);
+ mem->size += realsize;
+ mem->memory[mem->size] = 0;
+ }
+ return realsize;
+}
+
+
+
+void ccurl_fetch_data(ccurl_location_t *curloc)
+{
+ CURL *curl = NULL;
+ CURLcode res;
+
+ // curl temps
+ ccurl_memory_t chunk;
+
+ chunk.memory = NULL;
+ chunk.size = 0;
+
+ curl = curl_easy_init();
+ if (curl) {
+ curl_easy_setopt(curl, CURLOPT_URL, curloc->uri);
+ curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1);
+ curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, ccurl_write_memory_callback);
+ curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *) &chunk);
+ curl_easy_setopt(curl, CURLOPT_USERAGENT, "conky-curl/1.0");
+
+ res = curl_easy_perform(curl);
+ if (res == CURLE_OK && chunk.size) {
+ timed_thread_lock(curloc->p_timed_thread);
+ (*curloc->process_function)(curloc->result, chunk.memory);
+ timed_thread_unlock(curloc->p_timed_thread);
+ free(chunk.memory);
+ } else {
+ ERR("weather: no data from server");
+ }
+
+ curl_easy_cleanup(curl);
+ }
+
+ return;
+}
+
+void *ccurl_thread(void *) __attribute__((noreturn));
+
+void ccurl_init_thread(ccurl_location_t *curloc, int interval)
+{
+#ifdef DEBUG
+ assert(curloc->result);
+#endif /* DEBUG */
+ curloc->p_timed_thread =
+ timed_thread_create(&ccurl_thread,
+ (void *)curloc, interval * 1000000);
+
+ if (!curloc->p_timed_thread) {
+ ERR("curl thread: error creating timed thread");
+ }
+ timed_thread_register(curloc->p_timed_thread,
+ &curloc->p_timed_thread);
+ if (timed_thread_run(curloc->p_timed_thread)) {
+ ERR("curl thread: error running timed thread");
+ }
+}
+
+void *ccurl_thread(void *arg)
+{
+ ccurl_location_t *curloc = (ccurl_location_t*)arg;
+
+ while (1) {
+ ccurl_fetch_data(curloc);
+ if (timed_thread_test(curloc->p_timed_thread, 0)) {
+ timed_thread_exit(curloc->p_timed_thread);
+ }
+ }
+ /* never reached */
+}
+
+static ccurl_location_t *ccurl_locations_head = 0;
+
+void ccurl_free_info(void)
+{
+ ccurl_free_locations(&ccurl_locations_head);
+}
+
+void ccurl_parse_data(void *result, const char *data)
+{
+ strncpy(result, data, max_user_text);
+}
+
+void ccurl_process_info(char *p, int p_max_size, char *uri, int interval)
+{
+ ccurl_location_t *curloc = ccurl_find_location(&ccurl_locations_head, uri);
+ if (!curloc->p_timed_thread) {
+ curloc->result = malloc(max_user_text);
+ memset(curloc->result, 0, max_user_text);
+ curloc->process_function = &ccurl_parse_data;
+ ccurl_init_thread(curloc, interval);
+ if (!curloc->p_timed_thread) {
+ ERR("error setting up weather thread");
+ }
+ }
+
+ timed_thread_lock(curloc->p_timed_thread);
+ strncpy(p, curloc->result, p_max_size);
+ timed_thread_unlock(curloc->p_timed_thread);
+}
+
--- /dev/null
+/*
+ * Conky, a system monitor, based on torsmo
+ *
+ * Please see COPYING for details
+ *
+ * Copyright (c) 2005-2009 Brenden Matthews, Philip Kovacs, et. al.
+ * (see AUTHORS)
+ * All rights reserved.
+ *
+ * This program 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.
+ *
+ * This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef _CURL_THREAD_H_
+#define _CURL_THREAD_H_
+
+typedef struct _ccurl_location_t {
+ char *uri; /* uri of location */
+ void *result; /* a pointer to some arbitrary data, will be freed by ccurl_free_info() if non-null */
+ timed_thread *p_timed_thread; /* internal thread pointer */
+ void (*process_function)(void *, const char *); /* function to call when data is ready to be processed, the first argument will be the result pointer, and the second argument is an internal buffer that shouldn't be mangled */
+ struct _ccurl_location_t *next; /* internal list pointer */
+} ccurl_location_t;
+
+/* find an existing location for the uri specified */
+ccurl_location_t *ccurl_find_location(ccurl_location_t **locations_head, char *uri);
+/* free all locations (as well as location->uri and location->result if
+ * non-null) */
+void ccurl_free_locations(ccurl_location_t **locations_head);
+/* initiates a thread at the location specified using the interval in seconds */
+void ccurl_init_thread(ccurl_location_t *curloc, int interval);
+
+/* for $curl, free internal list pointer */
+void ccurl_free_info(void);
+/* runs instance of $curl */
+void ccurl_process_info(char *p, int p_max_size, char *uri, int interval);
+
+#endif /* _CURL_THREAD_H_ */
+
projects / monky / commitdiff