fivedev/harbour-core
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

2009-07-28 01:51 UTC+0200 Viktor Szakats (harbour.01 syenar.hu)

Browse Source 
* external/libhpdf/Makefile
    + Enabled for os2/watcom.

  * include/hbdefs.h
    * Minor addition to new type section.
      'bool' is the new type for boolean, so maybe we should
      use them instead of hbBool/TRUE/FALSE.

  * source/rtl/hbsocket.c
    ! Added one 'static'.
    * Added one pair of paranthesis (formatting).

  * source/rtl/hbgtcore.c
  * source/rtl/hbsha1.c
  * contrib/hbwin/win_prt.c
    * Minor formatting.

  * contrib/xhb/xhbfunc.c
    + Added copyright holder for HB_F_EOF().

  * contrib/hbssl/ssl.c
    ! Minor typo in comment.

  * contrib/hbssl/hbssl.h
    ! Added HB_EXTERN_BEGIN/HB_EXTERN_END.

  * config/global.cf
    + Added HB_UNIX_COMPATIBLE variable.
    + Setting default lib install dir to lib/<arch>/<comp>
      on non-*nix systems.

  * examples/httpsrv/socket.c
    + Copied from uhttpd2. Please verify.
This commit is contained in:
Viktor Szakats
2009-07-27 23:54:06 +00:00
parent 2abefe1b3e
commit 4b7833ba16
12 changed files with 238 additions and 364 deletions
Download Patch File Download Diff File Expand all files Collapse all files

476
harbour/examples/httpsrv/socket.c
View File

