res_calendar_exchange.c File Reference

Resource for handling MS Exchange calendars. More...

#include "asterisk.h"
#include <libical/ical.h>
#include <ne_session.h>
#include <ne_uri.h>
#include <ne_request.h>
#include <ne_auth.h>
#include <ne_redirect.h>
#include <iksemel.h>
#include "asterisk/module.h"
#include "asterisk/channel.h"
#include "asterisk/calendar.h"
#include "asterisk/lock.h"
#include "asterisk/config.h"
#include "asterisk/astobj2.h"
#include "asterisk/uuid.h"

Include dependency graph for res_calendar_exchange.c:

Go to the source code of this file.

Data Structures
struct	exchangecal_pvt
struct	xmlstate

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
struct ast_module *	AST_MODULE_SELF_SYM (void)
static int	auth_credentials (void *userdata, const char *realm, int attempts, char *username, char *secret)
static struct ast_str *	bs_to_exchange_bs (struct ast_str *dst, enum ast_calendar_busy_state bs)
static struct ast_str *	epoch_to_exchange_time (struct ast_str *dst, time_t epoch)
static void	exchangecal_destructor (void *obj)
static struct ast_str *	exchangecal_get_events_between (struct exchangecal_pvt *pvt, time_t start_time, time_t end_time)
static void *	exchangecal_load_calendar (void *data)
static struct ast_str *	exchangecal_request (struct exchangecal_pvt *pvt, const char *method, struct ast_str *req_body, struct ast_str *subdir)
static int	exchangecal_write_event (struct ast_calendar_event *event)
static int	fetch_response_reader (void *data, const char *block, size_t len)
static struct ast_str *	generate_exchange_uuid (struct ast_str *uid)
static int	is_valid_uuid (struct ast_str *uid)
static int	load_module (void)
static enum ast_calendar_busy_state	msbusy_to_bs (const char *msbusy)
static time_t	mstime_to_time_t (char *mstime)
static int	parse_cdata (void *data, char *value, size_t len)
static int	parse_tag (void *data, char *name, char **atts, int type)
static int	unload_module (void)
static void *	unref_exchangecal (void *obj)
static int	update_exchangecal (struct exchangecal_pvt *pvt)
static struct ast_str *	xml_encode_str (struct ast_str *dst, const char *src)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Asterisk MS Exchange Calendar Integration" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_EXTENDED, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_DEVSTATE_PLUGIN, .requires = "res_calendar", }
static const struct ast_module_info *	ast_module_info = &__mod_info
static struct ast_calendar_tech	exchangecal_tech

Detailed Description

Resource for handling MS Exchange calendars.

Definition in file res_calendar_exchange.c.

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 749 of file res_calendar_exchange.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 749 of file res_calendar_exchange.c.

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 749 of file res_calendar_exchange.c.

auth_credentials()

static int auth_credentials ( void *  userdata, const char *  realm, int  attempts, char *  username, char *  secret  )

static

Definition at line 357 of file res_calendar_exchange.c.

{
    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;
}

References ast_log, LOG_WARNING, ast_calendar::name, exchangecal_pvt::owner, exchangecal_pvt::secret, and exchangecal_pvt::user.

Referenced by exchangecal_load_calendar().

bs_to_exchange_bs()

static struct ast_str * bs_to_exchange_bs ( struct ast_str *  dst, enum ast_calendar_busy_state  bs  )

static

Definition at line 323 of file res_calendar_exchange.c.

{
    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;
}

References AST_CALENDAR_BS_BUSY, AST_CALENDAR_BS_BUSY_TENTATIVE, ast_str_set(), and bs.

Referenced by exchangecal_write_event().

epoch_to_exchange_time()

static struct ast_str * epoch_to_exchange_time ( struct ast_str *  dst, time_t  epoch  )

static

Definition at line 302 of file res_calendar_exchange.c.

{
    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;
}

References ast_copy_string(), ast_str_append(), and tmp().

Referenced by exchangecal_write_event().

exchangecal_destructor()

static void exchangecal_destructor ( void *  obj )

static

Definition at line 219 of file res_calendar_exchange.c.

{
    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);
    }
    ne_uri_free(&pvt->uri);
    ast_string_field_free_memory(pvt);
 
    ao2_callback(pvt->events, OBJ_UNLINK | OBJ_NODATA | OBJ_MULTIPLE, NULL, NULL);
 
    ao2_ref(pvt->events, -1);
}

References ao2_callback, ao2_ref, ast_debug, ast_string_field_free_memory, exchangecal_pvt::events, ast_calendar::name, NULL, OBJ_MULTIPLE, OBJ_NODATA, OBJ_UNLINK, exchangecal_pvt::owner, exchangecal_pvt::session, and exchangecal_pvt::uri.

Referenced by exchangecal_load_calendar().

exchangecal_get_events_between()

static struct ast_str * exchangecal_get_events_between ( struct exchangecal_pvt *  pvt, time_t  start_time, time_t  end_time  )

static

Definition at line 532 of file res_calendar_exchange.c.

