Logo Search packages:      
Sourcecode: libical version File versions

icalcap_message.c

#include "config.h"

#ifdef HAVE_STRING_H
#include <string.h>
#endif

#include "ical.h"
#include "icalcap.h"
#include "icalcap_message_impl.h"


/**
 * constructor
 *
 * Create a new icalcap_message from a component. This represents a command.
 */
icalcap_message *
icalcap_message_new(const icalcap *cap, const icalcomponent *comp) {

      icalcap_message *ret = NULL;

#ifdef WITH_RR
      ret = icalcap_message_new_rr(cap, comp);
#else
      ret = NULL;
#endif
      return ret;
}

/**
 * constructor
 *
 * Create a new icalcap_message from a component. This represents a reply.
 */
icalcap_message *
icalcap_message_new_reply(const icalcap_message *capmsg, const icalcomponent *comp) {

#ifdef WITH_RR
      return icalcap_message_new_reply_rr(capmsg, comp);
#else
      return NULL;
#endif
}

/**
 * destructor
 *
 * Delete icalcap_message
 */
void
icalcap_message_free(icalcap_message *capmsg) {

#ifdef WITH_RR
      icalcap_message_free_rr(capmsg);
#else
#endif
}

/**
 * Send the icalcap_message and wait for an answer.
 * The icalcap_message will be invalid after this call, and only valid call will be
 * icalcap_message_free().
 */
icalcomponent *
icalcap_message_sync_send(icalcap_message *capmsg, int timeout) {

      g_return_val_if_fail(capmsg, NULL);

#ifdef WITH_RR
      return icalcap_message_sync_send_rr(capmsg, timeout);
#else
      return NULL;
#endif
}

/**
 * Send the icalcap_message.
 * The icalcap_message will be invalid after this call, and only valid call will be
 * icalcap_message_free().
 */
int
icalcap_message_send(icalcap_message *capmsg) {

      int   rc = FALSE;
      char   *str;

      g_return_val_if_fail(capmsg, FALSE);

#ifdef WITH_RR
      rc = icalcap_message_send_reply_rr(capmsg);
#else
      rc = FALSE;
#endif

      return rc;
}

/**
 * Convenience method to send a component in reply to the given icalcap_message.
 * The icalcomponent is not modified in any way.
 *
 * FIXME should be const icalcomponent *
 */
int
icalcap_message_reply_component(const icalcap_message *orig, icalcomponent *in) {

      icalcap_message*reply;
      int         rc;

      reply = icalcap_message_new_reply(orig, in);
      if (reply == NULL)
            return FALSE;

      rc = icalcap_message_send(reply);
      icalcap_message_free(reply);

      return rc;
}

/* Only used by icalcap_message_reply_error */
static icalcomponent *new_reply_component(const icalcap_message *capmsg, const icalcomponent *comp);

/**
 * Convenience method to send an error in reply to the given icalcap_message.
 */
int
icalcap_message_reply_error(const icalcap_message *orig, enum icalrequeststatus status,
                                    const char *msg, const char *debug) {

      struct icalreqstattype  stat;
      icalcomponent            *comp, *vreply;
      int               rc;

      /* Prepare the REQUEST-STATUS */
      stat = icalreqstattype_from_string(
            icalenum_reqstat_code(status));

      if (msg != NULL) {
            /* FIXME we used to do
                  stat.desc = strdup(msg);
               but this created a memory leak. Maybe the destructor for reqstat? */
            stat.desc = msg;
      } else {
            stat.desc = icalenum_reqstat_desc(status);
      }

      if (debug != NULL)
            stat.debug = debug;

      /* Prepare a VREPLY component */
      vreply = icalcomponent_vanew(
            ICAL_VREPLY_COMPONENT,
            icalproperty_new_requeststatus(stat),
            0);
      if (vreply == NULL) {
            /* FIXME */
            return FALSE;
      }

      comp = new_reply_component(orig, vreply);

      rc = icalcap_message_reply_component(orig, comp);

      icalcomponent_free(comp);
      icalcomponent_free(vreply);

      return rc;
}


/* internal use */

/* only used by new_reply_component */
static const char *
get_id(icalcomponent *comp) {

      icalproperty   *prop;
      icalparameter  *param;

      prop = icalcomponent_get_first_property(comp, ICAL_CMD_PROPERTY);
      if (prop == NULL)
            return NULL;

      param = icalproperty_get_first_parameter(prop, ICAL_ID_PARAMETER);
      if (param == NULL)
            return NULL;

      return icalparameter_get_id(param);
}

/* only used by icalcap_message_reply_error */
static icalcomponent *
new_reply_component(const icalcap_message *capmsg, const icalcomponent *comp) {

      icalcomponent  *clone, *cal, *root;
      icalproperty   *cmd;
      const char     *id;

      cmd = icalproperty_new_cmd(ICAL_CMD_REPLY);

      if (capmsg->comp != NULL) {
            id = get_id(capmsg->comp);

            if (id != NULL)
                  icalproperty_add_parameter(cmd, icalparameter_new_id(id));
      }

      cal = icalcomponent_vanew(
            ICAL_VCALENDAR_COMPONENT,
            icalproperty_new_version("2.0"),
            icalproperty_new_prodid("-//I.Net spa//NONSGML//EN"),
            cmd,
            0);

      if (comp != NULL) {
            clone = icalcomponent_new_clone(comp);
            icalcomponent_add_component(cal, clone);
      }

      root = icalcomponent_vanew(
            ICAL_XROOT_COMPONENT,
            cal,
            0);
      return root;
}

Generated by  Doxygen 1.6.0   Back to index