view release on metacpan or  search on metacpan

CSA.xs  view on Meta::CPAN

#ifdef __cplusplus
extern "C" {
#endif
#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"
#ifdef __cplusplus
}
#endif

  /*
	Copyright (c) 1997 Kenneth Albanowski. All rights reserved.
	This program is free software; you can redistribute it and/or
	modify it under the same terms as Perl itself.
  */
  
/*#define CSA_DEBUG */

#include <csa/csa.h>

#include "CsaUtils.h"

#define safe_malloc Csa_safe_malloc
#define safe_calloc Csa_safe_calloc

static int
not_here(s)
char *s;
{
    croak("%s not implemented on this architecture", s);
    return -1;
}

int max_callback = 0;

AV *callbacks, *callback_mode;

void callback_handler(
				CSA_session_handle session,
				CSA_flags reason,
				CSA_buffer call_data,
				CSA_buffer client_data,
				CSA_extension *callback_extensions)
{
	int callback = (int)client_data;
	SV ** arg = av_fetch(callbacks, callback, 0);
	AV * args = (AV*)SvRV(*arg);
	int i,j;
	dSP;
	PUSHMARK(sp);
	for(i=1;i<=av_len(args);i++)
		XPUSHs(sv_2mortal(newSVsv(*av_fetch(args, i, 0))));
	{
#ifdef CSA_DEBUG
		printf("Dealing with callback type %d, tag %d\n", reason, callback);
#endif
		if (reason & CSA_CB_CALENDAR_LOGON) {
			CSA_logon_callback_data * data = call_data;
			XPUSHs(sv_2mortal(newSVpv("CALENDAR LOGON", 0)));
			XPUSHs(sv_2mortal(newSVCSA_calendar_user(data->user)));
		}
		if (reason & CSA_CB_CALENDAR_DELETED) {
			CSA_calendar_deleted_callback_data * data = call_data;
			XPUSHs(sv_2mortal(newSVpv("CALENDAR DELETED", 0)));
			XPUSHs(sv_2mortal(newSVCSA_calendar_user(data->user)));
		}
		if (reason & CSA_CB_CALENDAR_ATTRIBUTE_UPDATED) {
			CSA_calendar_attr_update_callback_data * data = call_data;
			XPUSHs(sv_2mortal(newSVpv("CALENDAR ATTRIBUTE UPDATED", 0)));
			XPUSHs(sv_2mortal(newSVCSA_calendar_user(data->user)));
			for (j=0;j<data->number_attributes;j++)
				XPUSHs(sv_2mortal(newSVpv(data->attribute_names[j], 0)));
		}
		if (reason & CSA_CB_ENTRY_ADDED) {
			CSA_add_entry_callback_data * data = call_data;
			XPUSHs(sv_2mortal(newSVpv("ENTRY ADDED", 0)));
			XPUSHs(sv_2mortal(newSVCSA_calendar_user(data->user)));
			XPUSHs(sv_2mortal(newSVCSA_opaque_data(&data->added_entry_id)));
		}
		if (reason & CSA_CB_ENTRY_DELETED) {
			CSA_delete_entry_callback_data * data = call_data;
			XPUSHs(sv_2mortal(newSVpv("ENTRY DELETED", 0)));
			XPUSHs(sv_2mortal(newSVCSA_calendar_user(data->user)));
			XPUSHs(sv_2mortal(newSVCSA_opaque_data(&data->deleted_entry_id)));
			XPUSHs(sv_2mortal(newSVCSA_SCOPE(data->scope)));
			XPUSHs(sv_2mortal(newSVISO_date_time(data->date_and_time,0)));
		}
		if (reason & CSA_CB_ENTRY_UPDATED) {
			CSA_update_entry_callback_data * data = call_data;
			XPUSHs(sv_2mortal(newSVpv("ENTRY UPDATED", 0)));
			XPUSHs(sv_2mortal(newSVCSA_calendar_user(data->user)));
			XPUSHs(sv_2mortal(newSVCSA_opaque_data(&data->old_entry_id)));
			XPUSHs(sv_2mortal(newSVCSA_opaque_data(&data->new_entry_id)));
			XPUSHs(sv_2mortal(newSVCSA_SCOPE(data->scope)));
			XPUSHs(sv_2mortal(newSVISO_date_time(data->date_and_time,0)));
		}
	}
	PUTBACK ;
	perl_call_sv(*av_fetch(args, 0, 0), G_DISCARD);
}