{
    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;
}

References ast_debug, ast_free, ast_localtime(), ast_log, ast_str_append(), ast_str_buffer(), ast_str_create, ast_strftime(), end, exchangecal_request(), LOG_ERROR, NULL, and exchangecal_pvt::url.

Referenced by update_exchangecal().

exchangecal_load_calendar()

static void * exchangecal_load_calendar ( void *  data )

static

Definition at line 600 of file res_calendar_exchange.c.

{
    struct exchangecal_pvt *pvt;
    const struct ast_config *cfg;
    struct ast_variable *v;
    struct ast_calendar *cal = void_data;
    ast_mutex_t refreshlock;
 
    if (!(cal && (cfg = ast_calendar_config_acquire()))) {
        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");
        }
        ast_calendar_config_release();
        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);
        ast_calendar_config_release();
        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);
        ast_calendar_config_release();
        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);
        ast_calendar_config_release();
        return NULL;
    }
 
    for (v = ast_variable_browse(cfg, 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);
        }
    }
 
    ast_calendar_config_release();
 
    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_redirect_register(pvt->session);
    ne_set_server_auth(pvt->session, auth_credentials, pvt);
    if (!strcasecmp(pvt->uri.scheme, "https")) {
        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;
}

References ao2_alloc, ao2_trylock, ao2_unlock, ast_calendar_config_acquire(), ast_calendar_config_release(), ast_calendar_event_container_alloc(), ast_cond_timedwait, ast_debug, ast_log, ast_mutex_init, ast_mutex_lock, ast_mutex_unlock, ast_string_field_init, ast_string_field_set, ast_strlen_zero(), ast_tvnow(), ast_variable_browse(), auth_credentials(), exchangecal_pvt::events, exchangecal_destructor(), LOG_ERROR, LOG_WARNING, ast_calendar::name, ast_variable::name, ast_variable::next, NULL, exchangecal_pvt::owner, ast_calendar::refresh, refreshlock, exchangecal_pvt::session, ast_calendar::tech_pvt, ast_calendar::unload, ast_calendar::unloading, unref_exchangecal(), update_exchangecal(), exchangecal_pvt::uri, exchangecal_pvt::url, url, and ast_variable::value.

exchangecal_request()

static struct ast_str * exchangecal_request ( struct exchangecal_pvt *  pvt, const char *  method, struct ast_str *  req_body, struct ast_str *  subdir  )

static

Definition at line 372 of file res_calendar_exchange.c.

{
    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);
    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;
}

References ast_free, ast_log, ast_str_buffer(), ast_str_create, ast_str_strlen(), buf, fetch_response_reader(), LOG_ERROR, LOG_WARNING, method, ast_calendar::name, NULL, exchangecal_pvt::owner, exchangecal_pvt::session, exchangecal_pvt::uri, and exchangecal_pvt::url.

Referenced by exchangecal_get_events_between(), and exchangecal_write_event().

exchangecal_write_event()

static int exchangecal_write_event ( struct ast_calendar_event *  event )

static

Definition at line 408 of file res_calendar_exchange.c.

{
    struct ast_str *body = NULL;
    struct ast_str *response = NULL;
    struct ast_str *subdir = NULL;
    struct ast_str *uid = NULL;
    struct ast_str *summary = NULL;
    struct ast_str *description = NULL;
    struct ast_str *organizer = NULL;
    struct ast_str *location = NULL;
    struct ast_str *start = NULL;
    struct ast_str *end = NULL;
    struct ast_str *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))) {
        ast_log(LOG_ERROR, "Could not allocate memory for request!\n");
        goto write_cleanup;
    }
 
    if (!(uid = ast_str_create(AST_UUID_STR_LEN)) ||
        !(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, AST_UUID_STR_LEN, "%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));
 
    if ((response = exchangecal_request(event->owner->tech_pvt, "PROPPATCH", body, subdir))) {
        ret = 0;
    }
 
write_cleanup:
    ast_free(uid);
    ast_free(summary);
    ast_free(description);
    ast_free(organizer);
    ast_free(location);
    ast_free(start);
    ast_free(end);
    ast_free(busystate);
    ast_free(body);
    ast_free(response);
    ast_free(subdir);
 
    return ret;
}

References ast_free, ast_log, ast_str_append(), ast_str_buffer(), ast_str_create, ast_str_set(), ast_strlen_zero(), AST_UUID_STR_LEN, ast_verb, bs_to_exchange_bs(), end, epoch_to_exchange_time(), exchangecal_request(), generate_exchange_uuid(), is_valid_uuid(), LOG_ERROR, LOG_WARNING, NULL, and xml_encode_str().

fetch_response_reader()

static int fetch_response_reader ( void *  data, const char *  block, size_t  len  )

static

Definition at line 341 of file res_calendar_exchange.c.

{
    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;
}

References ast_free, ast_malloc, ast_str_append(), len(), and tmp().

Referenced by exchangecal_request().

generate_exchange_uuid()

static struct ast_str * generate_exchange_uuid ( struct ast_str *  uid )

static

Definition at line 244 of file res_calendar_exchange.c.

{
    char buffer[AST_UUID_STR_LEN];
 
    ast_uuid_generate_str(buffer, sizeof(buffer));
    ast_str_set(&uid, 0, "%s", buffer);
    return uid;
}

References ast_str_set(), ast_uuid_generate_str(), and AST_UUID_STR_LEN.

Referenced by exchangecal_write_event().

is_valid_uuid()

static int is_valid_uuid ( struct ast_str *  uid )

static

Definition at line 253 of file res_calendar_exchange.c.

{
    struct ast_uuid *uuid = ast_str_to_uuid(ast_str_buffer(uid));
 
    if (uuid) {
        ast_free(uuid);
        return 1;
    }
 
    return 0;
}

References ast_free, ast_str_buffer(), ast_str_to_uuid(), and uuid().

Referenced by exchangecal_write_event().

load_module()

static int load_module ( void  )

static

Definition at line 725 of file res_calendar_exchange.c.

{
    ne_sock_init();
    if (ast_calendar_register(&exchangecal_tech)) {
        ne_sock_exit();
        return AST_MODULE_LOAD_DECLINE;
    }
 
    return AST_MODULE_LOAD_SUCCESS;
}

References ast_calendar_register(), AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, and exchangecal_tech.

msbusy_to_bs()

static enum ast_calendar_busy_state msbusy_to_bs ( const char *  msbusy )

static

Definition at line 160 of file res_calendar_exchange.c.

{
    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;
    }
}

