aboutsummaryrefslogtreecommitdiffstats
path: root/libical/src/libicalss
diff options
context:
space:
mode:
Diffstat (limited to 'libical/src/libicalss')
-rw-r--r--libical/src/libicalss/icalcstpclient.c343
-rw-r--r--libical/src/libicalss/icalcstpclient.h100
-rw-r--r--libical/src/libicalss/icalcstpserver.c278
-rw-r--r--libical/src/libicalss/icalcstpserver.h101
4 files changed, 822 insertions, 0 deletions
diff --git a/libical/src/libicalss/icalcstpclient.c b/libical/src/libicalss/icalcstpclient.c
new file mode 100644
index 0000000000..d53d53f568
--- /dev/null
+++ b/libical/src/libicalss/icalcstpclient.c
@@ -0,0 +1,343 @@
+/* -*- Mode: C -*-
+ ======================================================================
+ FILE: icalcstps.c
+ CREATOR: ebusboom 23 Jun 2000
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either:
+
+ The LGPL as published by the Free Software Foundation, version
+ 2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+ Or:
+
+ The Mozilla Public License Version 1.0. You may obtain a copy of
+ the License at http://www.mozilla.org/MPL/
+
+
+ ======================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "ical.h"
+#include "icalcstp.h"
+#include "icalcstpclient.h"
+#include "pvl.h"
+
+#include <sys/types.h> /* For send(), others */
+#include <sys/socket.h> /* For send(), others. */
+#include <unistd.h> /* For alarm */
+#include <errno.h>
+#include <stdlib.h> /* for malloc */
+#include <string.h>
+
+#define EOL "\n"
+
+
+/* Client state machine */
+
+typedef enum icalcstpc_line_type {
+ ICALCSTPC_RESPONSE_CODE_LINE,
+ ICALCSTPC_TERMINATOR_LINE,
+ ICALCSTPC_APPLICATION_DATA_LINE
+} icalcstpc_line_type;
+
+typedef enum icalcstpc_state {
+ ICALCSTPC_SEND_STATE,
+ ICALCSTPC_RESPONSE_CODE_STATE,
+ ICALCSTPC_RESPONSE_DATA_STATE
+} icalcstpc_state;
+
+
+
+struct icalcstpc_impl {
+ int timeout;
+ icalparser *parser;
+ icalcstp_command command;
+ icalcstpc_state state;
+ char* next_output;
+ char* next_input;
+};
+
+icalcstpc* icalcstpc_new()
+{
+ struct icalcstpc_impl *impl;
+
+ impl = malloc(sizeof(struct icalcstpc_impl));
+
+ if(impl == 0){
+ icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+ return 0;
+ }
+
+ memset(impl,0,sizeof(struct icalcstpc_impl));
+
+ return impl;
+}
+
+void icalcstpc_free(icalcstpc* cstpc)
+{
+ struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstpc;
+
+ if(impl->next_output != 0){
+ free(impl->next_output);
+ }
+
+ if(impl->next_input != 0){
+ free(impl->next_input);
+ }
+
+
+ if(impl->parser != 0){
+ icalparser_free(impl->parser);
+ }
+}
+
+/* Get the next string to send to the server */
+char* icalcstpc_next_output(icalcstpc* cstp, char * line)
+{
+ char* out;
+ struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstp;
+
+ if(impl->next_output == 0){
+ return 0;
+ }
+
+ out = impl->next_output;
+
+ impl->next_output = 0;
+
+ icalmemory_add_tmp_buffer(out);
+
+ return out;
+}
+
+/* process the next string sent by the server */
+int icalcstpc_next_input(icalcstpc* cstp, char* line)
+{
+ struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstp;
+ icalcstpc_line_type line_type;
+
+ if(icalcstp_line_is_endofdata(line) || line == 0){
+ return 0;
+ }
+
+ switch (impl->command){
+ case ICAL_ABORT_COMMAND:{
+ break;
+ }
+ case ICAL_AUTHENTICATE_COMMAND:{
+ break;
+ }
+ case ICAL_CAPABILITY_COMMAND:{
+ break;
+ }
+ case ICAL_CONTINUE_COMMAND:{
+ break;
+ }
+ case ICAL_CALIDEXPAND_COMMAND:{
+ break;
+ }
+ case ICAL_IDENTIFY_COMMAND:{
+ break;
+ }
+ case ICAL_DISCONNECT_COMMAND:{
+ break;
+ }
+ case ICAL_SENDDATA_COMMAND:{
+ break;
+ }
+ case ICAL_STARTTLS_COMMAND:{
+ break;
+ }
+ case ICAL_UPNEXPAND_COMMAND:{
+ break;
+ }
+ case ICAL_COMPLETE_COMMAND:{
+ break;
+ }
+ case ICAL_UNKNOWN_COMMAND:{
+ break;
+ }
+ default:
+ break;
+ }
+}
+
+/* After icalcstpc_next_input returns a 0, there are responses
+ ready. use these to get them */
+icalcstpc_response icalcstpc_first_response(icalcstpc* cstp)
+{
+ struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstp;
+
+}
+
+
+icalcstpc_response icalcstpc_next_response(icalcstpc* cstp)
+{
+ struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstp;
+}
+
+
+int icalcstpc_set_timeout(icalcstpc* cstp, int sec)
+{
+ struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstp;
+}
+
+icalerrorenum icalcstpc_abort(icalcstpc* cstp)
+{
+ struct icalcstpc_impl* impl = (struct icalcstpc_impl*)cstp;
+
+ icalerror_check_arg_re(cstp!=0,"cstp",ICAL_BADARG_ERROR);
+
+ impl->next_output = "ABORT\n";
+
+ return ICAL_NO_ERROR;
+}
+
+icalerrorenum icalcstpclient_setup_output(icalcstpc* cstp, size_t sz)
+{
+ struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstp;
+
+ if(impl->next_output != 0){
+ icalerror_set_errno(ICAL_USAGE_ERROR);
+ return ICAL_USAGE_ERROR;
+ }
+
+ impl->next_output = malloc(sz);
+
+ if(impl->next_output == 0){
+ icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+ return ICAL_NEWFAILED_ERROR;
+ }
+
+ return ICAL_NO_ERROR;
+
+}
+
+icalerrorenum icalcstpc_authenticate(icalcstpc* cstp, char* mechanism,
+ char* data, char* f(char*))
+{
+ struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstp;
+ char* command_str;
+ icalerrorenum error;
+ size_t sz;
+
+ icalerror_check_arg_re(cstp!=0,"cstp",ICAL_BADARG_ERROR);
+ icalerror_check_arg_re(mechanism!=0,"mechanism",ICAL_BADARG_ERROR);
+ icalerror_check_arg_re(data!=0,"data",ICAL_BADARG_ERROR);
+ icalerror_check_arg_re(f!=0,"f",ICAL_BADARG_ERROR);
+
+ impl->command = ICAL_AUTHENTICATE_COMMAND;
+
+ command_str = icalcstp_command_to_string(impl->command);
+
+ sz = strlen(command_str) + strlen(mechanism) + strlen(data) + 4;
+
+ if((error=icalcstpclient_setup_output(cstp,sz)) != ICAL_NO_ERROR){
+ return error;
+ }
+
+ sprintf(impl->next_output,"%s %s %s%s",command_str,mechanism,data,EOL);
+
+ return ICAL_NO_ERROR;
+}
+
+icalerrorenum icalcstpc_capability(icalcstpc* cstp)
+{
+ struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstp;
+ char* command_str;
+ icalerrorenum error;
+ size_t sz;
+
+ icalerror_check_arg_re(cstp!=0,"cstp",ICAL_BADARG_ERROR);
+
+ impl->command = ICAL_CAPABILITY_COMMAND;
+
+ command_str = icalcstp_command_to_string(impl->command);
+
+ sz = strlen(command_str);
+
+ if((error=icalcstpclient_setup_output(cstp,sz)) != ICAL_NO_ERROR){
+ return error;
+ }
+
+ return ICAL_NO_ERROR;
+}
+
+icalerrorenum icalcstpc_calidexpand(icalcstpc* cstp,char* calid)
+{
+ struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstp;
+
+ impl->command = ICAL_CALIDEXPAND_COMMAND;
+ return ICAL_NO_ERROR;
+}
+
+icalerrorenum icalcstpc_continue(icalcstpc* cstp, unsigned int time)
+{
+ struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstp;
+
+ impl->command = ICAL_CONTINUE_COMMAND;
+ return ICAL_NO_ERROR;
+}
+
+icalerrorenum icalcstpc_disconnect(icalcstpc* cstp)
+{
+ struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstp;
+
+
+ impl->command = ICAL_DISCONNECT_COMMAND;
+
+ return ICAL_NO_ERROR;
+}
+
+icalerrorenum icalcstpc_identify(icalcstpc* cstp, char* id)
+{
+ struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstp;
+
+
+ impl->command = ICAL_IDENTIFY_COMMAND;
+
+ return ICAL_NO_ERROR;
+}
+
+icalerrorenum icalcstpc_starttls(icalcstpc* cstp, char* command,
+ char* data, char * f(char*))
+{
+ struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstp;
+
+ impl->command = ICAL_STARTTLS_COMMAND;
+
+ return ICAL_NO_ERROR;
+}
+
+icalerrorenum icalcstpc_upnexpand(icalcstpc* cstp,char* calid)
+{
+ struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstp;
+
+
+ impl->command = ICAL_UPNEXPAND_COMMAND;
+
+ return ICAL_NO_ERROR;
+}
+
+icalerrorenum icalcstpc_sendata(icalcstpc* cstp, unsigned int time,
+ icalcomponent *comp)
+{
+ struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstp;
+
+ impl->command = ICAL_SENDDATA_COMMAND;
+
+ return ICAL_NO_ERROR;
+}
+
+
+
+
diff --git a/libical/src/libicalss/icalcstpclient.h b/libical/src/libicalss/icalcstpclient.h
new file mode 100644
index 0000000000..8d9d0c904c
--- /dev/null
+++ b/libical/src/libicalss/icalcstpclient.h
@@ -0,0 +1,100 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalcstpclient.h
+ CREATOR: eric 4 Feb 01
+
+ $Id$
+
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either:
+
+ The LGPL as published by the Free Software Foundation, version
+ 2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+ Or:
+
+ The Mozilla Public License Version 1.0. You may obtain a copy of
+ the License at http://www.mozilla.org/MPL/
+
+ The original code is icalcstp.h
+
+======================================================================*/
+
+
+#ifndef ICALCSTPC_H
+#define ICALCSTPC_H
+
+#include "ical.h"
+#include "icalcstp.h"
+
+/********************** Client (Sender) Interfaces **************************/
+
+/* How to use:
+
+ 1) Construct a new icalcstpc
+ 2) Issue a command by calling one of the command routines.
+ 3) Repeat until both call icalcstpc_next_output and
+ icalcstpc_next_input return 0:
+ 3a) Call icalcstpc_next_output. Send string to server.
+ 3b) Get string from server, & give to icalcstp_next_input()
+ 4) Iterate with icalcstpc_first_response & icalcstp_next_response to
+ get the servers responses
+ 5) Repeat at #2
+*/
+
+
+typedef void icalcstpc;
+
+/* Response code sent by the server. */
+typedef struct icalcstpc_response {
+ icalrequeststatus code;
+ char *arg; /* These strings are owned by libical */
+ char *debug_text;
+ char *more_text;
+ void* result;
+} icalcstpc_response;
+
+
+icalcstpc* icalcstpc_new();
+
+void icalcstpc_free(icalcstpc* cstpc);
+
+int icalcstpc_set_timeout(icalcstpc* cstp, int sec);
+
+
+/* Get the next string to send to the server */
+char* icalcstpc_next_output(icalcstpc* cstp, char* line);
+
+/* process the next string from the server */
+int icalcstpc_next_input(icalcstpc* cstp, char * line);
+
+/* After icalcstpc_next_input returns a 0, there are responses
+ ready. use these to get them */
+icalcstpc_response icalcstpc_first_response(icalcstpc* cstp);
+icalcstpc_response icalcstpc_next_response(icalcstpc* cstp);
+
+/* Issue a command */
+icalerrorenum icalcstpc_abort(icalcstpc* cstp);
+icalerrorenum icalcstpc_authenticate(icalcstpc* cstp, char* mechanism,
+ char* init_data, char* f(char*) );
+icalerrorenum icalcstpc_capability(icalcstpc* cstp);
+icalerrorenum icalcstpc_calidexpand(icalcstpc* cstp,char* calid);
+icalerrorenum icalcstpc_continue(icalcstpc* cstp, unsigned int time);
+icalerrorenum icalcstpc_disconnect(icalcstpc* cstp);
+icalerrorenum icalcstpc_identify(icalcstpc* cstp, char* id);
+icalerrorenum icalcstpc_starttls(icalcstpc* cstp, char* command,
+ char* init_data, char* f(char*));
+icalerrorenum icalcstpc_senddata(icalcstpc* cstp, unsigned int time,
+ icalcomponent *comp);
+icalerrorenum icalcstpc_upnexpand(icalcstpc* cstp,char* calid);
+icalerrorenum icalcstpc_sendata(icalcstpc* cstp, unsigned int time,
+ icalcomponent *comp);
+
+
+#endif /* !ICALCSTPC_H */
+
+
+
diff --git a/libical/src/libicalss/icalcstpserver.c b/libical/src/libicalss/icalcstpserver.c
new file mode 100644
index 0000000000..1a6ed7b976
--- /dev/null
+++ b/libical/src/libicalss/icalcstpserver.c
@@ -0,0 +1,278 @@
+/* -*- Mode: C -*-
+ ======================================================================
+ FILE: icalcstpserver.c
+ CREATOR: ebusboom 13 Feb 01
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either:
+
+ The LGPL as published by the Free Software Foundation, version
+ 2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+ Or:
+
+ The Mozilla Public License Version 1.0. You may obtain a copy of
+ the License at http://www.mozilla.org/MPL/
+
+
+ ======================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "ical.h"
+#include "icalcstp.h"
+#include "icalcstpserver.h"
+#include "pvl.h"
+
+#include <sys/types.h> /* For send(), others */
+#include <sys/socket.h> /* For send(), others. */
+#include <unistd.h> /* For alarm */
+#include <errno.h>
+#include <stdlib.h> /* for malloc */
+#include <string.h>
+
+
+
+struct icalcstps_impl {
+ int timeout;
+ icalparser *parser;
+ enum cstps_state major_state;
+ struct icalcstps_commandfp commandfp;
+};
+
+
+
+
+/* This state machine is a Mealy-type: actions occur on the
+ transitions, not in the states.
+
+ Here is the state machine diagram from the CAP draft:
+
+
+ STARTTLS /
+ CAPABILITY
+ +-------+
+ | | +---------------+
+ | +-----------+ AUTHENTICATE | |
+ +-->| Connected |-------------->| Authenticated |
+ +-----------+ | |
+ | +---------------+
+ | |
+ | |
+ | |
+ | | +-----+ STARTTLS /
+ | V | | CAPABILITY /
+ | +---------------+ | IDENTIFY
+ | | |<-+
+ | | Identified |<----+
+ | +--------| | |
+ | | +---------------+ | command
+ | | | | completes
+ V |DISCONNECT | |
+ +--------------+ | |SENDDATA |
+ | Disconnected |<--+ | |
+ +--------------+ | | ABORT
+ A | |
+ | V |
+ | DISCONNECT +---------------+ |
+ +--------------------| Receive |--+
+ | |<--+
+ +---------------+ |
+ | | CONTINUTE
+ +----+
+
+ In this implmenetation, the transition from CONNECTED to IDENTIFIED
+ is non-standard. The spec specifies that on the ATHENTICATE
+ command, the machine transitions from CONNECTED to AUTHENTICATED,
+ and then immediately goes to IDENTIFIED. This makes AUTHENTICATED a
+ useless state, so I removed it */
+
+struct state_table {
+ enum cstps_state major_state;
+ enum icalcstp_command command;
+ void (*action)();
+ enum cstps_state next_state;
+
+} server_state_table[] =
+{
+ { CONNECTED, ICAL_CAPABILITY_COMMAND , 0, CONNECTED},
+ { CONNECTED, ICAL_AUTHENTICATE_COMMAND , 0, IDENTIFIED}, /* Non-standard */
+ { IDENTIFIED, ICAL_STARTTLS_COMMAND, 0, IDENTIFIED},
+ { IDENTIFIED, ICAL_IDENTIFY_COMMAND, 0, IDENTIFIED},
+ { IDENTIFIED, ICAL_CAPABILITY_COMMAND, 0, IDENTIFIED},
+ { IDENTIFIED, ICAL_SENDDATA_COMMAND, 0, RECEIVE},
+ { IDENTIFIED, ICAL_DISCONNECT_COMMAND, 0, DISCONNECTED},
+ { DISCONNECTED, 0, 0, 0},
+ { RECEIVE, ICAL_DISCONNECT_COMMAND, 0, DISCONNECTED},
+ { RECEIVE, ICAL_CONTINUE_COMMAND, 0, RECEIVE},
+ { RECEIVE, ICAL_ABORT_COMMAND , 0, IDENTIFIED},
+ { RECEIVE, ICAL_COMPLETE_COMMAND , 0, IDENTIFIED}
+};
+
+
+/**********************************************************************/
+
+
+
+icalcstps* icalcstps_new(struct icalcstps_commandfp cfp)
+{
+ struct icalcstps_impl* impl;
+
+ if ( ( impl = (struct icalcstps_impl*)
+ malloc(sizeof(struct icalcstps_impl))) == 0) {
+ icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+ return 0;
+ }
+
+ impl->commandfp = cfp;
+ impl->timeout = 10;
+
+ return (icalcstps*)impl;
+
+}
+
+void icalcstps_free(icalcstps* cstp);
+
+int icalcstps_set_timeout(icalcstps* cstp, int sec)
+{
+ struct icalcstps_impl *impl = (struct icalcstps_impl *) cstp;
+
+ icalerror_check_arg_rz( (cstp!=0), "cstp");
+
+ impl->timeout = sec;
+
+ return sec;
+}
+
+typedef struct icalcstps_response {
+ icalrequeststatus code;
+ char caluid[1024];
+ void* result;
+} icalcstps_response;
+
+
+icalerrorenum prep_abort(struct icalcstps_impl* impl, char* data)
+{
+ return ICAL_NO_ERROR;
+}
+icalerrorenum prep_authenticate(struct icalcstps_impl* impl, char* data)
+{ return ICAL_NO_ERROR;
+}
+icalerrorenum prep_capability(struct icalcstps_impl* impl, char* data)
+{ return ICAL_NO_ERROR;
+}
+icalerrorenum prep_calidexpand(struct icalcstps_impl* impl, char* data)
+{
+ return ICAL_NO_ERROR;
+}
+icalerrorenum prep_continue(struct icalcstps_impl* impl, char* data)
+{
+ return ICAL_NO_ERROR;
+}
+icalerrorenum prep_disconnect(struct icalcstps_impl* impl, char* data)
+{
+ return ICAL_NO_ERROR;
+}
+icalerrorenum prep_identify(struct icalcstps_impl* impl, char* data)
+{
+ return ICAL_NO_ERROR;
+}
+icalerrorenum prep_starttls(struct icalcstps_impl* impl, char* data)
+{
+ return ICAL_NO_ERROR;
+}
+icalerrorenum prep_upnexpand(struct icalcstps_impl* impl, char* data)
+{
+ return ICAL_NO_ERROR;
+}
+icalerrorenum prep_sendata(struct icalcstps_impl* impl, char* data)
+{ return ICAL_NO_ERROR;
+}
+
+char* icalcstps_process_incoming(icalcstps* cstp, char* input)
+{
+ struct icalcstps_impl *impl = (struct icalcstps_impl *) cstp;
+ char *i;
+ char *cmd_or_resp;
+ char *data;
+ char *input_cpy;
+ icalerrorenum error;
+
+ icalerror_check_arg_rz(cstp !=0,"cstp");
+ icalerror_check_arg_rz(input !=0,"input");
+
+ if ((input_cpy = (char*)strdup(input)) == 0){
+ icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+ return 0;
+ }
+
+ i = (char*)strstr(" ",input_cpy);
+
+ cmd_or_resp = input_cpy;
+
+ if (i != 0){
+ *i = '\0';
+ data = ++i;
+ } else {
+ data = 0;
+ }
+
+ printf("cmd: %s\n",cmd_or_resp);
+ printf("data: %s\n",data);
+
+ /* extract the command, look up in the state table, and dispatch
+ to the proper handler */
+
+ if(strcmp(cmd_or_resp,"ABORT") == 0){
+ error = prep_abort(impl,data);
+ } else if(strcmp(cmd_or_resp,"AUTHENTICATE") == 0){
+ error = prep_authenticate(impl,data);
+ } else if(strcmp(cmd_or_resp,"CAPABILITY") == 0){
+ error = prep_capability(impl,data);
+ } else if(strcmp(cmd_or_resp,"CALIDEXPAND") == 0){
+ error = prep_calidexpand(impl,data);
+ } else if(strcmp(cmd_or_resp,"CONTINUE") == 0){
+ error = prep_continue(impl,data);
+ } else if(strcmp(cmd_or_resp,"DISCONNECT") == 0){
+ error = prep_disconnect(impl,data);
+ } else if(strcmp(cmd_or_resp,"IDENTIFY") == 0){
+ error = prep_identify(impl,data);
+ } else if(strcmp(cmd_or_resp,"STARTTLS") == 0){
+ error = prep_starttls(impl,data);
+ } else if(strcmp(cmd_or_resp,"UPNEXPAND") == 0){
+ error = prep_upnexpand(impl,data);
+ } else if(strcmp(cmd_or_resp,"SENDDATA") == 0){
+ error = prep_sendata(impl,data);
+ }
+
+ return 0;
+}
+
+ /* Read data until we get a end of data marker */
+
+
+
+struct icalcstps_server_stubs {
+ icalerrorenum (*abort)(icalcstps* cstp);
+ icalerrorenum (*authenticate)(icalcstps* cstp, char* mechanism,
+ char* data);
+ icalerrorenum (*calidexpand)(icalcstps* cstp, char* calid);
+ icalerrorenum (*capability)(icalcstps* cstp);
+ icalerrorenum (*cont)(icalcstps* cstp, unsigned int time);
+ icalerrorenum (*identify)(icalcstps* cstp, char* id);
+ icalerrorenum (*disconnect)(icalcstps* cstp);
+ icalerrorenum (*sendata)(icalcstps* cstp, unsigned int time,
+ icalcomponent *comp);
+ icalerrorenum (*starttls)(icalcstps* cstp, char* command,
+ char* data);
+ icalerrorenum (*upnexpand)(icalcstps* cstp, char* upn);
+ icalerrorenum (*unknown)(icalcstps* cstp, char* command, char* data);
+};
+
diff --git a/libical/src/libicalss/icalcstpserver.h b/libical/src/libicalss/icalcstpserver.h
new file mode 100644
index 0000000000..6fa2254b2e
--- /dev/null
+++ b/libical/src/libicalss/icalcstpserver.h
@@ -0,0 +1,101 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalcstpserver.h
+ CREATOR: eric 13 Feb 01
+
+ $Id$
+
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either:
+
+ The LGPL as published by the Free Software Foundation, version
+ 2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+ Or:
+
+ The Mozilla Public License Version 1.0. You may obtain a copy of
+ the License at http://www.mozilla.org/MPL/
+
+ The original code is icalcstp.h
+
+======================================================================*/
+
+
+#ifndef ICALCSTPS_H
+#define ICALCSTPS_H
+
+#include "ical.h"
+
+
+/********************** Server (Reciever) Interfaces *************************/
+
+/* On the server side, the caller will recieve data from the incoming
+ socket and pass it to icalcstps_next_input. The caller then takes
+ the return from icalcstps_next_outpu and sends it out through the
+ socket. This gives the caller a point of control. If the cstp code
+ connected to the socket itself, it would be hard for the caller to
+ do anything else after the cstp code was started.
+
+ All of the server and client command routines will generate
+ response codes. On the server side, these responses will be turned
+ into text and sent to the client. On the client side, the reponse
+ is the one sent from the server.
+
+ Since each command can return multiple responses, the responses are
+ stored in the icalcstps object and are accesses by
+ icalcstps_first_response() and icalcstps_next_response()
+
+ How to use:
+
+ 1) Construct a new icalcstps, bound to your code via stubs
+ 2) Repeat forever:
+ 2a) Get string from client & give to icalcstps_next_input()
+ 2b) Repeat until icalcstp_next_output returns 0:
+ 2b1) Call icalcstps_next_output.
+ 2b2) Send string to client.
+*/
+
+
+
+typedef void icalcstps;
+
+/* Pointers to the rountines that
+ icalcstps_process_incoming will call when it recognizes a CSTP
+ command in the data. BTW, the CONTINUE command is named 'cont'
+ because 'continue' is a C keyword */
+
+struct icalcstps_commandfp {
+ icalerrorenum (*abort)(icalcstps* cstp);
+ icalerrorenum (*authenticate)(icalcstps* cstp, char* mechanism,
+ char* data);
+ icalerrorenum (*calidexpand)(icalcstps* cstp, char* calid);
+ icalerrorenum (*capability)(icalcstps* cstp);
+ icalerrorenum (*cont)(icalcstps* cstp, unsigned int time);
+ icalerrorenum (*identify)(icalcstps* cstp, char* id);
+ icalerrorenum (*disconnect)(icalcstps* cstp);
+ icalerrorenum (*sendata)(icalcstps* cstp, unsigned int time,
+ icalcomponent *comp);
+ icalerrorenum (*starttls)(icalcstps* cstp, char* command,
+ char* data);
+ icalerrorenum (*upnexpand)(icalcstps* cstp, char* upn);
+ icalerrorenum (*unknown)(icalcstps* cstp, char* command, char* data);
+};
+
+
+
+icalcstps* icalcstps_new(struct icalcstps_commandfp stubs);
+
+void icalcstps_free(icalcstps* cstp);
+
+int icalcstps_set_timeout(icalcstps* cstp, int sec);
+
+/* Get the next string to send to the client */
+char* icalcstps_next_output(icalcstps* cstp);
+
+/* process the next string from the client */
+int icalcstps_next_input(icalcstps* cstp);
+
+#endif /* ICALCSTPS */
generated by cgit (git 2.34.1) at 2024-11-19 10:53:55 +0800