typedef struct Calendar__CSA__Session_t {
	CSA_session_handle	session;
	int	shorten;
	int iso_times;
	int connected;
} * Calendar__CSA__Session;

typedef struct Calendar__CSA__Entry_t {
	SV	* session_sv;
	Calendar__CSA__Session	session;
	CSA_entry_handle	entry;
} * Calendar__CSA__Entry;

typedef struct Calendar__CSA__EntryList_t {
	SV	* session_sv;
	Calendar__CSA__Session	session;
	int 	count;
	CSA_entry_handle	*list;
} * Calendar__CSA__EntryList;



SV * newSVCSA_reminder_reference(CSA_reminder_reference * rem, Calendar__CSA__Session parent, SV * parent_sv)
{
        HV * u;
        SV * r;
        if (!rem)
                return newSVsv(&sv_undef);
        u = newHV();
        if (rem->run_time)
                hv_store(u, "run_time", 8, newSVpv(rem->run_time, 0), 0);
        if (rem->snooze_time)
                hv_store(u, "snooze_time", 11, newSVpv(rem->snooze_time, 0), 0);
        hv_store(u, "repeat_count", 12, newSViv(rem->repeat_count), 0);
        if (rem->attribute_name)
                hv_store(u, "attribute_name", 14, newSVpv(rem->attribute_name, 0), 0);
        if (rem->entry) {
        		SV * e = newSVsv(&sv_undef);
        		Calendar__CSA__Entry entry = safe_malloc(sizeof(struct Calendar__CSA__Entry_t));
        		entry->entry = rem->entry;
        		entry->session = parent;
        		entry->session_sv = SvREFCNT_inc(parent_sv);
				sv_setref_pv(e, "Calendar::CSA::Entry", (void*)entry);
                hv_store(u, "entry", 5, e, 0);
        }
        r = newRV((SV*)u);
        SvREFCNT_dec(u);
        return r;
}

CSA.xs  view on Meta::CPAN

    case 'T':
	break;
    case 'U':
	break;
    case 'V':
	break;
    case 'W':
	break;
    case 'X':
	break;
    case 'Y':
	break;
    case 'Z':
	break;
    }
    errno = EINVAL;
    return 0;

not_there:
    errno = ENOENT;
    return 0;
}


static struct opts configs[] = {
	{CSA_CONFIG_CHARACTER_SET, "CHARACTER SET"},
	{CSA_CONFIG_LINE_TERM, "LINE TERM"},
	{CSA_CONFIG_DEFAULT_SERVICE, "DEFAULT SERVICE"},
	{CSA_CONFIG_DEFAULT_USER, "DEFAULT USER"},
	{CSA_CONFIG_REQ_PASSWORD, "REQ PASSWORD"},
	{CSA_CONFIG_REQ_SERVICE, "REQ SERVICE"},
	{CSA_CONFIG_REQ_USER, "REQ USER"},
	{CSA_CONFIG_UI_AVAIL, "UI AVAIL"},
	{CSA_CONFIG_VER_IMPLEM, "VER IMPLEM"},
	{CSA_CONFIG_VER_SPEC, "VER SPEC"},
	{0,0}
};


MODULE = Calendar::CSA		PACKAGE = Calendar::CSA

