path: root/win32/sablot/include/shandler.h

/*

 * The contents of this file are subject to the Mozilla Public

 * License Version 1.1 (the "License"); you may not use this file

 * except in compliance with the License. You may obtain a copy of

 * the License at http://www.mozilla.org/MPL/

 *

 * Software distributed under the License is distributed on an "AS

 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or

 * implied. See the License for the specific language governing

 * rights and limitations under the License.

 *

 * The Original Code is the Sablotron XSLT Processor.

 *

 * The Initial Developer of the Original Code is Ginger Alliance Ltd.

 * Portions created by Ginger Alliance are Copyright (C) 2000-2002

 * Ginger Alliance Ltd. All Rights Reserved.

 *

 * Contributor(s):

 *

 * Alternatively, the contents of this file may be used under the

 * terms of the GNU General Public License Version 2 or later (the

 * "GPL"), in which case the provisions of the GPL are applicable

 * instead of those above.  If you wish to allow use of your

 * version of this file only under the terms of the GPL and not to

 * allow others to use your version of this file under the MPL,

 * indicate your decision by deleting the provisions above and

 * replace them with the notice and other provisions required by

 * the GPL.  If you do not delete the provisions above, a recipient

 * may use your version of this file under either the MPL or the

 * GPL.

 */



#ifndef ShandlerHIncl

#define ShandlerHIncl



/* we have to deal with the size_t type, sys/types.h;

   is needed on some platforms */

#if !defined(_MSC_VER) && !defined(__BORLANDC__)

#include <sabcfg.h>

#endif



#include <stddef.h>



/* GP: clean */



/*****************************************************************



  handler types



*****************************************************************/



typedef enum

{

    HLR_MESSAGE = 0,

    HLR_SCHEME,

    HLR_SAX,

    HLR_MISC,

    HLR_ENC

} HandlerType;



extern const char* hlrTypeNames[]; /* found in base.cpp */



typedef enum

{

    SH_ERR_OK = 0,

    SH_ERR_NOT_OK = 1,

    SH_ERR_UNSUPPORTED_SCHEME

} SchemeHandlerErrors;



/*****************************************************************

SchemeHandler



  is a structure for a scheme handler. It contains pointers to

  the following functions of the handler:

        open(), get(), put(), close().

  All of these function return an error flag (0=OK, 1=not).

  open() may also return SH_ERR_UNSUPPORTED_SCHEME.

*****************************************************************/



/*  getAll: open the URI and return the whole string

        scheme = URI scheme (e.g. "http")

        rest = the rest of the URI (without colon)

        the document is returned in a handler-allocated buffer

        byteCount holds the byte count on return

        return *buffer = NULL if not processed

*/

typedef int SchemeHandlerGetAll(void *userData, SablotHandle processor_,

    const char *scheme, const char *rest,

    char **buffer, int *byteCount);



/*  freeMemory: free the buffer allocated by getAll

*/



typedef int SchemeHandlerFreeMemory(void *userData, SablotHandle processor_,

    char *buffer);



/*  open: open the URI and return a handle

        scheme = URI scheme (e.g. "http")

        rest = the rest of the URI (without colon)

        the resulting handle is returned in '*handle'

*/

typedef int SchemeHandlerOpen(void *userData, SablotHandle processor_,

    const char *scheme, const char *rest, int *handle);



/*  get: retrieve data from the URI

        handle = the handle assigned on open

        buffer = pointer to the data

        *byteCount = number of bytes to read

            (the number actually read is returned here)

*/

typedef int SchemeHandlerGet(void *userData, SablotHandle processor_,

    int handle, char *buffer, int *byteCount);



/*  put: save data to the URI (if possible)

        handle = the handle assigned on open

        buffer = pointer to the data

        *byteCount = number of bytes to write

            (the number actually written is returned here)

*/

typedef int SchemeHandlerPut(void *userData, SablotHandle processor_,

    int handle, const char *buffer, int *byteCount);



/*  close: close the URI with the given handle

        handle = the handle assigned on open

*/

typedef int SchemeHandlerClose(void *userData, SablotHandle processor_,

    int handle);



typedef struct

{

    SchemeHandlerGetAll *getAll;

    SchemeHandlerFreeMemory *freeMemory;

    SchemeHandlerOpen *open;

    SchemeHandlerGet *get;

    SchemeHandlerPut *put;

    SchemeHandlerClose *close;

} SchemeHandler;



/*****************************************************************

MessageHandler



  a structure for external message handlers. Such a handler, if set,

  receives all error reports, displays them, keeps the log, the

  error trace, etc.

*****************************************************************/



/*

   define the "facility number" for Sablotron. This does not mean much

   nowadays.

*/



#define MH_FACILITY_SABLOTRON 2



/* type for the error codes used by the message handler */



typedef unsigned long MH_ERROR;



/* logging levels for the message handler */



typedef enum

{

    MH_LEVEL_DEBUG,

    MH_LEVEL_INFO,

    MH_LEVEL_WARN,

    MH_LEVEL_ERROR,

    MH_LEVEL_CRITICAL

} MH_LEVEL;



