/*
  Meanwhile - Unofficial Lotus Sametime Community Client Library
  Copyright (C) 2004  Christopher (siege) O'Brien
  
  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Library General Public
  License as published by the Free Software Foundation; either
  version 2 of the License, or (at your option) any later version.
  
  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Library General Public License for more details.
  
  You should have received a copy of the GNU Library General Public
  License along with this library; if not, write to the Free
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#ifndef _MW_SESSION_H
#define _MW_SESSION_H


/** @file mw_session.h

    A client session with a Sametime server is encapsulated in the
    mwSession structure. The session controls channels, provides
    encryption ciphers, and manages services using messages over the
    Master channel.

    A session does not directly communicate with a socket or stream,
    instead the session is initialized from client code with an
    instance of a mwSessionHandler structure. This session handler
    provides functions as call-backs for common session events, and
    provides functions for writing-to and closing the connection to
    the server.

    A session does not perform reads on a socket directly. Instead, it
    must be fed from an outside source via the mwSession_recv
    function. The session will buffer and merge data passed to this
    function to build complete protocol messages, and will act upon
    each complete message accordingly.
*/


#include "mw_common.h"


#ifdef __cplusplus
extern "C" {
#endif


struct mwChannelSet;
struct mwCipher;
struct mwMessage;
struct mwService;


/** default protocol major version */
#define MW_PROTOCOL_VERSION_MAJOR  0x001e


/** default protocol minor version */
#define MW_PROTOCOL_VERSION_MINOR  0x001d


/** @section Session Properties
    for use with mwSession_setProperty, et al.
*/
/*@{*/

/** char *, session user ID */
#define mwSession_AUTH_USER_ID      "session.auth.user"

/** char *, plaintext password */
#define mwSession_AUTH_PASSWORD     "session.auth.password"

/** struct mwOpaque *, authentication token */
#define mwSession_AUTH_TOKEN        "session.auth.token"

/** char *, hostname of client */
#define mwSession_CLIENT_HOST       "client.host"

/** guint32, local IP of client */
#define mwSession_CLIENT_IP         "client.ip"

/** guint16, major version of client protocol */
#define mwSession_CLIENT_VER_MAJOR  "client.version.major"

/** guint16, minor version of client protocol */
#define mwSession_CLIENT_VER_MINOR  "client.version.minor"

/** guint16, client type identifier */
#define mwSession_CLIENT_TYPE_ID    "client.id"

/** guint16, major version of server protocol */
#define mwSession_SERVER_VER_MAJOR  "server.version.major"

/** guint16, minor version of server protocol */
#define mwSession_SERVER_VER_MINOR  "server.version.minor"

/*@}*/


enum mwSessionState {
  mwSession_STARTING,      /**< session is starting */
  mwSession_HANDSHAKE,     /**< session has sent handshake */
  mwSession_HANDSHAKE_ACK, /**< session has received handshake ack */
  mwSession_LOGIN,         /**< session has sent login */
  mwSession_LOGIN_REDIR,   /**< session has been redirected */
  mwSession_LOGIN_ACK,     /**< session has received login ack */
  mwSession_STARTED,       /**< session is active */
  mwSession_STOPPING,      /**< session is shutting down */
  mwSession_STOPPED,       /**< session is stopped */
  mwSession_UNKNOWN,       /**< indicates an error determining state */
  mwSession_LOGIN_CONT,    /**< session has sent a login continue */
};


#define mwSession_isState(session, state) \
  (mwSession_getState((session)) == (state))

#define mwSession_isStarting(s) \
  (mwSession_isState((s), mwSession_STARTING)  || \
   mwSession_isState((s), mwSession_HANDSHAKE) || \
   mwSession_isState((s), mwSession_HANDSHAKE_ACK) || \
   mwSession_isState((s), mwSession_LOGIN) || \
   mwSession_isState((s), mwSession_LOGIN_ACK) || \
   mwSession_isState((s), mwSession_LOGIN_REDIR) || \
   mwSession_isState((s), mwSession_LOGIN_CONT))

#define mwSession_isStarted(s) \
  (mwSession_isState((s), mwSession_STARTED))

#define mwSession_isStopping(s) \
  (mwSession_isState((s), mwSession_STOPPING))

#define mwSession_isStopped(s) \
  (mwSession_isState((s), mwSession_STOPPED))


/** @struct mwSession

    Represents a Sametime client session */
struct mwSession;


/** @struct mwSessionHandler

    session handler. Structure which interfaces a session with client
    code to provide I/O and event handling */
struct mwSessionHandler {
  
  /** write data to the server connection. Required. Should return
      zero for success, non-zero for error */
  int (*io_write)(struct mwSession *, const guchar *buf, gsize len);
  
  /** close the server connection. Required */
  void (*io_close)(struct mwSession *);

  /** triggered by mwSession_free. Optional. Put cleanup code here */
  void (*clear)(struct mwSession *);

  /** Called when the session has changed status.

      @see mwSession_getStateInfo for uses of info field

      @param s      the session
      @param state  the session's state
      @param info   additional state information */
  void (*on_stateChange)(struct mwSession *s,
			 enum mwSessionState state, gpointer info);

  /** called when privacy information has been sent or received

      @see mwSession_getPrivacyInfo
  */
  void (*on_setPrivacyInfo)(struct mwSession *);

  /** called when user status has changed

      @see mwSession_getUserStatus */
  void (*on_setUserStatus)(struct mwSession *);

  /** called when an admin messages has been received */
  void (*on_admin)(struct mwSession *, const char *text);

  /** called when an announcement arrives */
  void (*on_announce)(struct mwSession *, struct mwLoginInfo *from,
		      gboolean may_reply, const char *text);

};


/** allocate a new session */
struct mwSession *mwSession_new(struct mwSessionHandler *);


/** stop, clear, free a session. Does not free contained ciphers or
    services, these must be taken care of explicitly. */
void mwSession_free(struct mwSession *);


/** obtain a reference to the session's handler */
struct mwSessionHandler *mwSession_getHandler(struct mwSession *);


/** instruct the session to begin. This will result in the initial
    handshake message being sent. */
void mwSession_start(struct mwSession *);


/** instruct the session to shut down with the following reason
    code. */
void mwSession_stop(struct mwSession *, guint32 reason);


/** Data is buffered, unpacked, and parsed into a message, then
    processed accordingly. */
void mwSession_recv(struct mwSession *, const guchar *, gsize);


/** primarily used by services to have messages serialized and sent
    @param s    session to send message over
    @param msg  message to serialize and send
    @returns    0 for success */
int mwSession_send(struct mwSession *s, struct mwMessage *msg);


/** sends the keepalive byte */
int mwSession_sendKeepalive(struct mwSession *s);


/** respond to a login redirect message by forcing the login sequence
    to continue through the immediate server. */
int mwSession_forceLogin(struct mwSession *s);


/** send an announcement to a list of users/groups. Targets of
    announcement must be in the same community as the session.

    @param s          session to send announcement from
    @param may_reply  permit clients to reply. Not all clients honor this.
    @param text       text of announcement
    @param recipients list of recipients. Each recipient is specified
                      by a single string, prefix with "@U " for users
                      and "@G " for Notes Address Book groups.
*/
int mwSession_sendAnnounce(struct mwSession *s, gboolean may_reply,
			   const char *text, const GList *recipients);


/** set the internal privacy information, and inform the server as
    necessary. Triggers the on_setPrivacyInfo call-back. */
int mwSession_setPrivacyInfo(struct mwSession *, struct mwPrivacyInfo *);


/** direct reference to the session's internal privacy structure */
struct mwPrivacyInfo *mwSession_getPrivacyInfo(struct mwSession *);


/** reference the login information for the session */
struct mwLoginInfo *mwSession_getLoginInfo(struct mwSession *);


/** set the internal user status state, and inform the server as
    necessary. Triggers the on_setUserStatus call-back */
int mwSession_setUserStatus(struct mwSession *, struct mwUserStatus *);


struct mwUserStatus *mwSession_getUserStatus(struct mwSession *);


/** current status of the session */
enum mwSessionState mwSession_getState(struct mwSession *);


/** additional status-specific information. Depending on the state of
    the session, this value has different meaning.

    @li @c mwSession_STOPPING guint32 error code causing
    the session to shut down

    @li @c mwSession_STOPPED guint32 error code causing
    the session to shut down

    @li @c mwSession_LOGIN_REDIR (char *) host to redirect
    to
*/
gpointer mwSession_getStateInfo(struct mwSession *);


struct mwChannelSet *mwSession_getChannels(struct mwSession *);


/** adds a service to the session. If the session is started (or when
    the session is successfully started) and the service has a start
    function, the session will request service availability from the
    server. On receipt of the service availability notification, the
    session will call the service's start function.

    @return TRUE if the session was added correctly */
gboolean mwSession_addService(struct mwSession *, struct mwService *);


/** find a service by its type identifier */
struct mwService *mwSession_getService(struct mwSession *, guint32 type);


/** removes a service from the session. If the session is started and
    the service has a stop function, it will be called. Returns the
    removed service */
struct mwService *mwSession_removeService(struct mwSession *, guint32 type);


/** a GList of services in this session. The GList needs to be freed
    after use */
GList *mwSession_getServices(struct mwSession *);


/** instruct a STARTED session to check the server for the presense of
    a given service. The service will be automatically started upon
    receipt of an affirmative reply from the server. This function is
    automatically called upon all services in a session when the
    session is fully STARTED.

    Services which terminate due to an error may call this on
    themselves to re-initialize when their server-side counterpart is
    made available again.

    @param s     owning session
    @param type  service type ID */
void mwSession_senseService(struct mwSession *s, guint32 type);


/** adds a cipher to the session. */
gboolean mwSession_addCipher(struct mwSession *, struct mwCipher *);


/** find a cipher by its type identifier */
struct mwCipher *mwSession_getCipher(struct mwSession *, guint16 type);


/** remove a cipher from the session */
struct mwCipher *mwSession_removeCipher(struct mwSession *, guint16 type);


/** a GList of ciphers in this session. The GList needs to be freed
    after use */
GList *mwSession_getCiphers(struct mwSession *);


/** associate a key:value pair with the session. If an existing value is
    associated with the same key, it will have its clear function called
    and will be replaced with the new value */
void mwSession_setProperty(struct mwSession *, const char *key,
			   gpointer val, GDestroyNotify clear);


/** obtain the value of a previously set property, or NULL */
gpointer mwSession_getProperty(struct mwSession *, const char *key);


/** remove a property, calling the optional GDestroyNotify function
    indicated in mwSession_setProperty if applicable */
void mwSession_removeProperty(struct mwSession *, const char *key);


/** associate arbitrary data with the session for use by the client
    code. Only client applications should use this, never services.

    @param session  the session to associate the data with
    @param data     arbitrary client data
    @param clear    optional cleanup function called on data from
                    mwSession_removeClientData and mwSession_free
*/
void mwSession_setClientData(struct mwSession *session,
			     gpointer data, GDestroyNotify clear);


gpointer mwSession_getClientData(struct mwSession *session);


/** remove client data, calling the optional GDestroyNotify function
    indicated in mwSession_setClientData if applicable */
void mwSession_removeClientData(struct mwSession *session);


#ifdef __cplusplus
}
#endif


#endif /* _MW_SESSION_H */