SV *
constant(name, arg)
	char *	name
	int	arg
	CODE:
	{
		char * s;
		s = constantstr(name, arg);
		if (s)
			RETVAL = newSVpv(s, 0);
		else {
			RETVAL = newSViv(constantint(name,arg));
		}
	}
	OUTPUT:
	RETVAL


void
add_calendar(user, ...)
	SV *	user
	CODE:
	{
		int i, j, err;
		CSA_calendar_user u;
		CSA_attribute * csa_attrs;
		
		if ((items-1)%2)
			croak("attributes must be paired names and values");

		SvCSA_calendar_user(user, &u);	
		
		if (items>1) {
			csa_attrs = safe_calloc(sizeof(CSA_attribute)*((items-1)/2), 1);
			for(j=0,i=1;i<items;j++,i+=2) {
				csa_attrs[j].name = lengthen(SvPV(ST(i),na));
				csa_attrs[j].value = SvCSA_attribute_value(ST(i+1), 0);
			}
		} else
			csa_attrs = 0;

		err = csa_add_calendar((CSA_session_handle)NULL, &u, (items-1)/2, csa_attrs, NULL);
		
		if (csa_attrs)
			free(csa_attrs);
		
		if (err)
			CsaCroak("add_calendar", err);
	}

Calendar::CSA::Session
logon(service=0, user=0, password=0, charset=0)
	char *	service
	SV *	user
	char *	password
	char *	charset
	CODE:
	{
		Calendar__CSA__Session session = safe_calloc(sizeof(struct Calendar__CSA__Session_t),1);
		CSA_return_code ret;
		CSA_calendar_user cu;
	
		if (service && !strlen(service))
			service = 0;
		
		ret =
		csa_logon(service,
			  SvCSA_calendar_user(user, &cu),
			  password,
			  charset, 
			  "-//XAPIA/CSA/VERSION1/NONSGML CSA Version 1//EN",
			  &session->session,
			  NULL);
	
		session->iso_times = 1;

		if (ret != CSA_SUCCESS)
		{
			free(session);
			CsaCroak("logon", ret);
		}
		
		session->connected = 1;
		RETVAL = session;
	}
	OUTPUT:
	RETVAL

void
list_calendars(service=0)
	char *	service
	PPCODE:
	{
		CSA_calendar_user *result;
		CSA_uint32 number;
		int err,i;
		SV ** s;
		HV * u;
		
		number = 0;
		
		err = csa_list_calendars(service, &number, &result, NULL);

		if (err)
			CsaCroak("list_calendars", err);
		
		if (result) {
			for(i=0;i<number;i++) {
				EXTEND(sp, 1);
				PUSHs(sv_2mortal(newSVpv(result[i].calendar_address,0)));
			}
			csa_free(result);
		}
	}

int
accept_numeric_enumerations(set=&sv_undef)
	SV *	set
	CODE:
	{
		RETVAL = Csa_accept_numeric_enumerations;
		if (set && SvOK(set))
			Csa_accept_numeric_enumerations = SvTRUE(set);
	}
	OUTPUT:
	RETVAL

int
generate_numeric_enumerations(set=&sv_undef)
	SV *	set
	CODE:
	{
		RETVAL = Csa_generate_numeric_enumerations;
		if (set && SvOK(set))
			Csa_generate_numeric_enumerations = SvTRUE(set);
	}
	OUTPUT:
	RETVAL


MODULE = Calendar::CSA		PACKAGE = Calendar::CSA::Session

void
DESTROY(session)	
	Calendar::CSA::Session	session
	CODE:
	if (session->connected)
		csa_logoff(session->session, NULL);
	free(session);

void
logoff(session)
	Calendar::CSA::Session	session
	CODE:
	{
		int error = csa_logoff(session->session, NULL);
		if (error != CSA_SUCCESS)
			CsaCroak("logoff", error);
		session->connected = 0;
	}
	OUTPUT:

int
short_entry_names(session, set=&sv_undef)
	Calendar::CSA::Session	session
	SV *	set
	CODE:
	{
		RETVAL = session->shorten;
		if (set && SvOK(set))
			session->shorten = SvTRUE(set);
	}
	OUTPUT:
	RETVAL

int
unix_times(session, set=&sv_undef)
	Calendar::CSA::Session	session
	SV *	set
	CODE:
	{
		RETVAL = !session->iso_times;
		if (set && SvOK(set))
			session->iso_times = !SvTRUE(set);
	}
	OUTPUT:
	RETVAL

void
look_up(session, users, flags=0)
	Calendar::CSA::Session	session
	SV *	users
	SV *	flags
	PPCODE:
	{
		CSA_calendar_user user, *result;
		CSA_uint32 number;
		int err,i;

		SvCSA_calendar_user(users, &user);

		number = 1;
		
		err = csa_look_up(session->session, &user, SvCSA_LOOKUP(flags), &number, &result, NULL);

		if (err)
			CsaCroak("look_up", err);
			
		for(i=0;i<number;i++) {
			EXTEND(sp, 1);
			PUSHs(sv_2mortal(newSVCSA_calendar_user(result+i)));
		}
		
		csa_free(result);
	}

void
query_configuration(session, item)
	Calendar::CSA::Session	session
	SV *	item
	PPCODE:
	{
		CSA_calendar_user user, *result;
		CSA_uint32 number;
		int err=0,i;
		i = SvOpt(item, "configuration item", configs);
		switch (i) {
		case CSA_CONFIG_CHARACTER_SET:
		  {
			char ** data;
			err = csa_query_configuration(session->session, CSA_CONFIG_CHARACTER_SET, (void**)&data, NULL);
			if (err) goto done;
			csa_free(data);
			while (data && *data) {
				EXTEND(sp, 1);
				PUSHs(sv_2mortal(newSVpv(*data, 0)));
				data++;
			}
			break;
		  }
		case CSA_CONFIG_LINE_TERM:
		  {
			CSA_enum data;
			err = csa_query_configuration(session->session, i, (void**)&data, NULL);
			if (err) goto done;
			EXTEND(sp, 1);
			PUSHs(sv_2mortal(newSVCSA_LINE_TERM(data)));
			break;
		  }
		case CSA_CONFIG_DEFAULT_SERVICE:
		case CSA_CONFIG_DEFAULT_USER:
		case CSA_CONFIG_VER_IMPLEM:
		case CSA_CONFIG_VER_SPEC:
		  {
			CSA_string data;
			err = csa_query_configuration(session->session, i, (void**)&data, NULL);
			if (err) goto done;
			EXTEND(sp, 1);
			PUSHs(sv_2mortal(data ? newSVpv(data,0) : newSVsv(&sv_undef)));
			csa_free(data);
			break;
		  }
		case CSA_CONFIG_REQ_PASSWORD:
		case CSA_CONFIG_REQ_SERVICE:
		case CSA_CONFIG_REQ_USER:
		  {
			CSA_enum data;
			err = csa_query_configuration(session->session, i, (void**)&data, NULL);
			if (err) goto done;
			EXTEND(sp, 1);
			PUSHs(sv_2mortal(newSVCSA_REQUIRED(data)));
			break;
		  }
		case CSA_CONFIG_UI_AVAIL:
		  {
			CSA_boolean data;
			err = csa_query_configuration(session->session, i, (void**)&data, NULL);
			if (err) goto done;
			EXTEND(sp, 1);
			PUSHs(sv_2mortal(newSViv(data)));
			break;
		  }
		default:
			croak("unhandled configuration query");
		}

    done:
		if (err)
			CsaCroak("query_configuration", err);
	}

