fivedev/harbour-core
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
41b8ecb6c79b21abd7593ea0785c0960a7b20549
harbour-core/include/hbsocket.h
Przemysław Czerpak 41b8ecb6c7 2015-08-26 15:51 UTC+0200 Przemyslaw Czerpak (druzus/at/poczta.onet.pl) 
* include/hbsocket.h
  * src/rtl/hbsockhb.c
    + added socket filters to standard socket API.
      At C level hb_sockex*() function with PHB_SOCKEX handler can be
      used to operate on socket filters. At PRG level standard hb_socket*()
      functions can be used.
      The following things has been changed in PRG hb_socket*() functions:
      hb_socketErorrString() can accept <pSocket> as 1-st or 2-nd parameter
      and redirect call to socket filter errorStr() method.
      hb_socketClose() executes automatically shutdown() for connected
      sockets - it is important in windows only where without explicit
      call to shutdown() before close transmitted data can be lost.
      hb_socketSend() and hb_socketRecv() can be redirected to filter
      streams if filter set such redirection. If filter does not redirect
      them then they operate on raw sockets. If hb_socketSend() is
      redirected then sent data is flushed automatically.
      The following new PRG functions has been added:
      Add/replace socket filter:
         hb_socketSetFilter( <pSocket>, [<cFilterName>], [<hParams>] )
               -> <pSocket> | NIL
            <cFilterName> is filter name, It's possible to set many filters
            in single hb_socketSetFilter() call separating filter names
            with "|" character, i.e.:
               pSock := hb_socketSetFilter( pSock, "ZSOCK|BFSOCK", hParams )
            <hParams> is hash array with initialization parameters used by
            given socket filter. The core implementation recognize the
            following settings:
               "readahead" - numeric value with size of read ahead buffer
               "flush" - numeric value with auto flush parameter (for more
                         information look at hb_socketAutoFlush() below)
               "redir" - logical value which can be use to enable/disable
                         hb_socketSend() and hb_socketRecv() redirection
                         to filter stream.
      Return filter name used by socket:
         hb_socketGetFilter( <pSocket> ) -> <cFilterName>
      Read from socket stream:
         hb_socketRead( <pSocket>, @<cData>, [<nLen> = Len( cData )],
                        [<nTimeout> = FOREVER] ) -> <nRead>
         this function is similar to hb_socketRecv() but is always
         redirected to socket stream filters.
      Write to socket stream:
         hb_socketWrite( <pSocket>, <cData>, [<nLen> = Len( cData )],
                         [<nTimeout> = FOREVER] ) -> <nWritten>
         this function is similar to hb_socketSend() but it is always
         redirected to socket stream filters. Written data is not flushed
         by default and it should be flushed explicitly by hb_socketFlush().
         Automatic flushing can be enabled by hb_socketAutoFlush() function.
      Flush data written to socket:
         hb_socketFlush( <pSocket>, [<nTimeout> = FOREVER], [<lSync>] )
                     -> <nNotFlushed>
            <lSync> parameter is logical value which can be used to force
            special synchronization method in some filters. Usually users
            do not have to use it in normal code.
      Enable/disable automatic flushing of written data.
         hb_socketAutoFlush( <pSocket>, [ <nTimeout> ] ) -> <nTimeout>
            <nTimeout> is timeout for automatic flush operation on written
            data in milliseconds. <nTimeout> = -1 means wait forever and
            <nTimeout> = 0 disables auto flush.
         automatic flushing can help in adopting existing code anyhow it
         may strongly reduce the performance in some filters, i.e.
         compression filters like ZSOCK have to add special data to the
         stream after each flush operation so it's suggested to call
         flush explicitly when we want to force delivering written data
         to the peer.

  * include/hbznet.h
  * src/rtl/hbznet.c
    + added ZNET socket filter - compressed and encrypted streams are
      compatible with hb_znet*() streams. The old hb_znet*() interface
      is obsolete for pure socket communication and if not used as
      hb_inet*() filter then should be replaced by hb_sockex*() in
      user programs.
      ZNET socket filter can be created by new PRG functions:
         hb_socketNewZNet( <pSocket>, [<cPass>], [<nCompressionLevel>], ;
                           [<nStrategy>] ) -> <pSocket> | NIL
      or by standard socket API with "ZNET" as filter name.
      ZNET filter recognize the following settings in initialization
      hash array:
         "key" or "pass" - string with encryption password
         "zlib" - numeric compression level (HB_ZLIB_COMPRESSION_*)
         "zs" - numeric ZLIB compression strategy (HB_ZLIB_STRATEGY_*)
      ZNET filter always disables any other filters and operates on raw
      socket.
      Please remember that it's optional module. If programmer does not
      use hb_socketNewZNet() explicitly and prefers using hb_socketNew()
      then he should force linking this module by REQUEST hb_socketNewZNet

    + added fSync parameter to hb_znetFlush()
      [INCOMPATIBLE]

  * src/rtl/hbinet.c
    * call flush filter function before socket is closed

  * src/rtl/Makefile
  + src/rtl/hbzsock.c
    + added ZSOCK socket filter - ZLIB and GZIP compression for socket
      streams.
      ZSOCK socket filter can be created by new PRG functions:
         hb_socketNewZSock( <pSocket>, [<hParams>] ) -> <pSocket> | NIL
      or by standard socket API with "ZSOCK" as filter name.
      Programmers using hb_socketNew() can force linking this module by
         REQUEST hb_socketNewZSock
      ZSOCK filter can be used with other filters.
      ZSOCK filter recognize the following settings in initialization
      hash array:
         "zlib" - numeric compression level (HB_ZLIB_COMPRESSION_*)
         "zs" - numeric ZLIB compression strategy (HB_ZLIB_STRATEGY_*)
         "zin" - logical value which allow to enable/disable ZLIB
                 decompression on input stream (default)
         "gzin" - logical value which allow to enable/disable GZIP
                  decompression on input stream - it's possible to
                  enable both ZLIB and GZIP decompression together
                  so both streams can be decompress
         "zout" - logical value which allow to enable/disable ZLIB
                  compression on output stream (default)
         "gzout" - logical value which allow to enable/disable GZIP
                   compression on output stream - if both "zout" and
                   "gzout" are enabled GZIP compression is used.

  * src/rtl/Makefile
  + src/rtl/hbbfsock.c
    + added BFSOCK socket filter - BlowFish input and output stream
      encryption in CTR mode.
      BFSOCK socket filter can be created by new PRG functions:
         hb_socketNewBFSock( <pSocket>, [<hParams>] ) -> <pSocket> | NIL
      or by standard socket API with "BFSOCK" as filter name.
      Programmers using hb_socketNew() can force linking this module by
         REQUEST hb_socketNewBFSock
      BFSOCK filter can be used with other filters, i.e. with ZSOCK.
      Please only remember that good encryption algorithms have to
      generate data which cannot be compressed so using "BFSOCK|ZSOCK"
      only wastes resources and correct filter order is "ZSOCK|BFSOCK".
      BFSOCK filter recognize the following settings in initialization
      hash array:
         "key" or "pass" - string with encryption password
         "iv" - string with initialization vector for CTR mode

  * contrib/hbssl/hbssl.ch
  * contrib/hbssl/hbssl.h
  * contrib/hbssl/hbssl.hbm
  * contrib/hbssl/hbssl.hbx
  * contrib/hbssl/ssl.c
  * contrib/hbssl/ssl_inet.c
  + contrib/hbssl/ssl_sock.c
    + added SSL socket filter
      SSL socket filter can be created by new PRG functions:
         hb_socketNewSSL_connect( <pSocket>, <pSSL> [, <nTimeout> ] )
               -> <pSocketSSL> | NIL
         hb_socketNewSSL_accept( <pSocket>, <pSSL> [, <nTimeout> ] )
               -> <pSocketSSL> | NIL
      or by standard socket API with "SSL" as filter name.
      Programmers using hb_socketNew() can force linking this module by
         REQUEST hb_socketNewSSL_connect
      or
         REQUEST hb_socketNewSSL_accept
      SSL filter always disables any other filters and operates on raw
      socket.
      SSL filter recognize the following settings in initialization hash
      array:
         "ctx" or "key" - pointer SSL item <pSSL>
         "timeout" - timeout (numeric)
         "client" - logical value indicating client mode (SSL_connect())
         "server" - logical value indicating server mode (SSL_accept())

  * contrib/hbssl/tests/inetssl.prg
    ! cleaned typo in local function name

  * contrib/hbnetio/netiocli.c
  * contrib/hbnetio/netiosrv.c
    * use new Harbour extended socket API (hb_sockex*()) instead of
      raw sockets and hb_znet*()

  * contrib/hbtcpio/tcpio.c
    * use new Harbour extended socket API (hb_sockex*()) instead of
      raw sockets
    + implemented hb_fileFlush()