References AST_CALENDAR_BS_BUSY, AST_CALENDAR_BS_BUSY_TENTATIVE, and AST_CALENDAR_BS_FREE.

Referenced by parse_cdata().

mstime_to_time_t()

static time_t mstime_to_time_t ( char *  mstime )

static

Definition at line 140 of file res_calendar_exchange.c.

{
    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);
}

References mstime().

Referenced by parse_cdata().

parse_cdata()

static int parse_cdata ( void *  data, char *  value, size_t  len  )

static

Definition at line 171 of file res_calendar_exchange.c.

{
    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 < 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;
}

References ast_calloc, ast_free, ast_skip_blanks(), ast_string_field_build, ast_calendar_event::description, len(), ast_calendar_event::location, msbusy_to_bs(), mstime_to_time_t(), ast_calendar_event::organizer, str, ast_calendar_event::summary, ast_calendar_event::uid, and value.

Referenced by update_exchangecal().

parse_tag()

static int parse_tag ( void *  data, char *  name, char **  atts, int  type  )

static

Definition at line 83 of file res_calendar_exchange.c.

{
    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;
}

References ao2_link, ast_calendar_event_alloc(), ast_calendar_unref_event(), ast_copy_string(), ast_log, ast_strlen_zero(), events, LOG_ERROR, name, tmp(), and type.

Referenced by update_exchangecal().

unload_module()

static int unload_module ( void  )

static

Definition at line 736 of file res_calendar_exchange.c.

{
    ast_calendar_unregister(&exchangecal_tech);
    ne_sock_exit();
    return 0;
}

References ast_calendar_unregister(), and exchangecal_tech.

unref_exchangecal()

static void * unref_exchangecal ( void *  obj )

static

Definition at line 235 of file res_calendar_exchange.c.

{
    struct exchangecal_pvt *pvt = obj;
 
    ao2_ref(pvt, -1);
    return NULL;
}

References ao2_ref, and NULL.

Referenced by exchangecal_load_calendar().

update_exchangecal()

static int update_exchangecal ( struct exchangecal_pvt *  pvt )

static

Definition at line 577 of file res_calendar_exchange.c.

{
    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;
}

References ast_calendar_merge_events(), ast_free, ast_str_buffer(), ast_str_strlen(), ast_tvnow(), end, exchangecal_pvt::events, exchangecal_get_events_between(), exchangecal_pvt::owner, parse_cdata(), parse_tag(), and ast_calendar::timeframe.

Referenced by exchangecal_load_calendar().

xml_encode_str()

static struct ast_str * xml_encode_str ( struct ast_str *  dst, const char *  src  )

static

Definition at line 265 of file res_calendar_exchange.c.

{
    const char *tmp;
    char buf[7];
 
    for (tmp = src; *tmp; tmp++) {
        switch (*tmp) {
        case '\"':
            strcpy(buf, """);
            break;
 
        case '\'':
            strcpy(buf, "'");
            break;
 
        case '&':
            strcpy(buf, "&");
            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;
}

References ast_str_append(), buf, and tmp().

Referenced by exchangecal_write_event().

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Asterisk MS Exchange Calendar Integration" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_EXTENDED, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_DEVSTATE_PLUGIN, .requires = "res_calendar", }

static

Definition at line 749 of file res_calendar_exchange.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 749 of file res_calendar_exchange.c.

exchangecal_tech

struct ast_calendar_tech exchangecal_tech

static

Definition at line 53 of file res_calendar_exchange.c.

Referenced by load_module(), and unload_module().