void
list_calendar_attributes(session)
	Calendar::CSA::Session	session
	PPCODE:
	{
		CSA_attribute_reference *result;
		CSA_uint32 number;
		int err,i;
		SV ** s;
		HV * u;
		
		number = 0;
		
		err = csa_list_calendar_attributes(session->session, &number, &result, NULL);

		if (err)
			CsaCroak("list_calendar_attributes", err);
		
		if (result) {
			for(i=0;i<number;i++) {
				EXTEND(sp, 1);
				PUSHs(sv_2mortal(newSVpv(shorten(result[i], session->shorten),0)));
			}
			csa_free(result);
		}
	}

void
read_calendar_attributes(session, ...)
	Calendar::CSA::Session	session
	PPCODE:
	{
		int i, j, err;
		int flags=0;
		CSA_uint32 count;
		CSA_attribute * result;
		CSA_attribute_reference * csa_names;
		if (items>1) {
			csa_names = safe_calloc(sizeof(CSA_attribute_reference)*(items-1),1);
			for(i=1;i<items;i++)
				csa_names[i-1] = lengthen(SvPV(ST(i), na));
		} else {
			csa_names = 0;
		}

		err = csa_read_calendar_attributes(session->session, items-1, csa_names, &count, &result, NULL);
		
		if (csa_names)
			free(csa_names);
		
		if (err)
			CsaCroak("read_calendar_attributes", err);
		
		if (result) {
			for(i=0;i<count;i++) {
				EXTEND(sp, 2);
				PUSHs(sv_2mortal(newSVpv(shorten(result[i].name,session->shorten), 0)));
				PUSHs(sv_2mortal(newSVCSA_attribute_value(result[i].value, session->shorten, session->iso_times)));
			}
			csa_free(result);
		}
	}

void
read_next_reminder(session, given_time, ...)
	Calendar::CSA::Session	session
	SV *	given_time
	PPCODE:
	{
		int i, j, err;
		int flags=0;
		CSA_uint32 count;
		CSA_reminder_reference * result;
		CSA_attribute_reference * csa_names;

		if (items>1) {
			csa_names = safe_calloc(sizeof(CSA_attribute_reference)*(items-1),1);
			for(i=1;i<items;i++)
				csa_names[i-1] = SvPV(ST(i), na);
		} else {
			csa_names = 0;
		}

		err = csa_read_next_reminder(session->session, items-1, csa_names, SvISO_date_time(given_time,0), &count, &result, NULL);
		
		if (csa_names)
			free(csa_names);
		
		if (err)
			CsaCroak("read_next_reminder", err);
		
		if (result) {
			for(i=0;i<count;i++) {
				EXTEND(sp, 1);
				PUSHs(sv_2mortal(newSVCSA_reminder_reference(result+i, session, ST(0))));
			}
			csa_free(result);
		}
	}

void
update_calendar_attributes(session, ...)
	Calendar::CSA::Session	session
	CODE:
	{
		int i,j, err;
		CSA_attribute * csa_attrs;
		if ((items-1)%2)
			croak("attributes must be paired names and values");
		if (items>1) {
			csa_attrs = safe_calloc(sizeof(CSA_attribute)*((items-1)/2), 1);
			for(j=0,i=1;i<items;j++,i+=2) {
				csa_attrs[j].name = lengthen(SvPV(ST(i),na));
				csa_attrs[j].value = SvCSA_attribute_value(ST(i+1), 0);
			}
		} else
			csa_attrs = 0;

		err = csa_update_calendar_attributes(session->session, items-1, csa_attrs, NULL);
		
		if (csa_attrs)
			free(csa_attrs);
		
		if (err)
			CsaCroak("update_calendar_attributes", err);
	}