2015-08-26 15:51:35 +02:00

207 lines
11 KiB
C
Raw Blame History

/*
* Harbour Project source code:
* socket C API
*
* Copyright 2009 Przemyslaw Czerpak <druzus / at / priv.onet.pl>
* www - http://harbour-project.org
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this software; see the file COPYING.txt. If not, write to
* the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/).
*
* As a special exception, the Harbour Project gives permission for
* additional uses of the text contained in its release of Harbour.
*
* The exception is that, if you link the Harbour libraries with other
* files to produce an executable, this does not by itself cause the
* resulting executable to be covered by the GNU General Public License.
* Your use of that executable is in no way restricted on account of
* linking the Harbour library code into it.
*
* This exception does not however invalidate any other reasons why
* the executable file might be covered by the GNU General Public License.
*
* This exception applies only to the code released by the Harbour
* Project under the name Harbour. If you copy code from other
* Harbour Project or Free Software Foundation releases into a copy of
* Harbour, as the General Public License permits, the exception does
* not apply to the code that you add in this way. To avoid misleading
* anyone as to the status of such modified files, you must delete
* this exception notice from them.
*
* If you write modifications of your own for Harbour, it is your choice
* whether to permit this exception to apply to your modifications.
* If you do not wish that, delete this exception notice.
*
*/
#ifndef HB_SOCKET_H_
#define HB_SOCKET_H_
#include "hbapi.h"
#include "hbsocket.ch"
HB_EXTERN_BEGIN
#if defined( HB_OS_WIN ) && ! defined( HB_OS_UNIX )
typedef HB_PTRUINT HB_SOCKET;
#else
typedef int HB_SOCKET;
#endif
typedef HB_SOCKET ( * HB_SOCKET_FUNC )( PHB_ITEM );
#define HB_NO_SOCKET ( ( HB_SOCKET ) -1 )
extern HB_EXPORT void hb_socketAutoInit( void );
extern HB_EXPORT int hb_socketInit( void );
extern HB_EXPORT void hb_socketCleanup( void );
extern HB_EXPORT int hb_socketGetError( void );
extern HB_EXPORT int hb_socketGetOsError( void );
extern HB_EXPORT const char * hb_socketErrorStr( int iError );
extern HB_EXPORT void hb_socketSetError( int iError );
extern HB_EXPORT int hb_socketGetAddrFamily( const void * pSockAddr, unsigned len );
extern HB_EXPORT HB_BOOL hb_socketLocalAddr( void ** pSockAddr, unsigned * puiLen, const char * szAddr );
extern HB_EXPORT HB_BOOL hb_socketInetAddr( void ** pSockAddr, unsigned * puiLen, const char * szAddr, int iPort );
extern HB_EXPORT HB_BOOL hb_socketInet6Addr( void ** pSockAddr, unsigned * puiLen, const char * szAddr, int iPort );
extern HB_EXPORT char * hb_socketAddrGetName( const void * pSockAddr, unsigned len );
extern HB_EXPORT HB_BOOL hb_socketResolveInetAddr( void ** pSockAddr, unsigned * puiLen, const char * szAddr, int iPort );
extern HB_EXPORT char * hb_socketResolveAddr( const char * szAddr, int af );
extern HB_EXPORT PHB_ITEM hb_socketGetHosts( const char * szAddr, int af );
extern HB_EXPORT PHB_ITEM hb_socketGetAliases( const char * szAddr, int af );
extern HB_EXPORT char * hb_socketGetHostName( const void * pSockAddr, unsigned len );
extern HB_EXPORT PHB_ITEM hb_socketGetIFaces( int af, HB_BOOL fNoAliases );
extern HB_EXPORT int hb_socketAddrGetPort( const void * pSockAddr, unsigned len );
extern HB_EXPORT HB_BOOL hb_socketAddrFromItem( void ** pSockAddr, unsigned * puiLen, PHB_ITEM pAddrItm );
extern HB_EXPORT PHB_ITEM hb_socketAddrToItem( const void * pSockAddr, unsigned len );
extern HB_EXPORT int hb_socketGetSockName( HB_SOCKET sd, void ** pSockAddr, unsigned * puiLen );
extern HB_EXPORT int hb_socketGetPeerName( HB_SOCKET sd, void ** pSockAddr, unsigned * puiLen );
extern HB_EXPORT HB_SOCKET hb_socketOpen( int domain, int type, int protocol );
extern HB_EXPORT int hb_socketClose( HB_SOCKET sd );
extern HB_EXPORT int hb_socketShutdown( HB_SOCKET sd, int iMode );
extern HB_EXPORT int hb_socketBind( HB_SOCKET sd, const void * pSockAddr, unsigned uiLen );
extern HB_EXPORT int hb_socketListen( HB_SOCKET sd, int iBacklog );
extern HB_EXPORT HB_SOCKET hb_socketAccept( HB_SOCKET sd, void ** pSockAddr, unsigned * puiLen, HB_MAXINT timeout );
extern HB_EXPORT int hb_socketConnect( HB_SOCKET sd, const void * pSockAddr, unsigned uiLen, HB_MAXINT timeout );
extern HB_EXPORT long hb_socketSend( HB_SOCKET sd, const void * data, long len, int flags, HB_MAXINT timeout );
extern HB_EXPORT long hb_socketSendTo( HB_SOCKET sd, const void * data, long len, int flags, const void * pSockAddr, unsigned uiSockLen, HB_MAXINT timeout );
extern HB_EXPORT long hb_socketRecv( HB_SOCKET sd, void * data, long len, int flags, HB_MAXINT timeout );
extern HB_EXPORT long hb_socketRecvFrom( HB_SOCKET sd, void * data, long len, int flags, void ** pSockAddr, unsigned * puiSockLen, HB_MAXINT timeout );
extern HB_EXPORT int hb_socketSetBlockingIO( HB_SOCKET sd, HB_BOOL fBlocking );
extern HB_EXPORT int hb_socketSetNoDelay( HB_SOCKET sd, HB_BOOL fNoDelay );
extern HB_EXPORT int hb_socketSetExclusiveAddr( HB_SOCKET sd, HB_BOOL fExclusive );
extern HB_EXPORT int hb_socketSetReuseAddr( HB_SOCKET sd, HB_BOOL fReuse );
extern HB_EXPORT int hb_socketSetKeepAlive( HB_SOCKET sd, HB_BOOL fKeepAlive );
extern HB_EXPORT int hb_socketSetBroadcast( HB_SOCKET sd, HB_BOOL fBroadcast );
extern HB_EXPORT int hb_socketSetSndBufSize( HB_SOCKET sd, int iSize );
extern HB_EXPORT int hb_socketSetRcvBufSize( HB_SOCKET sd, int iSize );
extern HB_EXPORT int hb_socketGetRcvBufSize( HB_SOCKET sd, int * piSize );
extern HB_EXPORT int hb_socketGetSndBufSize( HB_SOCKET sd, int * piSize );
extern HB_EXPORT int hb_socketSetMulticast( HB_SOCKET sd, int af, const char * szAddr );
extern HB_EXPORT int hb_socketSelectRead( HB_SOCKET sd, HB_MAXINT timeout );
extern HB_EXPORT int hb_socketSelectWrite( HB_SOCKET sd, HB_MAXINT timeout );
extern HB_EXPORT int hb_socketSelectWriteEx( HB_SOCKET sd, HB_MAXINT timeout );
extern HB_EXPORT int hb_socketSelect( PHB_ITEM pArrayRD, HB_BOOL fSetRD,
PHB_ITEM pArrayWR, HB_BOOL fSetWR,
PHB_ITEM pArrayEX, HB_BOOL fSetEX,
HB_MAXINT timeout, HB_SOCKET_FUNC pFunc );
/* Harbour level socket item API functions */
extern HB_EXPORT HB_SOCKET hb_socketParam( int iParam );
extern HB_EXPORT HB_SOCKET hb_socketItemGet( PHB_ITEM pItem );
extern HB_EXPORT PHB_ITEM hb_socketItemPut( PHB_ITEM pItem, HB_SOCKET sd );
extern HB_EXPORT void hb_socketItemClear( PHB_ITEM pItem );
#define HB_SOCKET_FILTER_MAX 128
struct _HB_SOCKEX;
typedef struct _HB_SOCKEX * PHB_SOCKEX;
#if defined( _HB_SOCKEX_IMPLEMENTATION_ )
typedef struct
{
const char * pszName;
PHB_SOCKEX ( * New ) ( HB_SOCKET sd, PHB_ITEM pParams );
PHB_SOCKEX ( * Next ) ( PHB_SOCKEX pSock, PHB_ITEM pParams );
int ( * Close ) ( PHB_SOCKEX pSock, HB_BOOL fClose );
long ( * Read ) ( PHB_SOCKEX pSock, void * data, long len, HB_MAXINT timeout );
long ( * Write ) ( PHB_SOCKEX pSock, const void * data, long len, HB_MAXINT timeout );
long ( * Flush ) ( PHB_SOCKEX pSock, HB_MAXINT timeout, HB_BOOL fSync );
int ( * CanRead ) ( PHB_SOCKEX pSock, HB_BOOL fBuffer, HB_MAXINT timeout );
int ( * CanWrite ) ( PHB_SOCKEX pSock, HB_BOOL fBuffer, HB_MAXINT timeout );
char * ( * Name ) ( PHB_SOCKEX pSock );
const char *( * ErrorStr ) ( PHB_SOCKEX pSock, int iError );
}
HB_SOCKET_FILTER, * PHB_SOCKET_FILTER;
typedef struct _HB_SOCKEX
{
HB_SOCKET sd;
HB_BOOL fRedirAll;
HB_BOOL fShutDown;
int iAutoFlush;
long inbuffer;
long posbuffer;
long readahead;
HB_BYTE * buffer;
void * cargo;
const HB_SOCKET_FILTER * pFilter;
}
HB_SOCKEX;
extern HB_EXPORT int hb_sockexRegister( const HB_SOCKET_FILTER * pFilter );
#endif /* _HB_SOCKEX_IMPLEMENTATION_ */
extern HB_EXPORT int hb_sockexClose( PHB_SOCKEX pSock, HB_BOOL fClose );
extern HB_EXPORT long hb_sockexRead ( PHB_SOCKEX pSock, void * data, long len, HB_MAXINT timeout );
extern HB_EXPORT long hb_sockexWrite( PHB_SOCKEX pSock, const void * data, long len, HB_MAXINT timeout );
extern HB_EXPORT long hb_sockexFlush( PHB_SOCKEX pSock, HB_MAXINT timeout, HB_BOOL fSync );
extern HB_EXPORT int hb_sockexCanRead ( PHB_SOCKEX pSock, HB_BOOL fBuffer, HB_MAXINT timeout );
extern HB_EXPORT int hb_sockexCanWrite( PHB_SOCKEX pSock, HB_BOOL fBuffer, HB_MAXINT timeout );
extern HB_EXPORT int hb_sockexSelect( PHB_ITEM pArrayRD, HB_BOOL fSetRD,
PHB_ITEM pArrayWR, HB_BOOL fSetWR,
PHB_ITEM pArrayEX, HB_BOOL fSetEX,
HB_MAXINT timeout, HB_SOCKET_FUNC pFunc );
extern HB_EXPORT HB_BOOL hb_sockexIsRaw( PHB_SOCKEX pSock );
extern HB_EXPORT int hb_sockexRawClear( PHB_SOCKEX pSock, HB_BOOL fClear );
extern HB_EXPORT HB_SOCKET hb_sockexGetHandle( PHB_SOCKEX pSock );
extern HB_EXPORT void hb_sockexClearHandle( PHB_SOCKEX pSock );
extern HB_EXPORT void hb_sockexSetShutDown( PHB_SOCKEX pSock, HB_BOOL fShutDown );
extern HB_EXPORT HB_BOOL hb_sockexGetShutDown( PHB_SOCKEX pSock );
extern HB_EXPORT void hb_sockexSetAutoFlush( PHB_SOCKEX pSock, int iAutoFlush );
extern HB_EXPORT int hb_sockexGetAutoFlush( PHB_SOCKEX pSock );
extern HB_EXPORT void hb_socekxParamsInit( PHB_SOCKEX pSock, PHB_ITEM pParams );
extern HB_EXPORT void hb_socekxParamsGetStd( PHB_ITEM pParams,
const void ** pKeydata, int * pKeylen,
const void ** pIV, int * pIVlen,
int * pLevel, int * pStrategy );
extern HB_EXPORT PHB_SOCKEX hb_sockexNew( HB_SOCKET sd, const char * pszFilter, PHB_ITEM pParams );
extern HB_EXPORT PHB_SOCKEX hb_sockexNext( PHB_SOCKEX pSock, const char * pszFilter, PHB_ITEM pParams );
extern HB_EXPORT char * hb_sockexName( PHB_SOCKEX pSock );
extern HB_EXPORT const char * hb_sockexErrorStr( PHB_SOCKEX pSock, int iError );
extern HB_EXPORT PHB_SOCKEX hb_sockexParam( int iParam );
extern HB_EXPORT PHB_SOCKEX hb_sockexItemGet( PHB_ITEM pItem );
extern HB_EXPORT PHB_ITEM hb_sockexItemPut( PHB_ITEM pItem, PHB_SOCKEX pSock );
extern HB_EXPORT void hb_sockexItemClear( PHB_ITEM pItem );
extern HB_EXPORT HB_BOOL hb_sockexItemSetFilter( PHB_ITEM pItem, const char * pszFilter, PHB_ITEM pParams );
HB_EXTERN_END
#endif /* HB_SOCKET_H_ */
Reference in New Issue View Git Blame Copy Permalink