@@ -2,15 +2,6 @@
* $Id$
*/
#include "hbapi.h"
#include "hbapiitm.h"
#if defined( HB_OS_WIN )
#define _WINSOCKAPI_ /* Prevents inclusion of winsock.h in windows.h */
#define HB_SOCKET_T SOCKET
#include <winsock2.h>
#include <windows.h>
/*
Function naming:
@@ -51,382 +42,199 @@
other: { AF_?, cAddressDump }
*/
#ifdef hb_parnidef
#undef hb_parnidef
#endif
#include "hbsocket.h"
#include "hbapiitm.h"
static int hb_parnidef( int iParam, int iValue )
{
return HB_ISNUM( iParam ) ? hb_parni( iParam ) : iValue;
}
static SOCKET hb_parsocket( int iParam )
static HB_SOCKET_T hb_parsocket( int iParam )
{
return HB_ISPOINTER( iParam ) ? ( SOCKET ) hb_parptr( 1 ) : INVALID_SOCKET;
return HB_ISPOINTER( iParam ) ? ( HB_SOCKET_T ) ( HB_PTRDIFF )
hb_parptr( iParam ) : HB_NO_SOCKET;
}
static void hb_retsocket( SOCKET hSocket )
static void hb_retsocket( HB_SOCKET_T hSocket )
{
if( hSocket == INVALID_SOCKET )
if( hSocket == HB_NO_SOCKET )
hb_ret();
else
hb_retptr( ( void* ) hSocket );
hb_retptr( ( void* ) ( HB_PTRDIFF ) hSocket );
}
static SOCKET hb_itemGetSocket( PHB_ITEM pItem )
static HB_SOCKET_T hb_itemGetSocket( PHB_ITEM pSocket )
{
return HB_IS_POINTER( pItem ) ? ( SOCKET ) hb_itemGetPtr( pItem ) : INVALID_SOCKET;
}
static PHB_ITEM hb_itemPutSocket( PHB_ITEM pItem, SOCKET hSocket )
{
if( ! pItem )
pItem = hb_itemNew( NULL );
if( hSocket == INVALID_SOCKET )
hb_itemClear( pItem );
if( pSocket && HB_IS_POINTER( pSocket ) )
return ( HB_SOCKET_T ) ( HB_PTRDIFF ) hb_itemGetPtr( pSocket );
else
hb_itemPutPtr( pItem, ( void* ) hSocket );
return pItem;
return HB_NO_SOCKET;
}
static void hb_itemGetSockaddr( PHB_ITEM pItem, struct sockaddr* sa )
HB_FUNC( SOCKET_INIT )
{
memset( sa, 0, sizeof( struct sockaddr ) );
hb_retni( hb_socketInit() );
}
if( HB_IS_ARRAY( pItem ) )
HB_FUNC( SOCKET_EXIT )
{
hb_socketCleanup();
}
HB_FUNC( SOCKET_ERROR )
{
hb_retni( hb_socketGetError() );
}
HB_FUNC( SOCKET_CREATE )
{
hb_retsocket( hb_socketOpen( hb_parnidef( 1, HB_SOCK_PF_INET ),
hb_parnidef( 2, HB_SOCK_STREAM ),
hb_parnidef( 3, HB_SOCK_IPPROTO_TCP ) ) );
}
HB_FUNC( SOCKET_CLOSE )
{
hb_retni( hb_socketClose( hb_parsocket( 1 ) ) );
}
HB_FUNC( SOCKET_BIND )
{
void * sa;
unsigned len;
if( hb_socketAddrFromItem( &sa, &len, hb_param( 2, HB_IT_ANY ) ) )
{
sa->sa_family = hb_arrayGetNI( pItem, 1 );
if( sa->sa_family == AF_INET )
{
( ( struct sockaddr_in* ) sa)->sin_addr.S_un.S_addr = inet_addr( hb_arrayGetCPtr( pItem, 2 ) );
( ( struct sockaddr_in* ) sa)->sin_port = htons( hb_arrayGetNI( pItem, 3 ) );
}
else
{
ULONG ulLen = hb_arrayGetCLen( pItem, 2 );
if( ulLen > sizeof( sa->sa_data ) )
ulLen = sizeof( sa->sa_data );
memcpy( sa->sa_data, hb_arrayGetCPtr( pItem, 2 ), ulLen );
}
hb_retni( hb_socketBind( hb_parsocket( 1 ), sa, len ) );
hb_xfree( sa );
}
}
static PHB_ITEM hb_itemPutSockaddr( PHB_ITEM pItem, const struct sockaddr* saddr )
HB_FUNC( SOCKET_LISTEN )
{
pItem = hb_itemNew( pItem );
if( saddr->sa_family == AF_INET )
{
hb_arrayNew( pItem, 3 );
hb_arraySetNI( pItem, 1, saddr->sa_family );
hb_arraySetC( pItem, 2, inet_ntoa( ( ( struct sockaddr_in* ) saddr )->sin_addr ) );
hb_arraySetNI( pItem, 3, ntohs( ( ( struct sockaddr_in* ) saddr )->sin_port ) );
}
else
{
hb_arrayNew( pItem, 2 );
hb_arraySetNI( pItem, 1, saddr->sa_family );
hb_arraySetCL( pItem, 2, saddr->sa_data, sizeof( saddr->sa_data ) );
}
return pItem;
hb_retni( hb_socketListen( hb_parsocket( 1 ), hb_parnidef( 2, 10 ) ) );
}
HB_FUNC ( SOCKET_INIT )
HB_FUNC( SOCKET_ACCEPT )
{
WSADATA wsad;
hb_retni( WSAStartup( hb_parnidef( 1, 257 ), &wsad ) );
hb_storclen( (char*) &wsad, sizeof( WSADATA ), 2 );
}
HB_FUNC ( SOCKET_EXIT )
{
hb_retni( WSACleanup() );
}
HB_FUNC ( SOCKET_ERROR )
{
hb_retni( WSAGetLastError() );
}
HB_FUNC ( SOCKET_CREATE )
{
hb_retsocket( socket( hb_parnidef( 1, PF_INET ),
hb_parnidef( 2, SOCK_STREAM ),
hb_parnidef( 3, IPPROTO_TCP ) ) );
}
HB_FUNC ( SOCKET_CLOSE )
{
hb_retni( closesocket( hb_parsocket( 1 ) ) );
}
HB_FUNC ( SOCKET_BIND )
{
struct sockaddr sa;
hb_itemGetSockaddr( hb_param( 2, HB_IT_ANY ), &sa );
hb_retni( bind( hb_parsocket( 1 ), &sa, sizeof( struct sockaddr ) ) );
}
HB_FUNC ( SOCKET_LISTEN )
{
hb_retni( listen( hb_parsocket( 1 ), hb_parnidef( 2, 10 ) ) );
}
HB_FUNC ( SOCKET_ACCEPT )
{
struct sockaddr saddr;
int iSize = sizeof( struct sockaddr );
hb_retsocket( accept( hb_parsocket( 1 ), &saddr, &iSize ) );
if( HB_ISBYREF( 2 ) )
{
PHB_ITEM pItem = hb_itemPutSockaddr( NULL, &saddr );
hb_itemParamStoreForward( 2, pItem );
hb_itemRelease( pItem );
void * sa;
unsigned len;
PHB_ITEM pItem;
hb_retsocket( hb_socketAccept( hb_parsocket( 1 ), &sa, &len,
HB_ISNUM( 3 ) ? hb_parnint( 3 ) : -1 ) );
pItem = hb_socketAddrToItem( sa, len );
if( pItem )
{
hb_itemParamStoreForward( 2, pItem );
hb_itemRelease( pItem );
}
else
hb_stor( 2 );
if( sa )
hb_xfree( sa );
}
else
hb_retsocket( hb_socketAccept( hb_parsocket( 1 ), NULL, 0,
HB_ISNUM( 3 ) ? hb_parnint( 3 ) : -1 ) );
}
HB_FUNC ( SOCKET_SHUTDOWN )
HB_FUNC( SOCKET_SHUTDOWN )
{
hb_retni( shutdown( hb_parsocket( 1 ), hb_parnidef( 2, SD_BOTH ) ) );
hb_retni( hb_socketShutdown( hb_parsocket( 1 ),
hb_parnidef( 2, HB_SOCK_SHUT_RDWR ) ) );
}
HB_FUNC ( SOCKET_RECV )
HB_FUNC( SOCKET_RECV )
{
int iLen, iRet;
char* pBuf;
char * pBuf;
long len;
iLen = hb_parni( 3 );
if( iLen > 65536 || iLen <= 0 )
iLen = 4096;
pBuf = ( char* ) hb_xgrab( ( ULONG ) iLen );
iRet = recv( hb_parsocket( 1 ), pBuf, iLen, hb_parnidef( 4, 0 ) );
hb_retni( iRet );
hb_storclen( pBuf, iRet > 0 ? iRet : 0, 2 );
len = hb_parni( 3 );
if( len <= 0 )
len = 4096;
pBuf = ( char* ) hb_xgrab( len + 1 );
len = hb_socketRecv( hb_parsocket( 1 ), pBuf, len, hb_parni( 4 ),
HB_ISNUM( 5 ) ? hb_parnint( 5 ) : -1 );
hb_retni( len );
hb_storclen( pBuf, len > 0 ? len : 0, 2 );
hb_xfree( pBuf );
}
HB_FUNC ( SOCKET_SEND )
HB_FUNC( SOCKET_SEND )
{
hb_retni( send( hb_parsocket( 1 ), hb_parc( 2 ), hb_parclen( 2 ), hb_parnidef( 3, 0 ) ) );
hb_retni( hb_socketSend( hb_parsocket( 1 ), hb_parc( 2 ), hb_parclen( 2 ),
hb_parni( 4 ), HB_ISNUM( 5 ) ? hb_parnint( 5 ) : -1 ) );
}
HB_FUNC ( SOCKET_SELECT )
HB_FUNC( SOCKET_GETSOCKNAME )
{
fd_set setread, setwrite, seterror;
BOOL bRead = 0, bWrite = 0, bError = 0;
struct timeval tv;
SOCKET socket, maxsocket;
PHB_ITEM pArray, pItem;
ULONG ulLen, ulIndex, ulCount;
LONG lTimeout;
int iRet;
FD_ZERO( &setread );
FD_ZERO( &setwrite );
FD_ZERO( &seterror );
maxsocket = (SOCKET) 0;
pArray = hb_param( 1, HB_IT_ARRAY );
if( pArray )
{
ulLen = hb_arrayLen( pArray );
for( ulIndex = 1; ulIndex <= ulLen; ulIndex++ )
{
socket = hb_itemGetSocket( hb_arrayGetItemPtr( pArray, ulIndex ) );
if( socket != INVALID_SOCKET )
{
bRead = 1;
FD_SET( socket, &setread );
if( socket > maxsocket )
maxsocket = socket;
}
}
}
pArray = hb_param( 2, HB_IT_ARRAY );
if( pArray )
{
ulLen = hb_arrayLen( pArray );
for( ulIndex = 1; ulIndex <= ulLen; ulIndex++ )
{
socket = hb_itemGetSocket( hb_arrayGetItemPtr( pArray, ulIndex ) );
if( socket != INVALID_SOCKET )
{
bWrite = 1;
FD_SET( socket, &setwrite );
if( socket > maxsocket )
maxsocket = socket;
}
}
}
pArray = hb_param( 3, HB_IT_ARRAY );
if( pArray )
{
ulLen = hb_arrayLen( pArray );
for( ulIndex = 1; ulIndex <= ulLen; ulIndex++ )
{
socket = hb_itemGetSocket( hb_arrayGetItemPtr( pArray, ulIndex ) );
if( socket != INVALID_SOCKET )
{
bError = 1;
FD_SET( socket, &seterror );
if( socket > maxsocket )
maxsocket = socket;
}
}
}
/* Default forever */
lTimeout = HB_ISNUM( 4 ) ? hb_parnl( 4 ) : -1;
if( lTimeout == -1 )
{
iRet = select( maxsocket + 1, bRead ? &setread : NULL, bWrite ? &setwrite: NULL,
bError ? &seterror : NULL, NULL );
}
else
{
tv.tv_sec = lTimeout / 1000;
tv.tv_usec = ( lTimeout % 1000 ) * 1000;
iRet = select( maxsocket + 1, bRead ? &setread : NULL, bWrite ? &setwrite: NULL,
bError ? &seterror : NULL, &tv );
}
pArray = hb_param( 1, HB_IT_ARRAY );
if( pArray && HB_ISBYREF( 1 ) )
{
ulLen = hb_arrayLen( pArray );
pItem = hb_itemNew( NULL );
hb_arrayNew( pItem, ulLen );
ulCount = 0;
for( ulIndex = 1; ulIndex <= ulLen; ulIndex++ )
{
socket = hb_itemGetSocket( hb_arrayGetItemPtr( pArray, ulIndex ) );
if( socket != INVALID_SOCKET )
{
if( FD_ISSET( socket, &setread ) )
{
hb_arraySetForward( pItem, ++ulCount, hb_itemPutSocket( NULL, socket ) );
}
}
}
hb_itemParamStoreForward( 1, pItem );
}
pArray = hb_param( 2, HB_IT_ARRAY );
if( pArray && HB_ISBYREF( 2 ) )
{
ulLen = hb_arrayLen( pArray );
pItem = hb_itemNew( NULL );
hb_arrayNew( pItem, ulLen );
ulCount = 0;
for( ulIndex = 1; ulIndex <= ulLen; ulIndex++ )
{
socket = hb_itemGetSocket( hb_arrayGetItemPtr( pArray, ulIndex ) );
if( socket != INVALID_SOCKET )
{
if( FD_ISSET( socket, &setwrite ) )
{
hb_arraySetForward( pItem, ++ulCount, hb_itemPutSocket( NULL, socket ) );
}
}
}
hb_itemParamStoreForward( 2, pItem );
}
pArray = hb_param( 3, HB_IT_ARRAY );
if( pArray && HB_ISBYREF( 3 ) )
{
ulLen = hb_arrayLen( pArray );
pItem = hb_itemNew( NULL );
hb_arrayNew( pItem, ulLen );
ulCount = 0;
for( ulIndex = 1; ulIndex <= ulLen; ulIndex++ )
{
socket = hb_itemGetSocket( hb_arrayGetItemPtr( pArray, ulIndex ) );
if( socket != INVALID_SOCKET )
{
if( FD_ISSET( socket, &seterror ) )
{
hb_arraySetForward( pItem, ++ulCount, hb_itemPutSocket( NULL, socket ) );
}
}
}
hb_itemParamStoreForward( 3, pItem );
}
void * sa;
unsigned len;
int iRet;
iRet = hb_socketGetSockName( hb_parsocket( 1 ), &sa, &len );
hb_retni( iRet );
}
HB_FUNC ( SOCKET_GETSOCKNAME )
{
struct sockaddr saddr;
int iSize = sizeof( struct sockaddr );
hb_retni( getsockname( hb_parsocket( 1 ), &saddr, &iSize ) );
if( HB_ISBYREF( 2 ) )
{
PHB_ITEM pItem = hb_itemPutSockaddr( NULL, &saddr );
hb_itemParamStoreForward( 2, pItem );
hb_itemRelease( pItem );
PHB_ITEM pItem = hb_socketAddrToItem( sa, len );
if( pItem )
{
hb_itemParamStoreForward( 2, pItem );
hb_itemRelease( pItem );
}
else
hb_stor( 2 );
}
if( sa )
hb_xfree( sa );
}
HB_FUNC( SOCKET_GETPEERNAME )
{
void * sa;
unsigned len;
int iRet;
iRet = hb_socketGetPeerName( hb_parsocket( 1 ), &sa, &len );
hb_retni( iRet );
if( HB_ISBYREF( 2 ) )
{
PHB_ITEM pItem = hb_socketAddrToItem( sa, len );
if( pItem )
{
hb_itemParamStoreForward( 2, pItem );
hb_itemRelease( pItem );
}
else
hb_stor( 2 );
}
if( sa )
hb_xfree( sa );
}
HB_FUNC( SOCKET_CONNECT )
{
void * sa;
unsigned len;
if( hb_socketAddrFromItem( &sa, &len, hb_param( 2, HB_IT_ANY ) ) )
{
hb_retni( hb_socketConnect( hb_parsocket( 1 ), sa, len,
HB_ISNUM( 3 ) ? hb_parnint( 3 ) : -1 ) );
hb_xfree( sa );
}
}
HB_FUNC ( SOCKET_GETPEERNAME )
HB_FUNC( SOCKET_SELECT )
{
struct sockaddr saddr;
int iSize = sizeof( struct sockaddr );
hb_retni( getpeername( hb_parsocket( 1 ), &saddr, &iSize ) );
if( HB_ISBYREF( 2 ) )
{
PHB_ITEM pItem = hb_itemPutSockaddr( NULL, &saddr );
hb_itemParamStoreForward( 2, pItem );
hb_itemRelease( pItem );
}
hb_retni( hb_socketSelect( hb_param( 1, HB_IT_ARRAY ), HB_ISBYREF( 1 ),
hb_param( 2, HB_IT_ARRAY ), HB_ISBYREF( 2 ),
hb_param( 3, HB_IT_ARRAY ), HB_ISBYREF( 3 ),
HB_ISNUM( 4 ) ? hb_parnint( 4 ) : -1,
hb_itemGetSocket ) );
}
HB_FUNC ( CONNECT )
{
struct sockaddr sa;
hb_itemGetSockaddr( hb_param( 2, HB_IT_ANY ), &sa );
hb_retni( connect( hb_parsocket( 1 ), &sa, sizeof( struct sockaddr ) ) );
}
#endif