void
add_calendar(session, user, ...)
	Calendar::CSA::Session	session
	SV *	user
	CODE:
	{
		int i, j, err;
		CSA_calendar_user u;
		CSA_attribute * csa_attrs;
		
		if ((items-2)%2)
			croak("attributes must be paired names and values");
		
		SvCSA_calendar_user(user, &u);	
		
		if (items>2) {
			csa_attrs = safe_calloc(sizeof(CSA_attribute)*((items-2)/2), 1);
			for(j=0,i=2;i<items;j++,i+=2) {
				csa_attrs[j].name = lengthen(SvPV(ST(i),na));
				csa_attrs[j].value = SvCSA_attribute_value(ST(i+1), 0);
			}
		} else
			csa_attrs = 0;

		err = csa_add_calendar(session->session, &u, (items-2)/2, csa_attrs, NULL);
		
		if (csa_attrs)
			free(csa_attrs);
		
		if (err)
			CsaCroak("add_calendar", err);
	}

void
free_time_search(session, range, duration, calendar,...)
	Calendar::CSA::Session	session
	SV *	range
	SV *	duration
	SV *	calendar
	PPCODE:
	{
		int i, j, err;
		CSA_uint32 count;
		CSA_free_time * result;
		CSA_calendar_user * csa_users;
		if (items>3) {
			csa_users = safe_malloc(sizeof(CSA_calendar_user)*(items-3));
			for(i=3;i<items;i++)
				SvCSA_calendar_user(ST(i), &csa_users[i-3]);
		} else
			csa_users = 0;
			
		err = csa_free_time_search(session->session, SvISO_date_time_range(range,0), SvISO_time_duration(duration,0), items-3, csa_users, &result, NULL);
		
		if (csa_users)
			free(csa_users);
		
		if (err)
			CsaCroak("free_time_search", err);
		
		if (result) {
			for(i=0;i<result->number_free_time_data;i++) {
				EXTEND(sp, 1);
				PUSHs(sv_2mortal(newSVISO_date_time(result->free_time_data[i], 0)));
			}
			csa_free(result);
		}
	}


void
delete_calendar(session)
	Calendar::CSA::Session	session
	CODE:
	{
		int err = csa_delete_calendar(session->session, NULL);
		if (err)
			CsaCroak("delete_calendar", err);
	}


int
register_callback(session, mode, callback, ...)
	Calendar::CSA::Session	session
	SV *	mode
	SV *	callback
	CODE:
	{
		int i;
		int flags=0;
		AV * args;
		if (SvROK(mode) && (SvTYPE(SvRV(mode)) == SVt_PVAV)) {
			args = (AV*)SvRV(mode);
			for (i=0;i<=av_len(args);i++)
				flags |= SvCSA_callback_mode(*av_fetch(args, i, 0));
		} else {
			flags = SvCSA_callback_mode(mode);
		}

		i = csa_register_callback(session->session, flags, callback_handler, (void*)(max_callback+1), NULL);
		if (i)
			CsaCroak("register_callback", i);
		max_callback++;
#ifdef CSA_DEBUG
		printf("Registered callback %d with action %d\n", max_callback, flags);
#endif
		args = newAV();
		for(i=2;i<items;i++)
			av_push(args, newSVsv(ST(i)));
		av_store(callbacks, max_callback, newRV((SV*)args));
		SvREFCNT_dec(args);
		av_store(callback_mode, max_callback, newSViv(flags));
		RETVAL = max_callback;
	}
	OUTPUT:
	RETVAL

void
call_callbacks(session, mode, ...)
	Calendar::CSA::Session	session
	SV *	mode
	CODE:
	{
		int i,j;
		int flags=0;
		AV * args;
		for(j=1;j<items;j++)
			if (SvROK(mode) && (SvTYPE(SvRV(mode)) == SVt_PVAV)) {
				args = (AV*)SvRV(mode);
				for (i=0;i<=av_len(args);i++)
					flags |= SvCSA_callback_mode(*av_fetch(args, i, 0));
			} else {
				flags |= SvCSA_callback_mode(mode);
			}
		i = csa_call_callbacks(session->session, flags, NULL);
		if (i)
			CsaCroak("call_callbacks", i);
	}