-/* Conky, a system monitor, based on torsmo
+/* -*- mode: c; c-basic-offset: 4; tab-width: 4; indent-tabs-mode: t -*-
+ * vim: ts=4 sw=4 noet ai cindent syntax=c
*
- * Any original torsmo code is licensed under the BSD license
- *
- * All code written since the fork of torsmo is licensed under the GPL
+ * Conky, a system monitor, based on torsmo
*
* Please see COPYING for details
*
- * Copyright (c) 2004, Hannu Saransaari and Lauri Hakkarainen
- * Copyright (c) 2005-2009 Brenden Matthews, Philip Kovacs, et. al.
+ * Copyright (c) 2005-2010 Brenden Matthews, Philip Kovacs, et. al.
* (see AUTHORS)
* All rights reserved.
*
*
*/
+#include "config.h"
#include "conky.h"
#include "logging.h"
#include "weather.h"
+#include "temphelper.h"
+#include "text_object.h"
+#include "ccurl_thread.h"
#include <time.h>
#include <ctype.h>
-#include <curl/curl.h>
-#include <curl/types.h>
-#include <curl/easy.h>
+#ifdef MATH
+#include <math.h>
+#endif /* MATH */
+#ifdef XOAP
+#include <libxml/parser.h>
+#include <libxml/xpath.h>
+#endif /* XOAP */
+
+/* WEATHER data */
+typedef struct PWEATHER_ {
+ char lastupd[32];
+#ifdef XOAP
+ char xoap_t[32];
+ char icon[3];
+#endif /* XOAP */
+ int temp;
+ int dew;
+ int cc;
+ int bar;
+ int wind_s;
+ int wind_d;
+ int hmid;
+ int wc;
+} PWEATHER;
+
+#ifdef XOAP
+#define FORECAST_DAYS 5
+typedef struct PWEATHER_FORECAST_ {
+ int hi[FORECAST_DAYS];
+ int low[FORECAST_DAYS];
+ char icon[FORECAST_DAYS][3];
+ char xoap_t[FORECAST_DAYS][32];
+ char day[FORECAST_DAYS][9];
+ char date[FORECAST_DAYS][7];
+ int wind_s[FORECAST_DAYS];
+ int wind_d[FORECAST_DAYS];
+ int hmid[FORECAST_DAYS];
+ int ppcp[FORECAST_DAYS];
+} PWEATHER_FORECAST;
+
+/* Xpath expressions for XOAP xml parsing */
+#define NUM_XPATH_EXPRESSIONS_CC 8
+const char *xpath_expression_cc[NUM_XPATH_EXPRESSIONS_CC] = {
+ "/weather/cc/lsup", "/weather/cc/tmp", "/weather/cc/t",
+ "/weather/cc/bar/r", "/weather/cc/wind/s", "/weather/cc/wind/d",
+ "/weather/cc/hmid", "/weather/cc/icon"
+};
-#define MAX_LOCATIONS 3
+#define NUM_XPATH_EXPRESSIONS_DF 10
+const char *xpath_expression_df[NUM_XPATH_EXPRESSIONS_DF] = {
+ "/weather/dayf/day[*]/hi", "/weather/dayf/day[*]/low",
+ "/weather/dayf/day[*]/part[1]/icon", "/weather/dayf/day[*]/part[1]/t",
+ "/weather/dayf/day[*]/part[1]/wind/s","/weather/dayf/day[*]/part[1]/wind/d",
+ "/weather/dayf/day[*]/part[1]/ppcp", "/weather/dayf/day[*]/part[1]/hmid",
+ "/weather/dayf/day[*]/@t", "/weather/dayf/day[*]/@dt"
+};
+#endif /* XOAP */
/* Possible sky conditions */
#define NUM_CC_CODES 6
-const char *CC_CODES[NUM_CC_CODES] =
- {"SKC", "CLR", "FEW", "SCT", "BKN", "OVC"};
+const char *CC_CODES[NUM_CC_CODES] = {
+ "SKC", "CLR", "FEW", "SCT", "BKN", "OVC"
+};
/* Possible weather modifiers */
#define NUM_WM_CODES 9
-const char *WM_CODES[NUM_WM_CODES] =
- {"VC", "MI", "BC", "PR", "TS", "BL", "SH", "DR", "FZ"};
+const char *WM_CODES[NUM_WM_CODES] = {
+ "VC", "MI", "BC", "PR", "TS", "BL",
+ "SH", "DR", "FZ"
+};
/* Possible weather conditions */
#define NUM_WC_CODES 17
-const char *WC_CODES[NUM_WC_CODES] =
- {"DZ", "RA", "GR", "GS", "SN", "SG", "FG", "HZ", "FU", "BR", "DU", "SA",
- "FC", "PO", "SQ", "SS", "DS"};
+const char *WC_CODES[NUM_WC_CODES] = {
+ "DZ", "RA", "GR", "GS", "SN", "SG",
+ "FG", "HZ", "FU", "BR", "DU", "SA",
+ "FC", "PO", "SQ", "SS", "DS"
+};
-/*
- * TODO: This could be made common with the one used in prss.c
- *
- */
+static ccurl_location_t *locations_head_cc = 0;
+#ifdef XOAP
+static ccurl_location_t *locations_head_df = 0;
+#endif
-struct WMemoryStruct {
- char *memory;
- size_t size;
+struct weather_data {
+ char uri[128];
+ char data_type[32];
+ int interval;
};
-typedef struct location_ {
- char *uri;
- int last_update;
- PWEATHER *data;
-} location;
+#ifdef XOAP
+struct weather_forecast_data {
+ char uri[128];
+ unsigned int day;
+ char data_type[32];
+ int interval;
+};
+#endif
-int num_locations = 0;
-location locations[MAX_LOCATIONS];
+void weather_free_info(void)
+{
+ ccurl_free_locations(&locations_head_cc);
+#ifdef XOAP
+ ccurl_free_locations(&locations_head_df);
+#endif
+}
-/*
- * TODO: This could be made common with the one used in prss.c
- *
- */
+int rel_humidity(int dew_point, int air) {
+ const float a = 17.27f;
+ const float b = 237.7f;
+
+ float diff = a*(dew_point/(b+dew_point)-air/(b+air));
+#ifdef MATH
+ return (int)(100.f*expf(diff));
+#else
+ return (int)(16.666667163372f*(6.f+diff*(6.f+diff*(3.f+diff))));
+#endif /* MATH */
+}
-size_t WWriteMemoryCallback(void *ptr, size_t size, size_t nmemb, void *data)
+#ifdef XOAP
+static void parse_df(PWEATHER_FORECAST *res, xmlXPathContextPtr xpathCtx)
{
- size_t realsize = size * nmemb;
- struct WMemoryStruct *mem = (struct WMemoryStruct *) 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;
+ int i, j, k;
+ char *content;
+ xmlXPathObjectPtr xpathObj;
+
+ xpathObj = xmlXPathEvalExpression((const xmlChar *)"/error/err", xpathCtx);
+ if (xpathObj && xpathObj->nodesetval && xpathObj->nodesetval->nodeNr > 0 &&
+ xpathObj->nodesetval->nodeTab[0]->type == XML_ELEMENT_NODE) {
+ content = (char *)xmlNodeGetContent(xpathObj->nodesetval->nodeTab[0]);
+ NORM_ERR("XOAP error: %s", content);
+ xmlFree(content);
+ xmlXPathFreeObject(xpathObj);
+ return;
+ }
+ xmlXPathFreeObject(xpathObj);
+
+ for (i = 0; i < NUM_XPATH_EXPRESSIONS_DF; i++) {
+ xpathObj = xmlXPathEvalExpression((const xmlChar *)xpath_expression_df[i], xpathCtx);
+ if (xpathObj != NULL) {
+ xmlNodeSetPtr nodes = xpathObj->nodesetval;
+ k = 0;
+ for (j = 0; j < nodes->nodeNr; ++j) {
+ if (nodes->nodeTab[j]->type == XML_ELEMENT_NODE) {
+ content = (char *)xmlNodeGetContent(nodes->nodeTab[k]);
+ switch(i) {
+ case 0:
+ res->hi[k] = atoi(content);
+ break;
+ case 1:
+ res->low[k] = atoi(content);
+ break;
+ case 2:
+ strncpy(res->icon[k], content, 2);
+ case 3:
+ strncpy(res->xoap_t[k], content, 31);
+ break;
+ case 4:
+ res->wind_s[k] = atoi(content);
+ break;
+ case 5:
+ res->wind_d[k] = atoi(content);
+ break;
+ case 6:
+ res->ppcp[k] = atoi(content);
+ break;
+ case 7:
+ res->hmid[k] = atoi(content);
+ }
+ } else if (nodes->nodeTab[j]->type == XML_ATTRIBUTE_NODE) {
+ content = (char *)xmlNodeGetContent(nodes->nodeTab[k]);
+ switch(i) {
+ case 8:
+ strncpy(res->day[k], content, 8);
+ break;
+ case 9:
+ strncpy(res->date[k], content, 6);
+ }
+ }
+ xmlFree(content);
+ if (++k == FORECAST_DAYS) break;
+ }
+ }
+ xmlXPathFreeObject(xpathObj);
}
- return realsize;
+ return;
}
-int weather_delay(int *last, int delay)
+static void parse_weather_forecast_xml(PWEATHER_FORECAST *res, const char *data)
{
- time_t now = time(NULL);
+ xmlDocPtr doc;
+ xmlXPathContextPtr xpathCtx;
- if ((!*last) || (now >= *last + delay)) {
- *last = now;
- return 1;
+ if (!(doc = xmlReadMemory(data, strlen(data), "", NULL, 0))) {
+ NORM_ERR("weather_forecast: can't read xml data");
+ return;
}
- return 0;
+ xpathCtx = xmlXPathNewContext(doc);
+ if(xpathCtx == NULL) {
+ NORM_ERR("weather_forecast: unable to create new XPath context");
+ xmlFreeDoc(doc);
+ return;
+ }
+
+ parse_df(res, xpathCtx);
+ xmlXPathFreeContext(xpathCtx);
+ xmlFreeDoc(doc);
+ return;
}
-void init_weather_info(void)
+static void parse_cc(PWEATHER *res, xmlXPathContextPtr xpathCtx)
{
int i;
-
- for (i = 0; i < MAX_LOCATIONS; i++) {
- locations[i].uri = NULL;
- locations[i].data = NULL;
- locations[i].last_update = 0;
+ char *content;
+ xmlXPathObjectPtr xpathObj;
+
+ xpathObj = xmlXPathEvalExpression((const xmlChar *)"/error/err", xpathCtx);
+ if (xpathObj && xpathObj->nodesetval && xpathObj->nodesetval->nodeNr > 0 &&
+ xpathObj->nodesetval->nodeTab[0]->type == XML_ELEMENT_NODE) {
+ content = (char *)xmlNodeGetContent(xpathObj->nodesetval->nodeTab[0]);
+ NORM_ERR("XOAP error: %s", content);
+ xmlFree(content);
+ xmlXPathFreeObject(xpathObj);
+ return;
+ }
+ xmlXPathFreeObject(xpathObj);
+
+ for (i = 0; i < NUM_XPATH_EXPRESSIONS_CC; i++) {
+ xpathObj = xmlXPathEvalExpression((const xmlChar *)xpath_expression_cc[i], xpathCtx);
+ if (xpathObj && xpathObj->nodesetval && xpathObj->nodesetval->nodeNr >0 &&
+ xpathObj->nodesetval->nodeTab[0]->type ==
+ XML_ELEMENT_NODE) {
+ content = (char *)xmlNodeGetContent(xpathObj->nodesetval->nodeTab[0]);
+ switch(i) {
+ case 0:
+ strncpy(res->lastupd, content, 31);
+ break;
+ case 1:
+ res->temp = atoi(content);
+ break;
+ case 2:
+ strncpy(res->xoap_t, content, 31);
+ break;
+ case 3:
+ res->bar = atoi(content);
+ break;
+ case 4:
+ res->wind_s = atoi(content);
+ break;
+ case 5:
+ res->wind_d = atoi(content);
+ break;
+ case 6:
+ res->hmid = atoi(content);
+ break;
+ case 7:
+ strncpy(res->icon, content, 2);
+ }
+ xmlFree(content);
+ }
+ xmlXPathFreeObject(xpathObj);
}
+ return;
}
-void free_weather_info(void)
+static void parse_weather_xml(PWEATHER *res, const char *data)
{
- int i;
+ xmlDocPtr doc;
+ xmlXPathContextPtr xpathCtx;
- for (i = 0; i < num_locations; i++) {
- if (locations[i].uri != NULL) {
- free(locations[i].uri);
- }
+ if (!(doc = xmlReadMemory(data, strlen(data), "", NULL, 0))) {
+ NORM_ERR("weather: can't read xml data");
+ return;
}
-}
-int rel_humidity(int dew_point, int air) {
- const float a = 17.27f;
- const float b = 237.7f;
+ xpathCtx = xmlXPathNewContext(doc);
+ if(xpathCtx == NULL) {
+ NORM_ERR("weather: unable to create new XPath context");
+ xmlFreeDoc(doc);
+ return;
+ }
- float g = a*dew_point/(b+dew_point);
- return (int)(100.f*expf(g-a*air/(b+air)));
+ parse_cc(res, xpathCtx);
+ xmlXPathFreeContext(xpathCtx);
+ xmlFreeDoc(doc);
+ return;
}
+#endif /* XOAP */
/*
* Horrible hack to avoid using regexes
static inline void parse_token(PWEATHER *res, char *token) {
- int i;
- char s_tmp[64];
-
- switch (strlen(token)) {
-
- //Check all tokens 2 chars long
- case 2:
-
- //Check if token is a weather condition
- for (i=0; i<2; i++) {
- if (!isalpha(token[i])) break;
- }
- if (i==2) {
- for(i=0; i<NUM_WC_CODES; i++) {
- if (!strncmp(token, WC_CODES[i], 2)) {
- res->wc=i+1;
- break;
- }
+ int i;
+ char s_tmp[64];
+
+ switch (strlen(token)) {
+
+ //Check all tokens 2 chars long
+ case 2:
+
+ //Check if token is a weather condition
+ for (i=0; i<2; i++) {
+ if (!isalpha(token[i])) break;
+ }
+ if (i==2) {
+ for(i=0; i<NUM_WC_CODES; i++) {
+ if (!strncmp(token, WC_CODES[i], 2)) {
+ res->wc=i+1;
+ break;
+ }
+ }
+ return;
+ }
+
+ //Check for CB
+ if (!strcmp(token, "CB")) {
+ res->cc = 8;
+ return;
+ }
+
+ break;
+
+ //Check all tokens 3 chars long
+ case 3:
+
+ //Check if token is a modified weather condition
+ if ((token[0] == '+') || (token[0] == '-')) {
+ for (i=1; i<3; i++) {
+ if (!isalpha(token[i])) break;
+ }
+ if (i==3) {
+ for(i=0; i<NUM_WC_CODES; i++) {
+ if (!strncmp(&token[1], WC_CODES[i], 2)) {
+ res->wc=i+1;
+ break;
+ }
+ }
+ return;
+ }
+ }
+
+ //Check for NCD or NSC
+ if ((!strcmp(token, "NCD")) || (!strcmp(token, "NSC"))) {
+ res->cc = 1;
+ return;
+ }
+
+ //Check for TCU
+ if (!strcmp(token, "TCU")) {
+ res->cc = 7;
+ return;
+ }
+
+ break;
+
+ //Check all tokens 4 chars long
+ case 4:
+
+ //Check if token is a modified weather condition
+ for(i=0; i<NUM_WM_CODES; i++) {
+ if (!strncmp(token, WM_CODES[i], 2)) {
+ for(i=0; i<NUM_WC_CODES; i++) {
+ if (!strncmp(&token[2], WC_CODES[i], 2)) {
+ res->wc=i+1;
+ return;
+ }
+ }
+ break;
+ }
+ }
+
+ break;
+
+ //Check all tokens 5 chars long
+ case 5:
+
+ //Check for CAVOK
+ if (!strcmp(token, "CAVOK")) {
+ res->cc = 1;
+ return;
+ }
+
+ //Check if token is the temperature
+ for (i=0; i<2; i++) {
+ if (!isdigit(token[i])) break;
+ }
+ if ((i==2) && (token[2] == '/')) {
+ for (i=3; i<5; i++) {
+ if (!isdigit(token[i])) break;
+ }
+ if (i==5) {
+ //First 2 digits gives the air temperature
+ res->temp=atoi(token);
+
+ //4th and 5th digits gives the dew point temperature
+ res->dew=atoi(&token[3]);
+
+ //Compute humidity
+ res->hmid = rel_humidity(res->dew, res->temp);
+
+ return;
+ }
+ }
+
+ //Check if token is the pressure
+ if ((token[0] == 'Q') || (token[0] == 'A')) {
+ for (i=1; i<5; i++) {
+ if (!isdigit(token[i])) break;
+ }
+ if (i==5) {
+ if (token[0] == 'A') {
+ //Convert inches of mercury to mbar
+ res->bar = (int)(atoi(&token[1])*0.338637526f);
+ return;
+ }
+
+ //Last 4 digits is pressure im mbar
+ res->bar = atoi(&token[1]);
+ return;
+ }
+ }
+
+ //Check if token is a modified weather condition
+ if ((token[0] == '+') || (token[0] == '-')) {
+ for(i=0; i<NUM_WM_CODES; i++) {
+ if (!strncmp(&token[1], WM_CODES[i], 2)) {
+ for(i=0; i<NUM_WC_CODES; i++) {
+ if (!strncmp(&token[3], WC_CODES[i], 2)) {
+ res->wc=i+1;
+ return;
+ }
+ }
+ break;
+ }
+ }
+ }
+ break;
+
+ //Check all tokens 6 chars long
+ case 6:
+
+ //Check if token is the cloud cover
+ for (i=0; i<3; i++) {
+ if (!isalpha(token[i])) break;
+ }
+ if (i==3) {
+ for (i=3; i<6; i++) {
+ if (!isdigit(token[i])) break;
+ }
+ if (i==6) {
+ //Check if first 3 digits gives the cloud cover condition
+ for(i=0; i<NUM_CC_CODES; i++) {
+ if (!strncmp(token, CC_CODES[i], 3)) {
+ res->cc=i+1;
+ break;
+ }
+ }
+ return;
+ }
+ }
+
+ //Check if token is positive temp and negative dew
+ for (i=0; i<2; i++) {
+ if (!isdigit(token[i])) break;
+ }
+ if ((i==2) && (token[2] == '/') && (token[3] == 'M')) {
+ for (i=4; i<6; i++) {
+ if (!isdigit(token[i])) break;
+ }
+ if (i==6) {
+ //1st and 2nd digits gives the temperature
+ res->temp = atoi(token);
+
+ //5th and 6th digits gives the dew point temperature
+ res->dew = -atoi(&token[4]);
+
+ //Compute humidity
+ res->hmid = rel_humidity(res->dew, res->temp);
+
+ return;
+ }
+ }
+
+ break;
+
+ //Check all tokens 7 chars long
+ case 7:
+
+ //Check if token is the observation time
+ for (i=0; i<6; i++) {
+ if (!isdigit(token[i])) break;
+ }
+ if ((i==6) && (token[6] == 'Z')) return;
+
+ //Check if token is the wind speed/direction in knots
+ for (i=0; i<5; i++) {
+ if (!isdigit(token[i])) break;
+ }
+ if ((i==5) && (token[5] == 'K') && (token[6] == 'T')) {
+
+ //First 3 digits are wind direction
+ strncpy(s_tmp, token, 3);
+ s_tmp[3]='\0';
+ res->wind_d=atoi(s_tmp);
+
+ //4th and 5th digit are wind speed in knots (convert to km/hr)
+ res->wind_s = (int)(atoi(&token[3])*1.852);
+
+ return;
+ }
+
+ //Check if token is negative temperature
+ if ((token[0] == 'M') && (token[4] == 'M')) {
+ for (i=1; i<3; i++) {
+ if (!isdigit(token[i])) break;
+ }
+ if ((i==3) && (token[3] == '/')) {
+ for (i=5; i<7; i++) {
+ if (!isdigit(token[i])) break;
+ }
+ if (i==7) {
+ //2nd and 3rd digits gives the temperature
+ res->temp = -atoi(&token[1]);
+
+ //6th and 7th digits gives the dew point temperature
+ res->dew = -atoi(&token[5]);
+
+ //Compute humidity
+ res->hmid = rel_humidity(res->dew, res->temp);
+
+ return;
+ }
+ }
+ }
+
+ //Check if token is wind variability
+ for (i=0; i<3; i++) {
+ if (!isdigit(token[i])) break;
+ }
+ if ((i==3) && (token[3] == 'V')) {
+ for (i=4; i<7; i++) {
+ if (!isdigit(token[i])) break;
+ }
+ if (i==7) return;
+ }
+
+ break;
+
+ //Check all tokens 8 chars long
+ case 8:
+
+ //Check if token is the wind speed/direction in m/s
+ for (i=0; i<5; i++) {
+ if (!isdigit(token[i])) break;
+ }
+ if ((i==5)&&(token[5] == 'M')&&(token[6] == 'P')&&(token[7] == 'S')) {
+
+ //First 3 digits are wind direction
+ strncpy(s_tmp, token, 3);
+ s_tmp[3]='\0';
+ res->wind_d=atoi(s_tmp);
+
+ //4th and 5th digit are wind speed in m/s (convert to km/hr)
+ res->wind_s = (int)(atoi(&token[3])*3.6);
+
+ return;
+ }
+
+ default:
+
+ //printf("token : %s\n", token);
+ break;
}
- return;
- }
-
- //Check for CB
- if (!strcmp(token, "CB")) {
- res->cc = 8;
- return;
- }
-
- break;
+}
- //Check all tokens 3 chars long
- case 3:
+#ifdef XOAP
+void parse_weather_forecast(void *result, const char *data)
+{
+ PWEATHER_FORECAST *res = (PWEATHER_FORECAST*)result;
+ /* Reset results */
+ memset(res, 0, sizeof(PWEATHER_FORECAST));
- //Check if token is a modified weather condition
- if ((token[0] == '+') || (token[0] == '-')) {
- for (i=1; i<3; i++) {
- if (!isalpha(token[i])) break;
- }
- if (i==3) {
- for(i=0; i<NUM_WC_CODES; i++) {
- if (!strncmp(&token[1], WC_CODES[i], 2)) {
- res->wc=i+1;
- break;
- }
- }
- return;
+ //Check if it is an xml file
+ if ( strncmp(data, "<?xml ", 6) == 0 ) {
+ parse_weather_forecast_xml(res, data);
}
- }
+}
+#endif /* XOAP */
- //Check for NCD or NSC
- if ((!strcmp(token, "NCD")) || (!strcmp(token, "NSC"))) {
- res->cc = 1;
- return;
- }
+void parse_weather(void *result, const char *data)
+{
+ PWEATHER *res = (PWEATHER*)result;
+ /* Reset results */
+ memset(res, 0, sizeof(PWEATHER));
- //Check for TCU
- if (!strcmp(token, "TCU")) {
- res->cc = 7;
- return;
- }
-
- break;
-
- //Check all tokens 4 chars long
- case 4:
-
- //Check if token is a modified weather condition
- for(i=0; i<NUM_WM_CODES; i++) {
- if (!strncmp(token, WM_CODES[i], 2)) {
- for(i=0; i<NUM_WC_CODES; i++) {
- if (!strncmp(&token[2], WC_CODES[i], 2)) {
- res->wc=i+1;
- return;
- }
- }
- break;
- }
- }
+#ifdef XOAP
+ //Check if it is an xml file
+ if ( strncmp(data, "<?xml ", 6) == 0 ) {
+ parse_weather_xml(res, data);
+ } else
+#endif /* XOAP */
+ {
+ //We assume its a text file
+ char s_tmp[256];
+ const char delim[] = " ";
- break;
+ //Divide time stamp and metar data
+ if (sscanf(data, "%[^'\n']\n%[^'\n']", res->lastupd, s_tmp) == 2) {
- //Check all tokens 5 chars long
- case 5:
+ //Process all tokens
+ char *p_tok = NULL;
+ char *p_save = NULL;
- //Check for CAVOK
- if (!strcmp(token, "CAVOK")) {
- res->cc = 1;
- return;
- }
-
- //Check if token is the temperature
- for (i=0; i<2; i++) {
- if (!isdigit(token[i])) break;
- }
- if ((i==2) && (token[2] == '/')) {
- for (i=3; i<5; i++) {
- if (!isdigit(token[i])) break;
- }
- if (i==5) {
- //First 2 digits gives the air temperature
- res->tmpC=atoi(token);
+ if ((strtok_r(s_tmp, delim, &p_save)) != NULL) {
- //4th and 5th digits gives the dew point temperature
- res->dew=atoi(&token[3]);
+ //Jump first token, must be icao
+ p_tok = strtok_r(NULL, delim, &p_save);
- //Compute humidity
- res->hmid = rel_humidity(res->dew, res->tmpC);
+ do {
- //Convert to Fahrenheit (faster here than in conky.c)
- res->tmpF = (res->tmpC*9)/5 + 32;
+ parse_token(res, p_tok);
+ p_tok = strtok_r(NULL, delim, &p_save);
- return;
+ } while (p_tok != NULL);
+ }
+ return;
+ }
+ else {
+ return;
+ }
}
- }
+}
- //Check if token is the pressure
- if ((token[0] == 'Q') || (token[0] == 'A')) {
- for (i=1; i<5; i++) {
- if (!isdigit(token[i])) break;
- }
- if (i==5) {
- if (token[0] == 'A') {
- //Convert inches of mercury to mbar
- res->bar = (int)(atoi(&token[1])*0.338637526f);
- return;
- }
-
- //Last 4 digits is pressure im mbar
- res->bar = atoi(&token[1]);
- return;
- }
- }
-
- //Check if token is a modified weather condition
- if ((token[0] == '+') || (token[0] == '-')) {
- for(i=0; i<NUM_WM_CODES; i++) {
- if (!strncmp(&token[1], WM_CODES[i], 2)) {
- for(i=0; i<NUM_WC_CODES; i++) {
- if (!strncmp(&token[3], WC_CODES[i], 2)) {
- res->wc=i+1;
- return;
- }
- }
- break;
- }
+void wind_deg_to_dir(char *p, int p_max_size, int wind_deg) {
+ if ((wind_deg >= 349) || (wind_deg < 12)) {
+ strncpy(p, "N", p_max_size);
+ } else if (wind_deg < 33) {
+ strncpy(p, "NNE", p_max_size);
+ } else if (wind_deg < 57) {
+ strncpy(p, "NE", p_max_size);
+ } else if (wind_deg < 79) {
+ strncpy(p, "ENE", p_max_size);
+ } else if (wind_deg < 102) {
+ strncpy(p, "E", p_max_size);
+ } else if (wind_deg < 124) {
+ strncpy(p, "ESE", p_max_size);
+ } else if (wind_deg < 147) {
+ strncpy(p, "SE", p_max_size);
+ } else if (wind_deg < 169) {
+ strncpy(p, "SSE", p_max_size);
+ } else if (wind_deg < 192) {
+ strncpy(p, "S", p_max_size);
+ } else if (wind_deg < 214) {
+ strncpy(p, "SSW", p_max_size);
+ } else if (wind_deg < 237) {
+ strncpy(p, "SW", p_max_size);
+ } else if (wind_deg < 259) {
+ strncpy(p, "WSW", p_max_size);
+ } else if (wind_deg < 282) {
+ strncpy(p, "W", p_max_size);
+ } else if (wind_deg < 304) {
+ strncpy(p, "WNW", p_max_size);
+ } else if (wind_deg < 327) {
+ strncpy(p, "NW", p_max_size);
+ } else if (wind_deg < 349) {
+ strncpy(p, "NNW", p_max_size);
+ };
+}
+
+#ifdef XOAP
+static void weather_forecast_process_info(char *p, int p_max_size, char *uri, unsigned int day, char *data_type, int interval)
+{
+ PWEATHER_FORECAST *data;
+
+ ccurl_location_t *curloc = ccurl_find_location(&locations_head_df, uri);
+ if (!curloc->p_timed_thread) {
+ curloc->result = malloc(sizeof(PWEATHER_FORECAST));
+ memset(curloc->result, 0, sizeof(PWEATHER_FORECAST));
+ curloc->process_function = &parse_weather_forecast;
+ ccurl_init_thread(curloc, interval);
+ if (!curloc->p_timed_thread) {
+ NORM_ERR("error setting up weather_forecast thread");
+ }
}
- }
- break;
-
- //Check all tokens 6 chars long
- case 6:
-
- //Check if token is the cloud cover
- for (i=0; i<3; i++) {
- if (!isalpha(token[i])) break;
- }
- if (i==3) {
- for (i=3; i<6; i++) {
- if (!isdigit(token[i])) break;
+
+ timed_thread_lock(curloc->p_timed_thread);
+ data = (PWEATHER_FORECAST*)curloc->result;
+ if (strcmp(data_type, "hi") == EQUAL) {
+ temp_print(p, p_max_size, data->hi[day], TEMP_CELSIUS);
+ } else if (strcmp(data_type, "low") == EQUAL) {
+ temp_print(p, p_max_size, data->low[day], TEMP_CELSIUS);
+ } else if (strcmp(data_type, "icon") == EQUAL) {
+ strncpy(p, data->icon[day], p_max_size);
+ } else if (strcmp(data_type, "forecast") == EQUAL) {
+ strncpy(p, data->xoap_t[day], p_max_size);
+ } else if (strcmp(data_type, "wind_speed") == EQUAL) {
+ snprintf(p, p_max_size, "%d", data->wind_s[day]);
+ } else if (strcmp(data_type, "wind_dir") == EQUAL) {
+ wind_deg_to_dir(p, p_max_size, data->wind_d[day]);
+ } else if (strcmp(data_type, "wind_dir_DEG") == EQUAL) {
+ snprintf(p, p_max_size, "%d", data->wind_d[day]);
+ } else if (strcmp(data_type, "humidity") == EQUAL) {
+ snprintf(p, p_max_size, "%d", data->hmid[day]);
+ } else if (strcmp(data_type, "precipitation") == EQUAL) {
+ snprintf(p, p_max_size, "%d", data->ppcp[day]);
+ } else if (strcmp(data_type, "day") == EQUAL) {
+ strncpy(p, data->day[day], p_max_size);
+ } else if (strcmp(data_type, "date") == EQUAL) {
+ strncpy(p, data->date[day], p_max_size);
}
- if (i==6) {
- //Check if first 3 digits gives the cloud cover condition
- for(i=0; i<NUM_CC_CODES; i++) {
- if (!strncmp(token, CC_CODES[i], 3)) {
- res->cc=i+1;
- break;
- }
- }
- return;
+
+ timed_thread_unlock(curloc->p_timed_thread);
+}
+#endif /* XOAP */
+
+static void weather_process_info(char *p, int p_max_size, char *uri, char *data_type, int interval)
+{
+ static const char *wc[] = {
+ "", "drizzle", "rain", "hail", "soft hail",
+ "snow", "snow grains", "fog", "haze", "smoke",
+ "mist", "dust", "sand", "funnel cloud tornado",
+ "dust/sand", "squall", "sand storm", "dust storm"
+ };
+ PWEATHER *data;
+
+ ccurl_location_t *curloc = ccurl_find_location(&locations_head_cc, uri);
+ if (!curloc->p_timed_thread) {
+ curloc->result = malloc(sizeof(PWEATHER));
+ memset(curloc->result, 0, sizeof(PWEATHER));
+ curloc->process_function = &parse_weather;
+ ccurl_init_thread(curloc, interval);
+ if (!curloc->p_timed_thread) {
+ NORM_ERR("error setting up weather thread");
+ }
}
- }
-
- //Check if token is positive temp and negative dew
- for (i=0; i<2; i++) {
- if (!isdigit(token[i])) break;
- }
- if ((i==2) && (token[2] == '/') && (token[3] == 'M')) {
- for (i=4; i<6; i++) {
- if (!isdigit(token[i])) break;
+
+ timed_thread_lock(curloc->p_timed_thread);
+ data = (PWEATHER*)curloc->result;
+ if (strcmp(data_type, "last_update") == EQUAL) {
+ strncpy(p, data->lastupd, p_max_size);
+ } else if (strcmp(data_type, "temperature") == EQUAL) {
+ temp_print(p, p_max_size, data->temp, TEMP_CELSIUS);
+ } else if (strcmp(data_type, "cloud_cover") == EQUAL) {
+#ifdef XOAP
+ if (data->xoap_t[0] != '\0') {
+ char *s = p;
+ strncpy(p, data->xoap_t, p_max_size);
+ while (*s) {
+ *s = tolower(*s);
+ s++;
+ }
+ } else
+#endif /* XOAP */
+ if (data->cc == 0) {
+ strncpy(p, "", p_max_size);
+ } else if (data->cc < 3) {
+ strncpy(p, "clear", p_max_size);
+ } else if (data->cc < 5) {
+ strncpy(p, "partly cloudy", p_max_size);
+ } else if (data->cc == 5) {
+ strncpy(p, "cloudy", p_max_size);
+ } else if (data->cc == 6) {
+ strncpy(p, "overcast", p_max_size);
+ } else if (data->cc == 7) {
+ strncpy(p, "towering cumulus", p_max_size);
+ } else {
+ strncpy(p, "cumulonimbus", p_max_size);
+ }
+#ifdef XOAP
+ } else if (strcmp(data_type, "icon") == EQUAL) {
+ strncpy(p, data->icon, p_max_size);
+#endif /* XOAP */
+ } else if (strcmp(data_type, "pressure") == EQUAL) {
+ snprintf(p, p_max_size, "%d", data->bar);
+ } else if (strcmp(data_type, "wind_speed") == EQUAL) {
+ snprintf(p, p_max_size, "%d", data->wind_s);
+ } else if (strcmp(data_type, "wind_dir") == EQUAL) {
+ wind_deg_to_dir(p, p_max_size, data->wind_d);
+ } else if (strcmp(data_type, "wind_dir_DEG") == EQUAL) {
+ snprintf(p, p_max_size, "%d", data->wind_d);
+
+ } else if (strcmp(data_type, "humidity") == EQUAL) {
+ snprintf(p, p_max_size, "%d", data->hmid);
+ } else if (strcmp(data_type, "weather") == EQUAL) {
+ strncpy(p, wc[data->wc], p_max_size);
}
- if (i==6) {
- //1st and 2nd digits gives the temperature
- res->tmpC = atoi(token);
- //5th and 6th digits gives the dew point temperature
- res->dew = -atoi(&token[4]);
+ timed_thread_unlock(curloc->p_timed_thread);
+}
- //Compute humidity
- res->hmid = rel_humidity(res->dew, res->tmpC);
+#ifdef XOAP
+/* xoap suffix for weather from weather.com */
+static char *xoap_cc = NULL;
+static char *xoap_df = NULL;
+#endif /* XOAP */
- //Convert to Fahrenheit (faster here than in conky.c)
- res->tmpF = (res->tmpC*9)/5 + 32;
+static int process_weather_uri(char *uri, char *locID, int dayf UNUSED_ATTR)
+{
+ /* locID MUST BE upper-case */
+ char *tmp_p = locID;
- return;
+ while (*tmp_p) {
+ *tmp_p = toupper(*tmp_p);
+ tmp_p++;
}
- }
- break;
+ /* Construct complete uri */
+#ifdef XOAP
+ if (strstr(uri, "xoap.weather.com")) {
+ if ((dayf == 0) && (xoap_cc != NULL)) {
+ strcat(uri, locID);
+ strcat(uri, xoap_cc);
+ } else if ((dayf == 1) && (xoap_df != NULL)) {
+ strcat(uri, locID);
+ strcat(uri, xoap_df);
+ } else {
+ free(uri);
+ uri = NULL;
+ }
+ } else
+#endif /* XOAP */
+ if (strstr(uri, "weather.noaa.gov")) {
+ strcat(uri, locID);
+ strcat(uri, ".TXT");
+ } else if (!strstr(uri, "localhost") && !strstr(uri, "127.0.0.1")) {
+ return -1;
+ }
+ return 0;
+}
- //Check all tokens 7 chars long
- case 7:
+#ifdef XOAP
- //Check if token is the observation time
- for (i=0; i<6; i++) {
- if (!isdigit(token[i])) break;
- }
- if ((i==6) && (token[6] == 'Z')) return;
+/*
+ * TODO: make the xoap keys file readable from the config file
+ * make the keys directly readable from the config file
+ * make the xoap keys file giveable as a command line option
+ */
+void load_xoap_keys(void)
+{
+ FILE *fp;
+ char *par = (char *) malloc(11 * sizeof(char));
+ char *key = (char *) malloc(17 * sizeof(char));
+ char *xoap = (char *) malloc(64 * sizeof(char));
+
+ to_real_path(xoap, XOAP_FILE);
+ fp = fopen(xoap, "r");
+ if (fp != NULL) {
+ if (fscanf(fp, "%10s %16s", par, key) == 2) {
+ xoap_cc = (char *) malloc(128 * sizeof(char));
+ xoap_df = (char *) malloc(128 * sizeof(char));
+
+ strcpy(xoap_cc, "?cc=*&link=xoap&prod=xoap&par=");
+ strcat(xoap_cc, par);
+ strcat(xoap_cc, "&key=");
+ strcat(xoap_cc, key);
+ strcat(xoap_cc, "&unit=m");
+
+ /* TODO: Use FORECAST_DAYS instead of 5 */
+ strcpy(xoap_df, "?dayf=5&link=xoap&prod=xoap&par=");
+ strcat(xoap_df, par);
+ strcat(xoap_df, "&key=");
+ strcat(xoap_df, key);
+ strcat(xoap_df, "&unit=m");
+ }
+ fclose(fp);
+ }
+ free(par);
+ free(key);
+ free(xoap);
+}
+
+void scan_weather_forecast_arg(struct text_object *obj, const char *arg, void *free_at_crash)
+{
+ int argc;
+ struct weather_forecast_data *wfd;
+ float interval = 0;
+ char *locID = (char *) malloc(9 * sizeof(char));
- //Check if token is the wind speed/direction in knots
- for (i=0; i<5; i++) {
- if (!isdigit(token[i])) break;
- }
- if ((i==5) && (token[5] == 'K') && (token[6] == 'T')) {
+ wfd = malloc(sizeof(struct weather_forecast_data));
+ memset(wfd, 0, sizeof(struct weather_forecast_data));
- //First 3 digits are wind direction
- strncpy(s_tmp, token, 3);
- res->wind_d=atoi(s_tmp);
+ argc = sscanf(arg, "%119s %8s %1u %31s %f", wfd->uri, locID, &wfd->day, wfd->data_type, &interval);
- //4th and 5th digit are wind speed in knots (convert to km/hr)
- res->wind_s = (int)(atoi(&token[3])*1.852);
+ if (argc < 4) {
+ free(locID);
+ free(wfd);
+ CRIT_ERR(obj, free_at_crash, "wrong number of arguments for $weather_forecast");
+ }
+ if (process_weather_uri(wfd->uri, locID, 1)) {
+ free(locID);
+ free(wfd);
+ CRIT_ERR(obj, free_at_crash, \
+ "could not recognize the weather forecast uri");
+ }
- return;
- }
+ /* Limit the day between 0 (today) and FORECAST_DAYS */
+ if (wfd->day >= FORECAST_DAYS) {
+ wfd->day = FORECAST_DAYS-1;
+ }
- //Check if token is negative temperature
- if ((token[0] == 'M') && (token[4] == 'M')) {
- for (i=1; i<3; i++) {
- if (!isdigit(token[i])) break;
+ /* Limit the data retrieval interval to 3 hours and an half */
+ if (interval < 210) {
+ interval = 210;
}
- if ((i==3) && (token[3] == '/')) {
- for (i=5; i<7; i++) {
- if (!isdigit(token[i])) break;
- }
- if (i==7) {
- //2nd and 3rd digits gives the temperature
- res->tmpC = -atoi(&token[1]);
- //6th and 7th digits gives the dew point temperature
- res->dew = -atoi(&token[5]);
+ /* Convert to seconds */
+ wfd->interval = interval * 60;
+ free(locID);
- //Compute humidity
- res->hmid = rel_humidity(res->dew, res->tmpC);
+ DBGP("weather_forecast: fetching %s for day %d from %s every %d seconds", \
+ wfd->data_type, wfd->day, wfd->uri, wfd->interval);
- //Convert to Fahrenheit (faster here than in conky.c)
- res->tmpF = (res->tmpC*9)/5 + 32;
+ obj->data.opaque = wfd;
+}
- return;
- }
- }
- }
-
- //Check if token is wind variability
- for (i=0; i<3; i++) {
- if (!isdigit(token[i])) break;
- }
- if ((i==3) && (token[3] == 'V')) {
- for (i=4; i<7; i++) {
- if (!isdigit(token[i])) break;
+void print_weather_forecast(struct text_object *obj, char *p, int p_max_size)
+{
+ struct weather_forecast_data *wfd = obj->data.opaque;
+
+ if (!wfd || !wfd->uri) {
+ NORM_ERR("error processing weather forecast data, check that you have a valid XOAP key if using XOAP.");
+ return;
}
- if (i==7) return;
- }
+ weather_forecast_process_info(p, p_max_size, wfd->uri, wfd->day, wfd->data_type, wfd->interval);
+}
+#endif /* XOAP */
- break;
+void scan_weather_arg(struct text_object *obj, const char *arg, void *free_at_crash)
+{
+ int argc;
+ struct weather_data *wd;
+ char *locID = (char *) malloc(9 * sizeof(char));
+ float interval = 0;
- //Check all tokens 8 chars long
- case 8:
+ wd = malloc(sizeof(struct weather_data));
+ memset(wd, 0, sizeof(struct weather_data));
- //Check if token is the wind speed/direction in m/s
- for (i=0; i<5; i++) {
- if (!isdigit(token[i])) break;
- }
- if ((i==5)&&(token[5] == 'M')&&(token[6] == 'P')&&(token[7] == 'S')) {
+ argc = sscanf(arg, "%119s %8s %31s %f", wd->uri, locID, wd->data_type, &interval);
- //First 3 digits are wind direction
- strncpy(s_tmp, token, 3);
- res->wind_d=atoi(s_tmp);
+ if (argc < 3) {
+ free(locID);
+ free(wd);
+ CRIT_ERR(obj, free_at_crash, "wrong number of arguments for $weather");
+ }
+ if (process_weather_uri(wd->uri, locID, 0)) {
+ free(locID);
+ free(wd);
+ CRIT_ERR(obj, free_at_crash, \
+ "could not recognize the weather uri");
+ }
- //4th and 5th digit are wind speed in m/s (convert to km/hr)
- res->wind_s = (int)(atoi(&token[3])*3.6);
+ /* Limit the data retrieval interval to half hour min */
+ if (interval < 30) {
+ interval = 30;
+ }
- return;
- }
+ /* Convert to seconds */
+ wd->interval = interval * 60;
+ free(locID);
- default:
+ DBGP("weather: fetching %s from %s every %d seconds", \
+ wd->data_type, wd->uri, wd->interval);
- //printf("token : %s\n", token);
- break;
- }
+ obj->data.opaque = wd;
}
-static inline PWEATHER *parse_weather(const char *data)
+void print_weather(struct text_object *obj, char *p, int p_max_size)
{
- char s_tmp[256];
- const char delim[] = " ";
-
- PWEATHER *res = malloc(sizeof(PWEATHER));
- memset(res, 0, sizeof(PWEATHER));
-
- //Divide time stamp and metar data
- if (sscanf(data, "%[^'\n']\n%[^'\n']", res->lastupd, s_tmp) == 2) {
-
- //Process all tokens
- char *p_tok = NULL;
- char *p_save = NULL;
-
- if ((strtok_r(s_tmp, delim, &p_save)) != NULL) {
-
- //Jump first token, must be icao
- p_tok = strtok_r(NULL, delim, &p_save);
-
- do {
-
- parse_token(res, p_tok);
- p_tok = strtok_r(NULL, delim, &p_save);
-
- } while (p_tok != NULL);
- }
- return res;
- }
- else {
- return NULL;
- }
+ struct weather_data *wd = obj->data.opaque;
+
+ if (!wd || !wd->uri) {
+ NORM_ERR("error processing weather data, check that you have a valid XOAP key if using XOAP.");
+ return;
+ }
+ weather_process_info(p, p_max_size, wd->uri, wd->data_type, wd->interval);
}
-PWEATHER *get_weather_info(char *uri, int delay)
+void free_weather(struct text_object *obj)
{
- CURL *curl = NULL;
- CURLcode res;
-
- // pointers to struct
- location *curloc = NULL;
- PWEATHER *curdata = NULL;
- int *last_update = 0;
-
- int i;
-
- // curl temps
- struct WMemoryStruct chunk;
-
- chunk.memory = NULL;
- chunk.size = 0;
-
- // first seek for the uri in list
- for (i = 0; i < num_locations; i++) {
- if (locations[i].uri != NULL) {
- if (!strcmp(locations[i].uri, uri)) {
- curloc = &locations[i];
- break;
- }
- }
- }
-
- if (!curloc) { // new location
- if (num_locations == MAX_LOCATIONS) {
- return NULL;
- }
- curloc = &locations[num_locations];
- curloc->uri = strndup(uri, text_buffer_size);
- num_locations++;
- }
-
- last_update = &curloc->last_update;
- curdata = curloc->data;
-
- // wait for delay to pass
- if (!weather_delay(last_update, delay)) {
- return curdata;
- }
-
- // clean up old data
- if (curdata != NULL) {
- free(curdata);
- curdata = NULL;
- }
-
- curl = curl_easy_init();
- if (curl) {
- curl_easy_setopt(curl, CURLOPT_URL, uri);
- curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1);
- curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WWriteMemoryCallback);
- curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *) &chunk);
- curl_easy_setopt(curl, CURLOPT_USERAGENT, "conky-weather/1.0");
-
- res = curl_easy_perform(curl);
- if (chunk.size) {
- curdata = parse_weather(chunk.memory);
- free(chunk.memory);
- } else {
- ERR("No data from server");
- }
-
- curl_easy_cleanup(curl);
- }
-
- curloc->data = curdata;
-
- return curdata;
+ if (obj->data.opaque) {
+ free(obj->data.opaque);
+ obj->data.opaque = NULL;
+ }
}
projects / monky / blobdiff