dect
/
asterisk
Archived
13
0
Fork 0
Code Releases Activity

Add Calendaring support for Asterisk 

This commit add Calendaring support to Asterisk for iCalendar, CalDAV, and MS
Exchange calendars. Exchange support has only been tested on Exchange Server 2k3
and does not support forms-based authentication at this time (patches *very*
welcome). Exchange support is also currently missing the ability to return a
list of a meting's attendees (again, patches are very, very welcome).

Features include:
  Querying a calendar for events over a specific time range
  Checking a calendar's busy status via the dialplan
  Writing calendar events via the dialplan (CalDAV and Exchange only)
  Handling calendar event notifications through the dialplan

(closes issue #14771)
Tested by: lmadsen, twilson, Shivaprakash

Review: https://reviewboard.asterisk.org/r/58


git-svn-id: http://svn.digium.com/svn/asterisk/trunk@197738 f38db490-d61c-443f-a65b-d21fe96a405b
This commit is contained in:
twilson 2009-05-28 19:57:18 +00:00
parent a9296071c7
commit aec81d8f10
12 changed files with 16843 additions and 11349 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
build_tools/menuselect-deps.in
View File

@ -11,6 +11,7 @@ GTK2=@PBX_GTK2@
GTK=@PBX_GTK@
H323=@PBX_H323@
HOARD=@PBX_HOARD@
ICAL=@PBX_ICAL@
ICONV=@PBX_ICONV@
IKSEMEL=@PBX_IKSEMEL@
IMAP_TK=@PBX_IMAP_TK@
@ -19,12 +20,14 @@ ISDNNET=@PBX_ISDNNET@
IXJUSER=@PBX_IXJUSER@
JACK=@PBX_JACK@
LDAP=@PBX_LDAP@
LIBXML2=@PBX_LIBXML2@
LTDL=@PBX_LTDL@
LUA=@PBX_LUA@
MISDN=@PBX_MISDN@
NBS=@PBX_NBS@
NETSNMP=@PBX_NETSNMP@
NEWT=@PBX_NEWT@
NEON=@PBX_NEON@
OGG=@PBX_OGG@
OPENH323=@PBX_OPENH323@
OSPTK=@PBX_OSPTK@

80
configs/calendar.conf.sample Normal file
View File

@ -0,0 +1,80 @@
;[calendar1]
;type = ical ; type of calendar--currently supported: ical, caldav, or exchange
;url = https://example.com/home/jdoe/Calendar/ ; URL to shared calendar (Zimbra example)
;user = jdoe ; web username
;secret = supersecret ; web password
;refresh = 15 ; refresh calendar every n minutes
;timeframe = 60 ; number of minutes of calendar data to pull for each refresh period
; ; should always be >= refresh
;
; You can set up res_icalendar to execute a call upon an upcoming busy status
; The following fields are available from the ${CALENDAR_EVENT(<field>)} dialplan function:
;
; summary : The VEVENT Summary property or Exchange subject
; description : The text description of the vent
; organizer : The organizer of the event
; location : The location field of the event
; calendar : The name of the calendar tied to the event
; uid : The unique ID for this event
; start : Start time of the event
; end : The end time of the event
; busystate : 0=FREE, 1=TENTATIVE, 2=BUSY
;
;autoreminder = 10 ; Override event-defined reminder before each busy status (in mins)
;
;channel = SIP/60001 ; Channel to dial
;context = default ; Context to connect to on answer
;extension = 123 ; Extension to connect to on answer
;
; or
;
;app = Playback ; Application to execute on answer (instead of context/extension)
;appdata = tt-weasels ; Data part of application to execute on answer
;
;waittime = 30 ; How long to wait for an answer
;[calendar2]
;type = exchange ; type of calendar--currently supported: ical, caldav, or exchange
;url = https://example.com/exchange/jdoe ; URL to MS Exchange OWA for user (usually includes exchange/user)
;user = jdoe ; Exchange username
;secret = mysecret ; Exchange password
;refresh = 15 ; refresh calendar every n minutes
;timeframe = 60 ; number of minutes of calendar data to pull for each refresh period
; ; should always be >= refresh
;
; You can set up res_icalendar to execute a call upon an upcoming busy status
;autoreminder = 10 ; Override event-defined reminder before each busy status (in mins)
;
;channel = SIP/1234 ; Channel to dial
;context = default ; Context to connect to on answer
;extension = 1234 ; Extension to connect to on answer
;
; or
;
;app = Playback ; Application to execute on answer (instead of context/extension)
;appdata = tt-weasels ; Data part of application to execute on answer
;
;waittime = 30 ; How long to wait for an answer
;[calendar3]
;type = caldav ; type of calendar--currently supported: ical, caldav, or exchange
;url = https://www.google.com/calendar/dav/username@gmail.com/events/ ; Main GMail calendar (the trailing slash is significant!)
;user = jdoe@gmail.com ; username
;secret = mysecret ; password
;refresh = 15 ; refresh calendar every n minutes
;timeframe = 60 ; number of minutes of calendar data to pull for each refresh period
; ; should always be >= refresh
;
; You can set up res_icalendar to execute a call upon an upcoming busy status
;autoreminder = 10 ; Override event-defined reminder before each busy status (in mins)
;
;channel = SIP/1234 ; Channel to dial
;context = default ; Context to connect to on answer
;extension = 1234 ; Extension to connect to on answer
;
; or
;
;app = Playback ; Application to execute on answer (instead of context/extension)
;appdata = tt-weasels ; Data part of application to execute on answer
;
;waittime = 30 ; How long to wait for an answer

24388
configure vendored
View File

File diff suppressed because it is too large Load Diff

6
configure.ac
View File

@ -244,6 +244,7 @@ AST_EXT_LIB_SETUP([GTK], [gtk libraries], [gtk])
AST_EXT_LIB_SETUP([GTK2], [gtk2 libraries], [gtk2])
AST_EXT_LIB_SETUP([GMIME], [GMime library], [gmime])
AST_EXT_LIB_SETUP([HOARD], [Hoard Memory Allocator], [hoard])
AST_EXT_LIB_SETUP([ICAL], [ical libraries], [ical])
AST_EXT_LIB_SETUP([ICONV], [Iconv Library], [iconv])
AST_EXT_LIB_SETUP([IKSEMEL], [Iksemel Jabber Library], [iksemel])
AST_EXT_LIB_SETUP([IMAP_TK], [UW IMAP Toolkit], [imap])
@ -258,6 +259,7 @@ AST_EXT_LIB_SETUP([LUA], [Lua], [lua])
AST_EXT_LIB_SETUP([MISDN], [mISDN User Library], [misdn])
AST_EXT_LIB_SETUP([NBS], [Network Broadcast Sound], [nbs])
AST_EXT_LIB_SETUP([NCURSES], [ncurses], [ncurses])
AST_EXT_LIB_SETUP([NEON], [neon], [neon])
AST_EXT_LIB_SETUP([NETSNMP], [Net-SNMP], [netsnmp])
AST_EXT_LIB_SETUP([NEWT], [newt], [newt])
AST_EXT_LIB_SETUP([OGG], [OGG], [ogg])
@ -779,6 +781,8 @@ else
PBX_ICONV=1
fi
AST_EXT_LIB_CHECK([ICAL], [ical], [icaltimezone_new], [libical/ical.h], [-lpthread])
AST_EXT_LIB_CHECK([IKSEMEL], [iksemel], [iks_start_sasl], [iksemel.h])
if test "${USE_IMAP_TK}" != "no"; then
@ -1350,6 +1354,8 @@ AST_EXT_LIB_CHECK([NBS], [nbs], [nbs_connect], [nbs.h])
AST_EXT_LIB_CHECK([NCURSES], [ncurses], [initscr], [curses.h])
AST_EXT_TOOL_CHECK([NEON], [neon])
AST_EXT_TOOL_CHECK([NETSNMP], [net-snmp], , [--agent-libs],
[#include <net-snmp/net-snmp-config.h>
#include <net-snmp/net-snmp-includes.h>

9
include/asterisk/autoconfig.h.in
View File

@ -400,6 +400,12 @@
/* Define to indicate the ${HOARD_DESCRIP} library version */
#undef HAVE_HOARD_VERSION
/* Define this to indicate the ${ICAL_DESCRIP} library */
#undef HAVE_ICAL
/* Define to indicate the ${ICAL_DESCRIP} library version */
#undef HAVE_ICAL_VERSION
/* Define this to indicate the ${ICONV_DESCRIP} library */
#undef HAVE_ICONV
@ -593,6 +599,9 @@
/* Define to 1 if you have the <ndir.h> header file, and it defines `DIR'. */
#undef HAVE_NDIR_H
/* Define if your system has the NEON libraries. */
#undef HAVE_NEON
/* Define to 1 if you have the <netdb.h> header file. */
#undef HAVE_NETDB_H

187
include/asterisk/calendar.h Normal file
View File

@ -0,0 +1,187 @@
/*
* Asterisk -- An open source telephony toolkit.
*
* Copyright (C) 2008 - 2009, Digium, Inc.
*
* Terry Wilson <twilson@digium.com>
*
* See http://www.asterisk.org for more information about
* the Asterisk project. Please do not directly contact
* any of the maintainers of this project for assistance;
* the project provides a web site, mailing lists and IRC
* channels for your use.
*
* This program is free software, distributed under the terms of
* the GNU General Public License Version 2. See the LICENSE file
* at the top of the source tree.
*/
#ifndef _ASTERISK_CALENDAR_H
#define _ASTERISK_CALENDAR_H
#include "asterisk.h"
#include "asterisk/stringfields.h"
#include "asterisk/config.h"
#include "asterisk/linkedlists.h"
#include "asterisk/lock.h"
/*! \file calendar.h
* \brief A general API for managing calendar events with Asterisk
*
* \author Terry Wilson <twilson@digium.com>
*
* \note This API implements an abstraction for handling different calendaring
* technologies in Asterisk. The services provided by the API are a dialplan
* function to query whether or not a calendar is busy at the present time, a
* adialplan function to query specific information about events in a time range,
* a devicestate provider, and notification of calendar events through execution
* of dialplan apps or dialplan logic at a specific context and extension. The
* information available through the CALENDAR_EVENT() dialplan function are:
*
* SUMMARY, DESCRIPTION, ORGANIZER, LOCATION
* CALENDAR, UID, START, END, and BUSYSTATE
*
* BUSYSTATE can have the values 0 (free), 1 (tentatively busy), or 2 (busy)
*
* Usage
* All calendaring configuration data is located in calendar.conf and is only read
* directly by the Calendaring API. Each calendar technology resource must register
* a load_calendar callback which will be passed an ast_calendar_load_data structure.
* The load_calendar callback function should then set the values it needs from this
* cfg, load the calendar data, and then loop updating the calendar data and events
* baesd on the refresh interval in the ast_calendar object. Each call to
* the load_calendar callback will be will run in its own thread.
*
* Updating events involves creating an astobj2 container of new events and passing
* it to the API through ast_calendar_merge_events.
*
* Calendar technology resource modules must also register an unref_calendar callback
* which will only be called when the resource module calls ast_calendar_unregister()
* to unregister that module's calendar type (usually done in module_unload())
*/
extern struct ast_config *calendar_config;
struct ast_calendar;
struct ast_calendar_event;
/*! \brief Individual calendaring technology data */
struct ast_calendar_tech {
const char *type;
const char *description;
const char *module;
int (* is_busy)(struct ast_calendar *calendar); /*!< Override default busy determination */
void *(* load_calendar)(void *data); /*!< Create private structure, add calendar events, etc. */
void *(* unref_calendar)(void *obj); /*!< Function to be called to free the private structure */
int (* write_event)(struct ast_calendar_event *event); /*!< Function for writing an event to the calendar */
AST_LIST_ENTRY(ast_calendar_tech) list;
};
enum ast_calendar_busy_state {
AST_CALENDAR_BS_FREE = 0,
AST_CALENDAR_BS_BUSY_TENTATIVE,
AST_CALENDAR_BS_BUSY,
};
struct ast_calendar_attendee {
char *data;
AST_LIST_ENTRY(ast_calendar_attendee) next;
};
/* \brief Calendar events */
struct ast_calendar_event {
AST_DECLARE_STRING_FIELDS(
AST_STRING_FIELD(summary);
AST_STRING_FIELD(description);
AST_STRING_FIELD(organizer);
AST_STRING_FIELD(location);
AST_STRING_FIELD(uid);
);
struct ast_calendar *owner; /*!< The calendar that owns this event */
time_t start; /*!< Start of event (UTC) */
time_t end; /*!< End of event (UTC) */
time_t alarm; /*!< Time for event notification */
enum ast_calendar_busy_state busy_state; /*!< The busy status of the event */
int notify_sched; /*!< The sched for event notification */
int bs_start_sched; /*!< The sched for changing the device state at the start of an event */
int bs_end_sched; /*!< The sched for changing the device state at the end of an event */
AST_LIST_HEAD_NOLOCK(attendees, ast_calendar_attendee) attendees;
};
/*! \brief Asterisk calendar structure */
struct ast_calendar {
const struct ast_calendar_tech *tech;
void *tech_pvt;
AST_DECLARE_STRING_FIELDS(
AST_STRING_FIELD(name); /*!< Name from config file [name] */
AST_STRING_FIELD(notify_channel); /*!< Channel to use for notification */
AST_STRING_FIELD(notify_context); /*!< Optional context to execute from for notification */
AST_STRING_FIELD(notify_extension); /*!< Optional extension to execute from for notification */
AST_STRING_FIELD(notify_app); /*!< Optional dialplan app to execute for notification */
AST_STRING_FIELD(notify_appdata); /*!< Optional arguments for dialplan app */
);
int autoreminder; /*!< If set, override any calendar_tech specific notification times and use this time (in mins) */
int notify_waittime; /*!< Maxiumum time to allow for a notification attempt */
int refresh; /*!< When to refresh the calendar events */
int timeframe; /*!< Span (in mins) of calendar data to pull with each request */
pthread_t thread; /*!< The thread that the calendar is loaded/updated in */
ast_cond_t unload;
int unloading:1;
int pending_deletion:1;
struct ao2_container *events; /*!< The events that are known at this time */
};
/*! \brief Register a new calendar technology
*
* \param tech calendar technology to register
*
* \retval 0 success
* \retval -1 failure
*/
int ast_calendar_register(struct ast_calendar_tech *tech);
/*! \brief Unregister a new calendar technology
*
* \param tech calendar technology to unregister
*
* \retval 0 success
* \retva -1 failure
*/
void ast_calendar_unregister(struct ast_calendar_tech *tech);
/*! \brief Allocate an astobj2 ast_calendar_event object
*
* \param cal calendar to allocate an event for
*
* \return a new, initialized calendar event
*/
struct ast_calendar_event *ast_calendar_event_alloc(struct ast_calendar *cal);
/*! \brief Allocate an astobj2 container for ast_calendar_event objects
*
* \return a new event container
*/
struct ao2_container *ast_calendar_event_container_alloc(void);
/*! \brief Add an event to the list of events for a calendar
*
* \param cal calendar containing the events to be merged
* \param new_events an oa2 container of events to be merged into cal->events
*/
void ast_calendar_merge_events(struct ast_calendar *cal, struct ao2_container *new_events);
/*! \brief Unreference an ast_calendar_event
*
* \param event event to unref
*
* \return NULL
*/
struct ast_calendar_event *ast_calendar_unref_event(struct ast_calendar_event *event);
/*! \brief Remove all events from calendar
*
* \param cal calendar whose events need to be cleared
*/
void ast_calendar_clear_events(struct ast_calendar *cal);
#endif /* _ASTERISK_CALENDAR_H */

6
makeopts.in
View File

@ -105,6 +105,9 @@ GTK_LIB=@GTK_LIB@
GTK2_INCLUDE=@GTK2_INCLUDE@
GTK2_LIB=@GTK2_LIB@
ICAL_INCLUDE=@ICAL_INCLUDE@
ICAL_LIB=@ICAL_LIB@
ICONV_INCLUDE=@ICONV_INCLUDE@
ICONV_LIB=@ICONV_LIB@
@ -133,6 +136,9 @@ NCURSES_INCLUDE=@NCURSES_INCLUDE@
NCURSES_LIB=@NCURSES_LIB@
NCURSES_DIR=@NCURSES_DIR@
NEON_INCLUDE=@NEON_INCLUDE@
NEON_LIB=@NEON_LIB@
NETSNMP_INCLUDE=@NETSNMP_INCLUDE@
NETSNMP_LIB=@NETSNMP_LIB@

1604
res/res_calendar.c Normal file
View File

File diff suppressed because it is too large Load Diff

7
res/res_calendar.exports Normal file
View File

@ -0,0 +1,7 @@
{
global:
ast_*;
calendar_config;
local:
*;
};

675
res/res_calendar_caldav.c Normal file
View File

@ -0,0 +1,675 @@
/*
* Asterisk -- An open source telephony toolkit.
*
* Copyright (C) 2008 - 2009, Digium, Inc.
*
* Terry Wilson <twilson@digium.com>
*
* See http://www.asterisk.org for more information about
* the Asterisk project. Please do not directly contact
* any of the maintainers of this project for assistance;
* the project provides a web site, mailing lists and IRC
* channels for your use.
*
* This program is free software, distributed under the terms of
* the GNU General Public License Version 2. See the LICENSE file
* at the top of the source tree.
*/
/*! \file
* \brief Resource for handling iCalnedar calendars
*/
/*** MODULEINFO
<depend>neon</depend>
<depend>ical</depend>
<depend>libxml2</depend>
***/
#include "asterisk.h"
ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
#include <libical/ical.h>
#include <neon/ne_session.h>
#include <neon/ne_uri.h>
#include <neon/ne_request.h>
#include <neon/ne_auth.h>
#include <libxml/xmlmemory.h>
#include <libxml/parser.h>
#include "asterisk/module.h"
#include "asterisk/calendar.h"
#include "asterisk/lock.h"
#include "asterisk/config.h"
#include "asterisk/astobj2.h"
static void *caldav_load_calendar(void *data);
static void *unref_caldav(void *obj);
static int caldav_write_event(struct ast_calendar_event *event);
static struct ast_calendar_tech caldav_tech = {
.type = "caldav",
.description = "CalDAV calendars",
.module = AST_MODULE,
.load_calendar = caldav_load_calendar,
.unref_calendar = unref_caldav,
.write_event = caldav_write_event,
};
struct caldav_pvt {
AST_DECLARE_STRING_FIELDS(
AST_STRING_FIELD(url);
AST_STRING_FIELD(user);
AST_STRING_FIELD(secret);
);
struct ast_calendar *owner;
ne_uri uri;
ne_session *session;
struct ao2_container *events;
};
static int cb_true(void *user_data, void *arg, int flags)
{
return CMP_MATCH;
}
static void caldav_destructor(void *obj)
{
struct caldav_pvt *pvt = obj;
ast_debug(1, "Destroying pvt for CalDAV calendar %s\n", pvt->owner->name);
if (pvt->session) {
ne_session_destroy(pvt->session);
}
ast_string_field_free_memory(pvt);
ao2_callback(pvt->events, OBJ_UNLINK | OBJ_NODATA | OBJ_MULTIPLE, cb_true, NULL);
ao2_ref(pvt->events, -1);
}
static void *unref_caldav(void *obj)
{
struct caldav_pvt *pvt = obj;
ao2_ref(pvt, -1);
return NULL;
}
static int fetch_response_reader(void *data, const char *block, size_t len)
{
struct ast_str **response = data;
unsigned char *tmp;
if (!(tmp = ast_malloc(len + 1))) {
return -1;
}
memcpy(tmp, block, len);
tmp[len] = '\0';
ast_str_append(response, 0, "%s", tmp);
ast_free(tmp);
return 0;
}
static int auth_credentials(void *userdata, const char *realm, int attempts, char *username, char *secret)
{
struct caldav_pvt *pvt = userdata;
if (attempts > 1) {
ast_log(LOG_WARNING, "Invalid username or password for CalDAV calendar '%s'\n", pvt->owner->name);
return -1;
}
ne_strnzcpy(username, pvt->user, NE_ABUFSIZ);
ne_strnzcpy(secret, pvt->secret, NE_ABUFSIZ);
return 0;
}
static struct ast_str *caldav_request(struct caldav_pvt *pvt, const char *method, struct ast_str *req_body, struct ast_str *subdir, const char *content_type)
{
struct ast_str *response;
ne_request *req;
int ret;
char buf[1000];
if (!pvt) {
ast_log(LOG_ERROR, "There is no private!\n");
return NULL;
}
if (!(response = ast_str_create(512))) {
ast_log(LOG_ERROR, "Could not allocate memory for response.\n");
return NULL;
}
snprintf(buf, sizeof(buf), "%s%s", pvt->uri.path, subdir ? ast_str_buffer(subdir) : "");
req = ne_request_create(pvt->session, method, buf);
ne_add_response_body_reader(req, ne_accept_2xx, fetch_response_reader, &response);
ne_set_request_body_buffer(req, ast_str_buffer(req_body), ast_str_strlen(req_body));
ne_add_request_header(req, "Content-type", ast_strlen_zero(content_type) ? "text/xml" : content_type);
ret = ne_request_dispatch(req);
ne_request_destroy(req);
if (ret != NE_OK || !ast_str_strlen(response)) {
ast_log(LOG_WARNING, "Unknown response to CalDAV calendar %s, request %s to %s: %s\n", pvt->owner->name, method, pvt->url, ne_get_error(pvt->session));
ast_free(response);
return NULL;
}
return response;
}
static int caldav_write_event(struct ast_calendar_event *event)
{
struct ast_str *body = NULL, *response = NULL, *subdir = NULL;
icalcomponent *calendar, *icalevent;
icaltimezone *utc = icaltimezone_get_utc_timezone();
int ret = -1;
if (!event) {
ast_log(LOG_WARNING, "No event passed!\n");
return -1;
}
if (!(event->start && event->end)) {
ast_log(LOG_WARNING, "The event must contain a start and an end\n");
return -1;
}
if (!(body = ast_str_create(512)) ||
!(subdir = ast_str_create(32)) ||
!(response = ast_str_create(512))) {
ast_log(LOG_ERROR, "Could not allocate memory for request and response!\n");
goto write_cleanup;
}
if (ast_strlen_zero(event->uid)) {
unsigned short val[8];
int x;
for (x = 0; x < 8; x++) {
val[x] = ast_random();
}
ast_string_field_build(event, uid, "%04x%04x-%04x-%04x-%04x-%04x%04x%04x", val[0], val[1], val[2], val[3], val[4], val[5], val[6], val[7]);
}
calendar = icalcomponent_new(ICAL_VCALENDAR_COMPONENT);
icalcomponent_add_property(calendar, icalproperty_new_version("2.0"));
icalcomponent_add_property(calendar, icalproperty_new_prodid("-//Digium, Inc.//res_caldav//EN"));
icalevent = icalcomponent_new(ICAL_VEVENT_COMPONENT);
icalcomponent_add_property(icalevent, icalproperty_new_dtstamp(icaltime_current_time_with_zone(utc)));
icalcomponent_add_property(icalevent, icalproperty_new_uid(event->uid));
icalcomponent_add_property(icalevent, icalproperty_new_dtstart(icaltime_from_timet_with_zone(event->start, 0, utc)));
icalcomponent_add_property(icalevent, icalproperty_new_dtend(icaltime_from_timet_with_zone(event->end, 0, utc)));
if (!ast_strlen_zero(event->organizer)) {
icalcomponent_add_property(icalevent, icalproperty_new_organizer(event->organizer));
}
if (!ast_strlen_zero(event->summary)) {
icalcomponent_add_property(icalevent, icalproperty_new_summary(event->summary));
}
if (!ast_strlen_zero(event->description)) {
icalcomponent_add_property(icalevent, icalproperty_new_description(event->description));
}
if (!ast_strlen_zero(event->location)) {
icalcomponent_add_property(icalevent, icalproperty_new_location(event->location));
}
switch (event->busy_state) {
case AST_CALENDAR_BS_BUSY:
icalcomponent_add_property(icalevent, icalproperty_new_status(ICAL_STATUS_CONFIRMED));
break;
case AST_CALENDAR_BS_BUSY_TENTATIVE:
icalcomponent_add_property(icalevent, icalproperty_new_status(ICAL_STATUS_TENTATIVE));
break;
default:
icalcomponent_add_property(icalevent, icalproperty_new_status(ICAL_STATUS_NONE));
}
icalcomponent_add_component(calendar, icalevent);
ast_str_append(&body, 0, "%s", icalcomponent_as_ical_string(calendar));
ast_str_set(&subdir, 0, "%s%s.ics", ast_str_buffer(body)[ast_str_strlen(body)] == '/' ? "" : "/", event->uid);
response = caldav_request(event->owner->tech_pvt, "PUT", body, subdir, "text/calendar");
ret = 0;
write_cleanup:
if (body) {
ast_free(body);
}
if (response) {
ast_free(response);
}
if (subdir) {
ast_free(subdir);
}
return ret;
}
static struct ast_str *caldav_get_events_between(struct caldav_pvt *pvt, time_t start_time, time_t end_time)
{
struct ast_str *body, *response;
icaltimezone *utc = icaltimezone_get_utc_timezone();
icaltimetype start, end;
const char *start_str, *end_str;
if (!(body = ast_str_create(512))) {
ast_log(LOG_ERROR, "Could not allocate memory for body of request!\n");
return NULL;
}
start = icaltime_from_timet_with_zone(start_time, 0, utc);
end = icaltime_from_timet_with_zone(end_time, 0, utc);
start_str = icaltime_as_ical_string(start);
end_str = icaltime_as_ical_string(end);
/* If I was really being efficient, I would store a collection of event URIs and etags,
* first doing a query of just the etag and seeing if anything had changed. If it had,
* then I would do a request for each of the events that had changed, and only bother
* updating those. Oh well. */
ast_str_append(&body, 0,
"<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n"
"<C:calendar-query xmlns:D=\"DAV:\" xmlns:C=\"urn:ietf:params:xml:ns:caldav\">\n"
" <D:prop>\n"
" <C:calendar-data>\n"
" <C:expand start=\"%s\" end=\"%s\"/>\n"
" </C:calendar-data>\n"
" </D:prop>\n"
" <C:filter>\n"
" <C:comp-filter name=\"VCALENDAR\">\n"
" <C:comp-filter name=\"VEVENT\">\n"
" <C:time-range start=\"%s\" end=\"%s\"/>\n"
" </C:comp-filter>\n"
" </C:comp-filter>\n"
" </C:filter>\n"
"</C:calendar-query>\n", start_str, end_str, start_str, end_str);
response = caldav_request(pvt, "REPORT", body, NULL, NULL);
ast_free(body);
return response;
}
static void caldav_add_event(icalcomponent *comp, struct icaltime_span *span, void *data)
{
struct caldav_pvt *pvt = data;
struct ast_calendar_event *event;
icaltimezone *utc = icaltimezone_get_utc_timezone();
icaltimetype start, end, tmp;
icalcomponent *valarm;
icalproperty *prop;
struct icaltriggertype trigger;
if (!(pvt && pvt->owner)) {
ast_log(LOG_ERROR, "Require a private structure with an owner\n");
return;
}
if (!(event = ast_calendar_event_alloc(pvt->owner))) {
ast_log(LOG_ERROR, "Could not allocate an event!\n");
return;
}
start = icaltime_from_timet_with_zone(span->start, 0, utc);
end = icaltime_from_timet_with_zone(span->end, 0, utc);
event->start = span->start;
event->end = span->end;
switch(icalcomponent_get_status(comp)) {
case ICAL_STATUS_CONFIRMED:
event->busy_state = AST_CALENDAR_BS_BUSY;
break;
case ICAL_STATUS_TENTATIVE:
event->busy_state = AST_CALENDAR_BS_BUSY_TENTATIVE;
break;
default:
event->busy_state = AST_CALENDAR_BS_FREE;
}
if ((prop = icalcomponent_get_first_property(comp, ICAL_SUMMARY_PROPERTY))) {
ast_string_field_set(event, summary, icalproperty_get_value_as_string(prop));
}
if ((prop = icalcomponent_get_first_property(comp, ICAL_DESCRIPTION_PROPERTY))) {
ast_string_field_set(event, description, icalproperty_get_value_as_string(prop));
}
if ((prop = icalcomponent_get_first_property(comp, ICAL_ORGANIZER_PROPERTY))) {
ast_string_field_set(event, organizer, icalproperty_get_value_as_string(prop));
}
if ((prop = icalcomponent_get_first_property(comp, ICAL_LOCATION_PROPERTY))) {
ast_string_field_set(event, location, icalproperty_get_value_as_string(prop));
}
if ((prop = icalcomponent_get_first_property(comp, ICAL_UID_PROPERTY))) {
ast_string_field_set(event, uid, icalproperty_get_value_as_string(prop));
} else {
ast_log(LOG_WARNING, "No UID found, but one is required. Generating, but updates may not be acurate\n");
if (!ast_strlen_zero(event->summary)) {
ast_string_field_set(event, uid, event->summary);
} else {
char tmp[100];
snprintf(tmp, sizeof(tmp), "%lu", event->start);
ast_string_field_set(event, uid, tmp);
}
}
/* Get the attendees */
for (prop = icalcomponent_get_first_property(comp, ICAL_ATTENDEE_PROPERTY);
prop; prop = icalcomponent_get_next_property(comp, ICAL_ATTENDEE_PROPERTY)) {
struct ast_calendar_attendee *attendee;
const char *data;
if (!(attendee = ast_calloc(1, sizeof(*attendee)))) {
event = ast_calendar_unref_event(event);
return;
}
data = icalproperty_get_attendee(prop);
if (!ast_strlen_zero(data)) {
attendee->data = ast_strdup(data);;
AST_LIST_INSERT_TAIL(&event->attendees, attendee, next);
}
}
/* Only set values for alarm based on VALARM. Can be overriden in main/calendar.c by autoreminder
* therefore, go ahead and add events even if their is no VALARM or it is malformed
* Currently we are only getting the first VALARM and are handling repitition in main/calendar.c from calendar.conf */
if (!(valarm = icalcomponent_get_first_component(comp, ICAL_VALARM_COMPONENT))) {
ao2_link(pvt->events, event);
event = ast_calendar_unref_event(event);
return;
}
if (!(prop = icalcomponent_get_first_property(valarm, ICAL_TRIGGER_PROPERTY))) {
ast_log(LOG_WARNING, "VALARM has no TRIGGER, skipping!\n");
ao2_link(pvt->events, event);
event = ast_calendar_unref_event(event);
return;
}
trigger = icalproperty_get_trigger(prop);
if (icaltriggertype_is_null_trigger(trigger)) {
ast_log(LOG_WARNING, "Bad TRIGGER for VALARM, skipping!\n");
ao2_link(pvt->events, event);
event = ast_calendar_unref_event(event);
return;
}
if (!icaltime_is_null_time(trigger.time)) { /* This is an absolute time */
tmp = icaltime_convert_to_zone(trigger.time, utc);
event->alarm = icaltime_as_timet_with_zone(tmp, utc);
} else { /* Offset from either dtstart or dtend */
/* XXX Technically you can check RELATED to see if the event fires from the END of the event
* But, I'm not sure I've ever seen anyone implement it in calendaring software, so I'm ignoring for now */
tmp = icaltime_add(start, trigger.duration);
event->alarm = icaltime_as_timet_with_zone(tmp, utc);
}
ao2_link(pvt->events, event);
event = ast_calendar_unref_event(event);
return;
}
struct xmlstate {
int in_caldata;
struct caldav_pvt *pvt;
struct ast_str *cdata;
time_t start;
time_t end;
};
static void handle_start_element(void *data, const xmlChar *fullname, const xmlChar **atts)
{
struct xmlstate *state = data;
if (!xmlStrcasecmp(fullname, BAD_CAST "C:calendar-data")) {
state->in_caldata = 1;
ast_str_reset(state->cdata);
}
}
static void handle_end_element(void *data, const xmlChar *name)
{
struct xmlstate *state = data;
struct icaltimetype start, end;
icaltimezone *utc = icaltimezone_get_utc_timezone();
icalcomponent *iter;
icalcomponent *comp;
if (xmlStrcasecmp(name, BAD_CAST "C:calendar-data")) {
return;
}
state->in_caldata = 0;
if (!(state->cdata && ast_str_strlen(state->cdata))) {
return;
}
/* XXX Parse the calendar blurb for recurrence events in the time range,
* create an event, and add it to pvt->events */
start = icaltime_from_timet_with_zone(state->start, 0, utc);
end = icaltime_from_timet_with_zone(state->end, 0, utc);
comp = icalparser_parse_string(ast_str_buffer(state->cdata));
for (iter = icalcomponent_get_first_component(comp, ICAL_VEVENT_COMPONENT);
iter;
iter = icalcomponent_get_next_component(comp, ICAL_VEVENT_COMPONENT))
{
icalcomponent_foreach_recurrence(iter, start, end, caldav_add_event, state->pvt);
}
icalcomponent_free(comp);
}
static void handle_characters(void *data, const xmlChar *ch, int len)
{
struct xmlstate *state = data;
xmlChar *tmp;
if (!state->in_caldata) {
return;
}
tmp = xmlStrndup(ch, len);
ast_str_append(&state->cdata, 0, "%s", (char *)tmp);
xmlFree(tmp);
}
static int update_caldav(struct caldav_pvt *pvt)
{
struct timeval now = ast_tvnow();
time_t start, end;
struct ast_str *response;
xmlSAXHandler saxHandler;
struct xmlstate state = {
.in_caldata = 0,
.pvt = pvt
};
start = now.tv_sec;
end = now.tv_sec + 60 * pvt->owner->timeframe;
if (!(response = caldav_get_events_between(pvt, start, end))) {
return -1;
}
if (!(state.cdata = ast_str_create(512))) {
ast_free(response);
return -1;
}
state.start = start;
state.end = end;
memset(&saxHandler, 0, sizeof(saxHandler));
saxHandler.startElement = handle_start_element;
saxHandler.endElement = handle_end_element;
saxHandler.characters = handle_characters;
xmlSAXUserParseMemory(&saxHandler, &state, ast_str_buffer(response), ast_str_strlen(response));
ast_calendar_merge_events(pvt->owner, pvt->events);
ast_free(response);
ast_free(state.cdata);
return 0;
}
static int verify_cert(void *userdata, int failures, const ne_ssl_certificate *cert)
{
/* Verify all certs */
return 0;
}
static void *caldav_load_calendar(void *void_data)
{
struct caldav_pvt *pvt;
struct ast_variable *v;
struct ast_calendar *cal = void_data;
ast_mutex_t refreshlock;
if (!(cal && calendar_config)) {
ast_log(LOG_ERROR, "You must enable calendar support for res_caldav to load\n");
return NULL;
}
if (ao2_trylock(cal)) {
if (cal->unloading) {
ast_log(LOG_WARNING, "Unloading module, load_calendar cancelled.\n");
} else {
ast_log(LOG_WARNING, "Could not lock calendar, aborting!\n");
}
return NULL;
}
if (!(pvt = ao2_alloc(sizeof(*pvt), caldav_destructor))) {
ast_log(LOG_ERROR, "Could not allocate caldav_pvt structure for calendar: %s\n", cal->name);
return NULL;
}
pvt->owner = cal;
if (!(pvt->events = ast_calendar_event_container_alloc())) {
ast_log(LOG_ERROR, "Could not allocate space for fetching events for calendar: %s\n", cal->name);
pvt = unref_caldav(pvt);
ao2_unlock(cal);
return NULL;
}
if (ast_string_field_init(pvt, 32)) {
ast_log(LOG_ERROR, "Couldn't allocate string field space for calendar: %s\n", cal->name);
pvt = unref_caldav(pvt);
ao2_unlock(cal);
return NULL;
}
for (v = ast_variable_browse(calendar_config, cal->name); v; v = v->next) {
if (!strcasecmp(v->name, "url")) {
ast_string_field_set(pvt, url, v->value);
} else if (!strcasecmp(v->name, "user")) {
ast_string_field_set(pvt, user, v->value);
} else if (!strcasecmp(v->name, "secret")) {
ast_string_field_set(pvt, secret, v->value);
}
}
if (ast_strlen_zero(pvt->url)) {
ast_log(LOG_WARNING, "No URL was specified for CalDAV calendar '%s' - skipping.\n", cal->name);
pvt = unref_caldav(pvt);
ao2_unlock(cal);
return NULL;
}
if (ne_uri_parse(pvt->url, &pvt->uri) || pvt->uri.host == NULL || pvt->uri.path == NULL) {
ast_log(LOG_WARNING, "Could not parse url '%s' for CalDAV calendar '%s' - skipping.\n", pvt->url, cal->name);
pvt = unref_caldav(pvt);
ao2_unlock(cal);
return NULL;
}
if (pvt->uri.scheme == NULL) {
pvt->uri.scheme = "http";
}
if (pvt->uri.port == 0) {
pvt->uri.port = ne_uri_defaultport(pvt->uri.scheme);
}
pvt->session = ne_session_create(pvt->uri.scheme, pvt->uri.host, pvt->uri.port);
ne_set_server_auth(pvt->session, auth_credentials, pvt);
if (!strncasecmp(pvt->uri.scheme, "https", sizeof(pvt->uri.scheme))) {
ne_ssl_trust_default_ca(pvt->session);
ne_ssl_set_verify(pvt->session, verify_cert, NULL);
}
cal->tech_pvt = pvt;
ast_mutex_init(&refreshlock);
/* Load it the first time */
update_caldav(pvt);
ao2_unlock(cal);
/* The only writing from another thread will be if unload is true */
for (;;) {
struct timeval tv = ast_tvnow();
struct timespec ts = {0,};
ts.tv_sec = tv.tv_sec + (60 * pvt->owner->refresh);
ast_mutex_lock(&refreshlock);
while (!pvt->owner->unloading) {
if (ast_cond_timedwait(&pvt->owner->unload, &refreshlock, &ts) == ETIMEDOUT) {
break;
}
}
ast_mutex_unlock(&refreshlock);
if (pvt->owner->unloading) {
ast_debug(10, "Skipping refresh since we got a shutdown signal\n");
return NULL;
}
ast_debug(10, "Refreshing after %d minute timeout\n", pvt->owner->refresh);
update_caldav(pvt);
}
return NULL;
}
static int load_module(void)
{
ne_sock_init();
if (ast_calendar_register(&caldav_tech)) {
ne_sock_exit();
return AST_MODULE_LOAD_DECLINE;
}
return AST_MODULE_LOAD_SUCCESS;
}
static int unload_module(void)
{
ast_calendar_unregister(&caldav_tech);
ne_sock_exit();
return 0;
}
AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "Asterisk CalDAV Calendar Integration",
.load = load_module,
.unload = unload_module,
);

757
res/res_calendar_exchange.c Normal file
View File

@ -0,0 +1,757 @@
/*
* Asterisk -- An open source telephony toolkit.
*
* Copyright (C) 2008 - 2009, Digium, Inc.
*
* Terry Wilson <twilson@digium.com>
*
* See http://www.asterisk.org for more information about
* the Asterisk project. Please do not directly contact
* any of the maintainers of this project for assistance;
* the project provides a web site, mailing lists and IRC
* channels for your use.
*
* This program is free software, distributed under the terms of
* the GNU General Public License Version 2. See the LICENSE file
* at the top of the source tree.
*/
/*! \file
* \brief Resource for handling iCalnedar calendars
*/
/*** MODULEINFO
<depend>neon</depend>
<depend>ical</depend>
<depend>iksemel</depend>
***/
#include "asterisk.h"
ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
#include <libical/ical.h>
#include <neon/ne_session.h>
#include <neon/ne_uri.h>
#include <neon/ne_request.h>
#include <neon/ne_auth.h>
#include <iksemel.h>
#include "asterisk/module.h"
#include "asterisk/calendar.h"
#include "asterisk/lock.h"
#include "asterisk/config.h"
#include "asterisk/astobj2.h"
static void *exchangecal_load_calendar(void *data);
static void *unref_exchangecal(void *obj);
static int exchangecal_write_event(struct ast_calendar_event *event);
static struct ast_calendar_tech exchangecal_tech = {
.type = "exchange",
.description = "MS Exchange calendars",
.module = AST_MODULE,
.load_calendar = exchangecal_load_calendar,
.unref_calendar = unref_exchangecal,
.write_event = exchangecal_write_event,
};
struct exchangecal_pvt {
AST_DECLARE_STRING_FIELDS(
AST_STRING_FIELD(url);
AST_STRING_FIELD(user);
AST_STRING_FIELD(secret);
);
struct ast_calendar *owner;
ne_uri uri;
ne_session *session;
struct ao2_container *events;
};
struct xmlstate {
char tag[80];
int in_response;
int in_propstat;
int in_prop;
void *ptr;
struct exchangecal_pvt *pvt;
};
static int parse_tag(void *data, char *name, char **atts, int type)
{
struct xmlstate *state = data;
char *tmp;
if ((tmp = strchr(name, ':'))) {
tmp++;
} else {
return IKS_HOOK;
}
ast_copy_string(state->tag, tmp, sizeof(state->tag));
switch (type) {
case IKS_OPEN:
if (!strcasecmp(state->tag, "response")) {
struct ast_calendar_event *event;
state->in_response = 1;
if (!(event = ast_calendar_event_alloc(state->pvt->owner))) {
return IKS_NOMEM;
}
state->ptr = event;
} else if (!strcasecmp(state->tag, "propstat")) {
state->in_propstat = 1;
} else if (!strcasecmp(state->tag, "prop")) {
state->in_prop = 1;
}
break;
case IKS_CLOSE:
if (!strcasecmp(state->tag, "response")) {
struct ao2_container *events = state->pvt->events;
struct ast_calendar_event *event = state->ptr;
state->in_response = 0;
if (ast_strlen_zero(event->uid)) {
ast_log(LOG_ERROR, "This event has no UID, something has gone wrong\n");
event = ast_calendar_unref_event(event);
return IKS_HOOK;
}
ao2_link(events, event);
event = ast_calendar_unref_event(event);
} else if (!strcasecmp(state->tag, "propstat")) {
state->in_propstat = 0;
} else if (!strcasecmp(state->tag, "prop")) {
state->in_prop = 0;
}
break;
default:
return IKS_OK;
}
return IKS_OK;
}
static time_t mstime_to_time_t(char *mstime)
{
char *read, *write;
icaltimetype tt;
for (read = write = mstime; *read; read++) {
if (*read == '.') {
*write++ = 'Z';
*write = '\0';
break;
}
if (*read == '-' || *read == ':')
continue;
*write = *read;
write++;
}
tt = icaltime_from_string(mstime);
return icaltime_as_timet(tt);
}
static enum ast_calendar_busy_state msbusy_to_bs(const char *msbusy)
{
if (!strcasecmp(msbusy, "FREE")) {
return AST_CALENDAR_BS_FREE;
} else if (!strcasecmp(msbusy, "TENTATIVE")) {
return AST_CALENDAR_BS_BUSY_TENTATIVE;
} else {
return AST_CALENDAR_BS_BUSY;
}
}
static int parse_cdata(void *data, char *value, size_t len)
{
char *str;
struct xmlstate *state = data;
struct ast_calendar_event *event = state->ptr;
str = ast_skip_blanks(value);
if (str == value + len)
return IKS_OK;
if (!(str = ast_calloc(1, len + 1))) {
return IKS_NOMEM;
}
memcpy(str, value, len);
if (!(state->in_response && state->in_propstat && state->in_prop)) {
ast_free(str);
return IKS_OK;
}
/* We use ast_string_field_build here because libiksemel is parsing CDATA with &lt; as
* new elements which is a bit odd and shouldn't happen */
if (!strcasecmp(state->tag, "subject")) {
ast_string_field_build(event, summary, "%s%s", event->summary, str);
} else if (!strcasecmp(state->tag, "location")) {
ast_string_field_build(event, location, "%s%s", event->location, str);
} else if (!strcasecmp(state->tag, "uid")) {
ast_string_field_build(event, uid, "%s%s", event->location, str);
} else if (!strcasecmp(state->tag, "organizer")) {
ast_string_field_build(event, organizer, "%s%s", event->organizer, str);
} else if (!strcasecmp(state->tag, "textdescription")) {
ast_string_field_build(event, description, "%s%s", event->description, str);
} else if (!strcasecmp(state->tag, "dtstart")) {
event->start = mstime_to_time_t(str);
} else if (!strcasecmp(state->tag, "dtend")) {
event->end = mstime_to_time_t(str);
} else if (!strcasecmp(state->tag, "busystatus")) {
event->busy_state = msbusy_to_bs(str);
} else if (!strcasecmp(state->tag, "reminderoffset")) {
/*XXX Currently we rely on event->start being set first which means we rely on the response order
* which technically should be fine since the query returns in the order we ask for, but ... */
event->alarm = event->start - atoi(str);
}
ast_free(str);
return IKS_OK;
}
static int cb_true(void *user_data, void *arg, int flags)
{
return CMP_MATCH;
}
static void exchangecal_destructor(void *obj)
{
struct exchangecal_pvt *pvt = obj;
ast_debug(1, "Destroying pvt for Exchange calendar %s\n", pvt->owner->name);
if (pvt->session) {
ne_session_destroy(pvt->session);
}
ast_string_field_free_memory(pvt);
ao2_callback(pvt->events, OBJ_UNLINK | OBJ_NODATA | OBJ_MULTIPLE, cb_true, NULL);
ao2_ref(pvt->events, -1);
}
static void *unref_exchangecal(void *obj)
{
struct exchangecal_pvt *pvt = obj;
ao2_ref(pvt, -1);
return NULL;
}
/* It is very important to use the return value of this function as a realloc could occur */
static struct ast_str *generate_exchange_uuid(struct ast_str *uid)
{
unsigned short val[8];
int x;
for (x = 0; x < 8; x++) {
val[x] = ast_random();
}
ast_str_set(&uid, 0, "%04x%04x-%04x-%04x-%04x-%04x%04x%04x", val[0], val[1], val[2], val[3], val[4], val[5], val[6], val[7]);
return uid;
}
static int is_valid_uuid(struct ast_str *uid)
{
int i;
if (ast_str_strlen(uid) != 36) {
return 0;
}
for (i = 0; i < ast_str_strlen(uid); i++) {
if (i == 8 || i == 13 || i == 18 || i == 23) {
if (ast_str_buffer(uid)[i] != '-') {
return 0;
}
} else if (!((ast_str_buffer(uid)[i] > 47 && ast_str_buffer(uid)[i] < 58) || (ast_str_buffer(uid)[i] > 96 && ast_str_buffer(uid)[i] < 103))) {
return 0;
}
}
return 1;
}
static struct ast_str *xml_encode_str(struct ast_str *dst, const char *src)
{
const char *tmp;
char buf[7];
for (tmp = src; *tmp; tmp++) {
switch (*tmp) {
case '\"':
strcpy(buf, "&quot;");
break;
case '\'':
strcpy(buf, "&apos;");
break;
case '&':
strcpy(buf, "&amp;");
break;
case '<':
strcpy(buf, "&lt;");
break;
case '>':
strcpy(buf, "&gt;");
break;
default:
sprintf(buf, "%c", *tmp);
}
ast_str_append(&dst, 0, "%s", buf);
}
return dst;
}
static struct ast_str *epoch_to_exchange_time(struct ast_str *dst, time_t epoch)
{
icaltimezone *utc = icaltimezone_get_utc_timezone();
icaltimetype tt = icaltime_from_timet_with_zone(epoch, 0, utc);
char tmp[30];
int i;
ast_copy_string(tmp, icaltime_as_ical_string(tt), sizeof(tmp));
for (i = 0; tmp[i]; i++) {
ast_str_append(&dst, 0, "%c", tmp[i]);
if (i == 3 || i == 5)
ast_str_append(&dst, 0, "%c", '-');
if (i == 10 || i == 12)
ast_str_append(&dst, 0, "%c", ':');
if (i == 14)
ast_str_append(&dst, 0, "%s", ".000");
}
return dst;
}
static struct ast_str *bs_to_exchange_bs(struct ast_str *dst, enum ast_calendar_busy_state bs)
{
switch (bs) {
case AST_CALENDAR_BS_BUSY:
ast_str_set(&dst, 0, "%s", "BUSY");
break;
case AST_CALENDAR_BS_BUSY_TENTATIVE:
ast_str_set(&dst, 0, "%s", "TENTATIVE");
break;
default:
ast_str_set(&dst, 0, "%s", "FREE");
}
return dst;
}
static int fetch_response_reader(void *data, const char *block, size_t len)
{
struct ast_str **response = data;
unsigned char *tmp;
if (!(tmp = ast_malloc(len + 1))) {
return -1;
}
memcpy(tmp, block, len);
tmp[len] = '\0';
ast_str_append(response, 0, "%s", tmp);
ast_free(tmp);
return 0;
}
static int auth_credentials(void *userdata, const char *realm, int attempts, char *username, char *secret)
{
struct exchangecal_pvt *pvt = userdata;
if (attempts > 1) {
ast_log(LOG_WARNING, "Invalid username or password for Exchange calendar '%s'\n", pvt->owner->name);
return -1;
}
ne_strnzcpy(username, pvt->user, NE_ABUFSIZ);
ne_strnzcpy(secret, pvt->secret, NE_ABUFSIZ);
return 0;
}
static struct ast_str *exchangecal_request(struct exchangecal_pvt *pvt, const char *method, struct ast_str *req_body, struct ast_str *subdir)
{
struct ast_str *response;
ne_request *req;
int ret;
char buf[1000];
if (!pvt) {
ast_log(LOG_ERROR, "There is no private!\n");
return NULL;
}
if (!(response = ast_str_create(512))) {
ast_log(LOG_ERROR, "Could not allocate memory for response.\n");
return NULL;
}
snprintf(buf, sizeof(buf), "%s%s", pvt->uri.path, subdir ? ast_str_buffer(subdir) : "");
req = ne_request_create(pvt->session, method, buf);
ne_add_response_body_reader(req, ne_accept_2xx, fetch_response_reader, &response);
ne_set_request_body_buffer(req, ast_str_buffer(req_body), ast_str_strlen(req_body));
ne_add_request_header(req, "Content-type", "text/xml");
ret = ne_request_dispatch(req);
if (ret != NE_OK || !ast_str_strlen(response)) {
ast_log(LOG_WARNING, "Unknown response to CalDAV calendar %s, request %s to %s: %s\n", pvt->owner->name, method, pvt->url, ne_get_error(pvt->session));
ast_free(response);
return NULL;
}
return response;
}
static int exchangecal_write_event(struct ast_calendar_event *event)
{
struct ast_str *body = NULL, *response = NULL, *subdir = NULL;
struct ast_str *uid = NULL, *summary = NULL, *description = NULL, *organizer = NULL,
*location = NULL, *start = NULL, *end = NULL, *busystate = NULL;
int ret = -1;
if (!event) {
ast_log(LOG_WARNING, "No event passed!\n");
return -1;
}
if (!(event->start && event->end)) {
ast_log(LOG_WARNING, "The event must contain a start and an end\n");
return -1;
}
if (!(body = ast_str_create(512)) ||
!(subdir = ast_str_create(32)) ||
!(response = ast_str_create(512))) {
ast_log(LOG_ERROR, "Could not allocate memory for request and response!\n");
goto write_cleanup;
}
if (!(uid = ast_str_create(32)) ||
!(summary = ast_str_create(32)) ||
!(description = ast_str_create(32)) ||
!(organizer = ast_str_create(32)) ||
!(location = ast_str_create(32)) ||
!(start = ast_str_create(32)) ||
!(end = ast_str_create(32)) ||
!(busystate = ast_str_create(32))) {
ast_log(LOG_ERROR, "Unable to allocate memory for request values\n");
goto write_cleanup;
}
if (ast_strlen_zero(event->uid)) {
uid = generate_exchange_uuid(uid);
} else {
ast_str_set(&uid, 36, "%s", event->uid);
}
if (!is_valid_uuid(uid)) {
ast_log(LOG_WARNING, "An invalid uid was provided, you may leave this field blank to have one generated for you\n");
goto write_cleanup;
}
summary = xml_encode_str(summary, event->summary);
description = xml_encode_str(description, event->description);
organizer = xml_encode_str(organizer, event->organizer);
location = xml_encode_str(location, event->location);
start = epoch_to_exchange_time(start, event->start);
end = epoch_to_exchange_time(end, event->end);
busystate = bs_to_exchange_bs(busystate, event->busy_state);
ast_str_append(&body, 0,
"<?xml version=\"1.0\"?>\n"
"<a:propertyupdate\n"
" xmlns:a=\"DAV:\"\n"
" xmlns:e=\"http://schemas.microsoft.com/exchange/\"\n"
" xmlns:mapi=\"http://schemas.microsoft.com/mapi/\"\n"
" xmlns:mapit=\"http://schemas.microsoft.com/mapi/proptag/\"\n"
" xmlns:x=\"xml:\" xmlns:cal=\"urn:schemas:calendar:\"\n"
" xmlns:dt=\"uuid:%s/\"\n" /* uid */
" xmlns:header=\"urn:schemas:mailheader:\"\n"
" xmlns:mail=\"urn:schemas:httpmail:\"\n"
">\n"
" <a:set>\n"
" <a:prop>\n"
" <a:contentclass>urn:content-classes:appointment</a:contentclass>\n"
" <e:outlookmessageclass>IPM.Appointment</e:outlookmessageclass>\n"
" <mail:subject>%s</mail:subject>\n" /* summary */
" <mail:description>%s</mail:description>\n" /* description */
" <header:to>%s</header:to>\n" /* organizer */
" <cal:location>%s</cal:location>\n" /* location */
" <cal:dtstart dt:dt=\"dateTime.tz\">%s</cal:dtstart>\n" /* start */
" <cal:dtend dt:dt=\"dateTime.tz\">%s</cal:dtend>\n" /* end */
" <cal:instancetype dt:dt=\"int\">0</cal:instancetype>\n"
" <cal:busystatus>%s</cal:busystatus>\n" /* busy_state (BUSY, FREE, BUSY_TENTATIVE) */
" <cal:meetingstatus>CONFIRMED</cal:meetingstatus>\n"
" <cal:alldayevent dt:dt=\"boolean\">0</cal:alldayevent>\n" /* XXX need to add event support for all day events */
" <cal:responserequested dt:dt=\"boolean\">0</cal:responserequested>\n"
" <mapi:finvited dt:dt=\"boolean\">1</mapi:finvited>\n"
" </a:prop>\n"
" </a:set>\n"
"</a:propertyupdate>\n",
ast_str_buffer(uid), ast_str_buffer(summary), ast_str_buffer(description), ast_str_buffer(organizer), ast_str_buffer(location), ast_str_buffer(start), ast_str_buffer(end), ast_str_buffer(busystate));
ast_verb(0, "\n\n%s\n\n", ast_str_buffer(body));
ast_str_set(&subdir, 0, "/Calendar/%s.eml", ast_str_buffer(uid));
response = exchangecal_request(event->owner->tech_pvt, "PROPPATCH", body, subdir);
ret = 0;
write_cleanup:
if (uid) {
ast_free(uid);
}
if (summary) {
ast_free(summary);
}
if (description) {
ast_free(description);
}
if (organizer) {
ast_free(organizer);
}
if (location) {
ast_free(location);
}
if (start) {
ast_free(start);
}
if (end) {
ast_free(end);
}
if (busystate) {
ast_free(busystate);
}
if (body) {
ast_free(body);
}
if (response) {
ast_free(response);
}
if (subdir) {
ast_free(subdir);
}
return ret;
}
static struct ast_str *exchangecal_get_events_between(struct exchangecal_pvt *pvt, time_t start_time, time_t end_time)
{
struct ast_str *body, *response;
char start[80], end[80];
struct timeval tv = {0,};
struct ast_tm tm;
tv.tv_sec = start_time;
ast_localtime(&tv, &tm, "UTC");
ast_strftime(start, sizeof(start), "%Y/%m/%d %T", &tm);
tv.tv_sec = end_time;
ast_localtime(&tv, &tm, "UTC");
ast_strftime(end, sizeof(end), "%Y/%m/%d %T", &tm);
if (!(body = ast_str_create(512))) {
ast_log(LOG_ERROR, "Could not allocate memory for body of request!\n");
return NULL;
}
ast_str_append(&body, 0,
"<?xml version=\"1.0\"?>\n"
"<g:searchrequest xmlns:g=\"DAV:\">\n"
" <g:sql> SELECT \"urn:schemas:calendar:location\", \"urn:schemas:httpmail:subject\",\n"
" \"urn:schemas:calendar:dtstart\", \"urn:schemas:calendar:dtend\",\n"
" \"urn:schemas:calendar:busystatus\", \"urn:schemas:calendar:instancetype\",\n"
" \"urn:schemas:calendar:uid\", \"urn:schemas:httpmail:textdescription\",\n"
" \"urn:schemas:calendar:organizer\", \"urn:schemas:calendar:reminderoffset\"\n"
" FROM Scope('SHALLOW TRAVERSAL OF \"%s/Calendar\"')\n"
" WHERE NOT \"urn:schemas:calendar:instancetype\" = 1\n"
" AND \"DAV:contentclass\" = 'urn:content-classes:appointment'\n"
" AND NOT (\"urn:schemas:calendar:dtend\" &lt; '%s'\n"
" OR \"urn:schemas:calendar:dtstart\" &gt; '%s')\n"
" ORDER BY \"urn:schemas:calendar:dtstart\" ASC\n"
" </g:sql>\n"
"</g:searchrequest>\n", pvt->url, start, end);
ast_debug(5, "Request:\n%s\n", ast_str_buffer(body));
response = exchangecal_request(pvt, "SEARCH", body, NULL);
ast_debug(5, "Response:\n%s\n", ast_str_buffer(response));
ast_free(body);
return response;
}
static int update_exchangecal(struct exchangecal_pvt *pvt)
{
struct xmlstate state;
struct timeval now = ast_tvnow();
time_t start, end;
struct ast_str *response;
iksparser *p;
state.pvt = pvt;
start = now.tv_sec;
end = now.tv_sec + 60 * pvt->owner->timeframe;
if (!(response = exchangecal_get_events_between(pvt, start, end))) {
return -1;
}
p = iks_sax_new(&state, parse_tag, parse_cdata);
iks_parse(p, ast_str_buffer(response), ast_str_strlen(response), 1);
ast_calendar_merge_events(pvt->owner, pvt->events);
ast_free(response);
return 0;
}
static void *exchangecal_load_calendar(void *void_data)
{
struct exchangecal_pvt *pvt;
struct ast_variable *v;
struct ast_calendar *cal = void_data;
ast_mutex_t refreshlock;
if (!(cal && calendar_config)) {
ast_log(LOG_ERROR, "You must enable calendar support for res_exchangecal to load\n");
return NULL;
}
if (ao2_trylock(cal)) {
if (cal->unloading) {
ast_log(LOG_WARNING, "Unloading module, load_calendar cancelled.\n");
} else {
ast_log(LOG_WARNING, "Could not lock calendar, aborting!\n");
}
return NULL;
}
if (!(pvt = ao2_alloc(sizeof(*pvt), exchangecal_destructor))) {
ast_log(LOG_ERROR, "Could not allocate exchangecal_pvt structure for calendar: %s\n", cal->name);
return NULL;
}
pvt->owner = cal;
if (!(pvt->events = ast_calendar_event_container_alloc())) {
ast_log(LOG_ERROR, "Could not allocate space for fetching events for calendar: %s\n", cal->name);
pvt = unref_exchangecal(pvt);
ao2_unlock(cal);
return NULL;
}
if (ast_string_field_init(pvt, 32)) {
ast_log(LOG_ERROR, "Couldn't allocate string field space for calendar: %s\n", cal->name);
pvt = unref_exchangecal(pvt);
ao2_unlock(cal);
return NULL;
}
for (v = ast_variable_browse(calendar_config, cal->name); v; v = v->next) {
if (!strcasecmp(v->name, "url")) {
ast_string_field_set(pvt, url, v->value);
} else if (!strcasecmp(v->name, "user")) {
ast_string_field_set(pvt, user, v->value);
} else if (!strcasecmp(v->name, "secret")) {
ast_string_field_set(pvt, secret, v->value);
}
}
if (ast_strlen_zero(pvt->url)) {
ast_log(LOG_WARNING, "No URL was specified for Exchange calendar '%s' - skipping.\n", cal->name);
pvt = unref_exchangecal(pvt);
ao2_unlock(cal);
return NULL;
}
if (ne_uri_parse(pvt->url, &pvt->uri) || pvt->uri.host == NULL || pvt->uri.path == NULL) {
ast_log(LOG_WARNING, "Could not parse url '%s' for Exchange calendar '%s' - skipping.\n", pvt->url, cal->name);
pvt = unref_exchangecal(pvt);
ao2_unlock(cal);
return NULL;
}
if (pvt->uri.scheme == NULL) {
pvt->uri.scheme = "http";
}
if (pvt->uri.port == 0) {
pvt->uri.port = ne_uri_defaultport(pvt->uri.scheme);
}
pvt->session = ne_session_create(pvt->uri.scheme, pvt->uri.host, pvt->uri.port);
ne_set_server_auth(pvt->session, auth_credentials, pvt);
if (!strncasecmp(pvt->uri.scheme, "https", sizeof(pvt->uri.scheme))) {
ne_ssl_trust_default_ca(pvt->session);
}
cal->tech_pvt = pvt;
ast_mutex_init(&refreshlock);
/* Load it the first time */
update_exchangecal(pvt);
ao2_unlock(cal);
/* The only writing from another thread will be if unload is true */
for (;;) {
struct timeval tv = ast_tvnow();
struct timespec ts = {0,};
ts.tv_sec = tv.tv_sec + (60 * pvt->owner->refresh);
ast_mutex_lock(&refreshlock);
while (!pvt->owner->unloading) {
if (ast_cond_timedwait(&pvt->owner->unload, &refreshlock, &ts) == ETIMEDOUT) {
break;
}
}
ast_mutex_unlock(&refreshlock);
if (pvt->owner->unloading) {
ast_debug(10, "Skipping refresh since we got a shutdown signal\n");
return NULL;
}
ast_debug(10, "Refreshing after %d minute timeout\n", pvt->owner->refresh);
update_exchangecal(pvt);
}
return NULL;
}
static int load_module(void)
{
ne_sock_init();
if (ast_calendar_register(&exchangecal_tech)) {
ne_sock_exit();
return AST_MODULE_LOAD_DECLINE;
}
return AST_MODULE_LOAD_SUCCESS;
}
static int unload_module(void)
{
ast_calendar_unregister(&exchangecal_tech);
ne_sock_exit();
return 0;
}
AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "Asterisk MS Exchange Calendar Integration",
.load = load_module,
.unload = unload_module,
);

470
res/res_calendar_icalendar.c Normal file
View File

@ -0,0 +1,470 @@
/*
* Asterisk -- An open source telephony toolkit.
*
* Copyright (C) 2008 - 2009, Digium, Inc.
*
* Terry Wilson <twilson@digium.com>
*
* See http://www.asterisk.org for more information about
* the Asterisk project. Please do not directly contact
* any of the maintainers of this project for assistance;
* the project provides a web site, mailing lists and IRC
* channels for your use.
*
* This program is free software, distributed under the terms of
* the GNU General Public License Version 2. See the LICENSE file
* at the top of the source tree.
*/
/*! \file
* \brief Resource for handling iCalnedar calendars
*/
/*** MODULEINFO
<depend>neon</depend>
<depend>ical</depend>
***/
#include "asterisk.h"
ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
#include <libical/ical.h>
#include <neon/ne_session.h>
#include <neon/ne_uri.h>
#include <neon/ne_request.h>
#include <neon/ne_auth.h>
#include "asterisk/module.h"
#include "asterisk/calendar.h"
#include "asterisk/lock.h"
#include "asterisk/config.h"
#include "asterisk/astobj2.h"
static void *ical_load_calendar(void *data);
static void *unref_icalendar(void *obj);
static struct ast_calendar_tech ical_tech = {
.type = "ical",
.module = AST_MODULE,
.description = "iCalendar .ics calendars",
.load_calendar = ical_load_calendar,
.unref_calendar = unref_icalendar,
};
struct icalendar_pvt {
AST_DECLARE_STRING_FIELDS(
AST_STRING_FIELD(url);
AST_STRING_FIELD(user);
AST_STRING_FIELD(secret);
);
struct ast_calendar *owner;
ne_uri uri;
ne_session *session;
icalcomponent *data;
struct ao2_container *events;
};
static int cb_true(void *user_data, void *arg, int flags)
{
return CMP_MATCH;
}
static void icalendar_destructor(void *obj)
{
struct icalendar_pvt *pvt = obj;
ast_debug(1, "Destroying pvt for iCalendar %s\n", pvt->owner->name);
if (pvt->session) {
ne_session_destroy(pvt->session);
}
if (pvt->data) {
icalcomponent_free(pvt->data);
}
ast_string_field_free_memory(pvt);
ao2_callback(pvt->events, OBJ_UNLINK | OBJ_NODATA | OBJ_MULTIPLE, cb_true, NULL);
ao2_ref(pvt->events, -1);
}
static void *unref_icalendar(void *obj)
{
struct icalendar_pvt *pvt = obj;
ao2_ref(pvt, -1);
return NULL;
}
static int fetch_response_reader(void *data, const char *block, size_t len)
{
struct ast_str **response = data;
unsigned char *tmp;
if (!(tmp = ast_malloc(len + 1))) {
return -1;
}
memcpy(tmp, block, len);
tmp[len] = '\0';
ast_str_append(response, 0, "%s", tmp);
ast_free(tmp);
return 0;
}
static int auth_credentials(void *userdata, const char *realm, int attempts, char *username, char *secret)
{
struct icalendar_pvt *pvt = userdata;
if (attempts > 1) {
ast_log(LOG_WARNING, "Invalid username or password for iCalendar '%s'\n", pvt->owner->name);
return -1;
}
ne_strnzcpy(username, pvt->user, NE_ABUFSIZ);
ne_strnzcpy(secret, pvt->secret, NE_ABUFSIZ);
return 0;
}
static icalcomponent *fetch_icalendar(struct icalendar_pvt *pvt)
{
int ret;
struct ast_str *response;
ne_request *req;
icalcomponent *comp = NULL;
if (!pvt) {
ast_log(LOG_ERROR, "There is no private!\n");
}
if (!(response = ast_str_create(512))) {
ast_log(LOG_ERROR, "Could not allocate memory for response.\n");
return NULL;
}
req = ne_request_create(pvt->session, "GET", pvt->uri.path);
ne_add_response_body_reader(req, ne_accept_2xx, fetch_response_reader, &response);
ret = ne_request_dispatch(req);
if (ret != NE_OK || !ast_str_strlen(response)) {
ast_log(LOG_WARNING, "Unable to retrieve iCalendar '%s' from '%s': %s\n", pvt->owner->name, pvt->url, ne_get_error(pvt->session));
ast_free(response);
return NULL;
}
if (!ast_strlen_zero(ast_str_buffer(response))) {
comp = icalparser_parse_string(ast_str_buffer(response));
}
ast_free(response);
return comp;
}
static void icalendar_add_event(icalcomponent *comp, struct icaltime_span *span, void *data)
{
struct icalendar_pvt *pvt = data;
struct ast_calendar_event *event;
icaltimezone *utc = icaltimezone_get_utc_timezone();
icaltimetype start, end, tmp;
icalcomponent *valarm;
icalproperty *prop;
struct icaltriggertype trigger;
if (!(pvt && pvt->owner)) {
ast_log(LOG_ERROR, "Require a private structure with an ownenr\n");
return;
}
if (!(event = ast_calendar_event_alloc(pvt->owner))) {
ast_log(LOG_ERROR, "Could not allocate an event!\n");
return;
}
start = icaltime_from_timet_with_zone(span->start, 0, utc);
end = icaltime_from_timet_with_zone(span->end, 0, utc);
event->start = span->start;
event->end = span->end;
switch(icalcomponent_get_status(comp)) {
case ICAL_STATUS_CONFIRMED:
event->busy_state = AST_CALENDAR_BS_BUSY;
break;
case ICAL_STATUS_TENTATIVE:
event->busy_state = AST_CALENDAR_BS_BUSY_TENTATIVE;
break;
default:
event->busy_state = AST_CALENDAR_BS_FREE;
}
if ((prop = icalcomponent_get_first_property(comp, ICAL_SUMMARY_PROPERTY))) {
ast_string_field_set(event, summary, icalproperty_get_value_as_string(prop));
}
if ((prop = icalcomponent_get_first_property(comp, ICAL_DESCRIPTION_PROPERTY))) {
ast_string_field_set(event, description, icalproperty_get_value_as_string(prop));
}
if ((prop = icalcomponent_get_first_property(comp, ICAL_ORGANIZER_PROPERTY))) {
ast_string_field_set(event, organizer, icalproperty_get_value_as_string(prop));
}
if ((prop = icalcomponent_get_first_property(comp, ICAL_LOCATION_PROPERTY))) {
ast_string_field_set(event, location, icalproperty_get_value_as_string(prop));
}
if ((prop = icalcomponent_get_first_property(comp, ICAL_UID_PROPERTY))) {
ast_string_field_set(event, uid, icalproperty_get_value_as_string(prop));
} else {
ast_log(LOG_WARNING, "No UID found, but one is required. Generating, but updates may not be acurate\n");
if (!ast_strlen_zero(event->summary)) {
ast_string_field_set(event, uid, event->summary);
} else {
char tmp[100];
snprintf(tmp, sizeof(tmp), "%lu", event->start);
ast_string_field_set(event, uid, tmp);
}
}
/* Get the attendees */
for (prop = icalcomponent_get_first_property(comp, ICAL_ATTENDEE_PROPERTY);
prop; prop = icalcomponent_get_next_property(comp, ICAL_ATTENDEE_PROPERTY)) {
struct ast_calendar_attendee *attendee;
const char *data;
if (!(attendee = ast_calloc(1, sizeof(*attendee)))) {
event = ast_calendar_unref_event(event);
return;
}
data = icalproperty_get_attendee(prop);
if (!ast_strlen_zero(data)) {
attendee->data = ast_strdup(data);;
AST_LIST_INSERT_TAIL(&event->attendees, attendee, next);
}
}
/* Only set values for alarm based on VALARM. Can be overriden in main/calendar.c by autoreminder
* therefore, go ahead and add events even if their is no VALARM or it is malformed
* Currently we are only getting the first VALARM and are handling repitition in main/calendar.c from calendar.conf */
if (!(valarm = icalcomponent_get_first_component(comp, ICAL_VALARM_COMPONENT))) {
ao2_link(pvt->events, event);
event = ast_calendar_unref_event(event);
return;
}
if (!(prop = icalcomponent_get_first_property(valarm, ICAL_TRIGGER_PROPERTY))) {
ast_log(LOG_WARNING, "VALARM has no TRIGGER, skipping!\n");
ao2_link(pvt->events, event);
event = ast_calendar_unref_event(event);
return;
}
trigger = icalproperty_get_trigger(prop);
if (icaltriggertype_is_null_trigger(trigger)) {
ast_log(LOG_WARNING, "Bad TRIGGER for VALARM, skipping!\n");
ao2_link(pvt->events, event);
event = ast_calendar_unref_event(event);
return;
}
if (!icaltime_is_null_time(trigger.time)) { /* This is an absolute time */
tmp = icaltime_convert_to_zone(trigger.time, utc);
event->alarm = icaltime_as_timet_with_zone(tmp, utc);
} else { /* Offset from either dtstart or dtend */
/* XXX Technically you can check RELATED to see if the event fires from the END of the event
* But, I'm not sure I've ever seen anyone implement it in calendaring software, so I'm ignoring for now */
tmp = icaltime_add(start, trigger.duration);
event->alarm = icaltime_as_timet_with_zone(tmp, utc);
}
ao2_link(pvt->events, event);
event = ast_calendar_unref_event(event);
return;
}
static void icalendar_update_events(struct icalendar_pvt *pvt)
{
struct icaltimetype start_time, end_time;
icalcomponent *iter;
if (!pvt) {
ast_log(LOG_ERROR, "iCalendar is NULL\n");
return;
}
if (!pvt->owner) {
ast_log(LOG_ERROR, "iCalendar is an orphan!\n");
return;
}
if (!pvt->data) {
ast_log(LOG_ERROR, "The iCalendar has not been parsed!\n");
return;
}
start_time = icaltime_current_time_with_zone(icaltimezone_get_utc_timezone());
end_time = icaltime_current_time_with_zone(icaltimezone_get_utc_timezone());
end_time.second += pvt->owner->timeframe * 60;
icaltime_normalize(end_time);
for (iter = icalcomponent_get_first_component(pvt->data, ICAL_VEVENT_COMPONENT);
iter;
iter = icalcomponent_get_next_component(pvt->data, ICAL_VEVENT_COMPONENT))
{
icalcomponent_foreach_recurrence(iter, start_time, end_time, icalendar_add_event, pvt);
}
ast_calendar_merge_events(pvt->owner, pvt->events);
}
static void *ical_load_calendar(void *void_data)
{
struct icalendar_pvt *pvt;
struct ast_variable *v;
struct ast_calendar *cal = void_data;
ast_mutex_t refreshlock;
if (!(cal && calendar_config)) {
ast_log(LOG_ERROR, "You must enable calendar support for res_icalendar to load\n");
return NULL;
}
if (ao2_trylock(cal)) {
if (cal->unloading) {
ast_log(LOG_WARNING, "Unloading module, load_calendar cancelled.\n");
} else {
ast_log(LOG_WARNING, "Could not lock calendar, aborting!\n");
}
return NULL;
}
if (!(pvt = ao2_alloc(sizeof(*pvt), icalendar_destructor))) {
ast_log(LOG_ERROR, "Could not allocate icalendar_pvt structure for calendar: %s\n", cal->name);
return NULL;
}
pvt->owner = cal;
if (!(pvt->events = ast_calendar_event_container_alloc())) {
ast_log(LOG_ERROR, "Could not allocate space for fetching events for calendar: %s\n", cal->name);
pvt = unref_icalendar(pvt);
ao2_unlock(cal);
return NULL;
}
if (ast_string_field_init(pvt, 32)) {
ast_log(LOG_ERROR, "Couldn't allocate string field space for calendar: %s\n", cal->name);
pvt = unref_icalendar(pvt);
ao2_unlock(cal);
return NULL;
}
for (v = ast_variable_browse(calendar_config, cal->name); v; v = v->next) {
if (!strcasecmp(v->name, "url")) {
ast_string_field_set(pvt, url, v->value);
} else if (!strcasecmp(v->name, "user")) {
ast_string_field_set(pvt, user, v->value);
} else if (!strcasecmp(v->name, "secret")) {
ast_string_field_set(pvt, secret, v->value);
}
}
if (ast_strlen_zero(pvt->url)) {
ast_log(LOG_WARNING, "No URL was specified for iCalendar '%s' - skipping.\n", cal->name);
pvt = unref_icalendar(pvt);
ao2_unlock(cal);
return NULL;
}
if (ne_uri_parse(pvt->url, &pvt->uri) || pvt->uri.host == NULL || pvt->uri.path == NULL) {
ast_log(LOG_WARNING, "Could not parse url '%s' for iCalendar '%s' - skipping.\n", pvt->url, cal->name);
pvt = unref_icalendar(pvt);
ao2_unlock(cal);
return NULL;
}
if (pvt->uri.scheme == NULL) {
pvt->uri.scheme = "http";
}
if (pvt->uri.port == 0) {
pvt->uri.port = ne_uri_defaultport(pvt->uri.scheme);
}
pvt->session = ne_session_create(pvt->uri.scheme, pvt->uri.host, pvt->uri.port);
ne_set_server_auth(pvt->session, auth_credentials, pvt);
if (!strncasecmp(pvt->uri.scheme, "https", sizeof(pvt->uri.scheme))) {
ne_ssl_trust_default_ca(pvt->session);
}
cal->tech_pvt = pvt;
ast_mutex_init(&refreshlock);
/* Load it the first time */
if (!(pvt->data = fetch_icalendar(pvt))) {
ast_log(LOG_WARNING, "Unable to parse iCalendar '%s'\n", cal->name);
}
icalendar_update_events(pvt);
ao2_unlock(cal);
/* The only writing from another thread will be if unload is true */
for(;;) {
struct timeval tv = ast_tvnow();
struct timespec ts = {0,};
ts.tv_sec = tv.tv_sec + (60 * pvt->owner->refresh);
ast_mutex_lock(&refreshlock);
while (!pvt->owner->unloading) {
if (ast_cond_timedwait(&pvt->owner->unload, &refreshlock, &ts) == ETIMEDOUT) {
break;
}
}
ast_mutex_unlock(&refreshlock);
if (pvt->owner->unloading) {
ast_debug(10, "Skipping refresh since we got a shutdown signal\n");
return NULL;
}
ast_debug(10, "Refreshing after %d minute timeout\n", pvt->owner->refresh);
if (!(pvt->data = fetch_icalendar(pvt))) {
ast_log(LOG_WARNING, "Unable to parse iCalendar '%s'\n", pvt->owner->name);
continue;
}
icalendar_update_events(pvt);
}
return NULL;
}
static int load_module(void)
{
ne_sock_init();
if (ast_calendar_register(&ical_tech)) {
ne_sock_exit();
return AST_MODULE_LOAD_DECLINE;
}
return AST_MODULE_LOAD_SUCCESS;
}
static int unload_module(void)
{
ast_calendar_unregister(&ical_tech);
ne_sock_exit();
return 0;
}
AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "Asterisk iCalendar .ics file integration",
.load = load_module,
.unload = unload_module,
);