/*

   makeCode()

   makes the "external" error code to report with log() or error()

   call with facility = module id; severity = 1 iff critical.

   'code' is the error code internal to Sablotron.

*/



typedef MH_ERROR

MessageHandlerMakeCode(

    void *userData, SablotHandle processor_,

    int severity, unsigned short facility, unsigned short code);



/*

   log()

   pass code created by makeCode, level as necessary

   fields is a NULL-terminated list of strings in form "field:contents"

   distinguished fields include: msg, file, line, token

*/



typedef MH_ERROR

MessageHandlerLog(

    void *userData, SablotHandle processor_,

    MH_ERROR code, MH_LEVEL level, char **fields);



/*

   error()

   for reporting errors, meaning as with log()

*/



typedef MH_ERROR

MessageHandlerError(void *userData, SablotHandle processor_,

    MH_ERROR code, MH_LEVEL level, char **fields);



/* the message handler structure. Use SablotRegMessageHandler() to register. */



typedef struct

{

    MessageHandlerMakeCode *makeCode;

    MessageHandlerLog *log;

    MessageHandlerError *error;

} MessageHandler;











/*



                SAXHandler

    a SAX-like, streaming interface for access to XML docs



*/





#define SAX_RETURN void



typedef SAX_RETURN

SAXHandlerStartDocument(void* userData, SablotHandle processor_);



typedef SAX_RETURN

SAXHandlerStartElement(void* userData, SablotHandle processor_,

    const char* name, const char** atts);



typedef SAX_RETURN

SAXHandlerEndElement(void* userData, SablotHandle processor_,

    const char* name);



typedef SAX_RETURN

SAXHandlerStartNamespace(void* userData, SablotHandle processor_,

    const char* prefix, const char* uri);



typedef SAX_RETURN

SAXHandlerEndNamespace(void* userData, SablotHandle processor_,

    const char* prefix);



typedef SAX_RETURN

SAXHandlerComment(void* userData, SablotHandle processor_,

    const char* contents);



typedef SAX_RETURN

SAXHandlerPI(void* userData, SablotHandle processor_,

    const char* target, const char* contents);



typedef SAX_RETURN

SAXHandlerCharacters(void* userData, SablotHandle processor_,

    const char* contents, int length);



typedef SAX_RETURN

SAXHandlerEndDocument(void* userData, SablotHandle processor_);





/*

    The SAX handler structure. Use SablotRegSAXHandler() to register.

*/





typedef struct

{

    SAXHandlerStartDocument     *startDocument;

    SAXHandlerStartElement      *startElement;

    SAXHandlerEndElement        *endElement;

    SAXHandlerStartNamespace    *startNamespace;

    SAXHandlerEndNamespace      *endNamespace;

    SAXHandlerComment           *comment;

    SAXHandlerPI                *processingInstruction;

    SAXHandlerCharacters        *characters;

    SAXHandlerEndDocument       *endDocument;

} SAXHandler;





/*****************************************************************

MiscHandler



  Collects miscellaneous callbacks.

*****************************************************************/



/*

    documentInfo()

    If set, this callback gets called after the output of a result

    document is finished, giving information about its content type

    and encoding.

*/



typedef void

MiscHandlerDocumentInfo(void* userData, SablotHandle processor_,

    const char *contentType, const char *encoding);



/*

    The Misc handler structure.

    Use SablotRegHandler(HLR_MISC, ...) to register.

*/



typedef struct

{

    MiscHandlerDocumentInfo     *documentInfo;

} MiscHandler;



/*****************************************************************

EncHandler



  Handler for recoding requests in absence of iconv.

*****************************************************************/



#define EH_FROM_UTF8 1

#define EH_TO_UTF8 0



/*

    the conversion descriptor like iconv_t

*/



typedef void* EHDescriptor;



typedef enum

{

    EH_OK,

    EH_EINVAL,

    EH_E2BIG,

    EH_EILSEQ

} EHResult;



/*

    open()

    direction is either EH_FROM_UTF8 or EH_TO_UTF8

    encoding is the other encoding

    RETURN the descriptor, or -1 if the encoding is not supported

*/



typedef EHDescriptor EncHandlerOpen(void* userData, SablotHandle processor_,

    int direction, const char *encoding);



/*

    conv()

    arguments 3 through 7 are just like for iconv, see the manpage

    RETURN -1 on error (set errno), a different value (e.g. 0) if OK

*/



typedef EHResult EncHandlerConv(void* userData, SablotHandle processor_,

    EHDescriptor cd, const char** inbuf, size_t *inbytesleft,

    char ** outbuf, size_t *outbytesleft);



/*

    close()

    cd is the descriptor to close. Return 0 if OK, -1 on error.

*/



typedef int EncHandlerClose(void* userData, SablotHandle processor_,

    EHDescriptor cd);



/*

    The EncHandler structure.

    Use SablotRegHandler(HLR_ENC, ...) to register.

*/



typedef struct

{

    EncHandlerOpen      *open;

    EncHandlerConv      *conv;

    EncHandlerClose     *close;

} EncHandler;



#endif