PlatformSW.cpp

Go to the documentation of this file.

// GENERIC version (sun, linux-x86, nios2, windows)
#define __NQ_INTERNAL_SW__

#include "PlatformSW.h"
#include "NQDeclarations.h"
#include "NQLogging.h"
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>


// includes for properly being able to handle thread calls to CNetworkQueue
// afair this is not required for anything else
#include "NQMessage.h"
#include "NQPacketQueue.h"
#include "NQResponseWaitQueue.h"
#include "NQMessagePool.h"
#include "NQPeerList.h"
#include "NQclass.h"

#ifdef __NEED_SOCKET_FUNCTIONS_SW__


    #if defined(PLF_UNIX_TCPIPSTACK) || defined(PLF_LWIP_TCPIPSTACK)
        // constants required by source code on unix and lwip
        const   INT32   SOCKET_ERROR    = -1;
        const   INT32   INVALID_SOCKET  = -1; 
    #endif

    #ifdef PLF_NICHE_TCPIPSTACK
        #define NICHE_SO_SENDBUF_SIZE 4096
        #define NICHE_SO_RECVBUF_SIZE 8192
    #endif


    const INT32 platformMaxFdSets = PLF_MAX_FDSETS;

    // create a human-readable IP-adress out of an host-encoded ip address

    ONECHAR *platformIPAddrConvert( const UINT32 ip_hostorder )
    {
        static char buffer[16];
        UINT32 networkorder = htonl(ip_hostorder);
        unsigned char *b = (unsigned char *) &networkorder;
    
        sprintf(buffer, "%d.%d.%d.%d", b[0], b[1], b[2], b[3]);
    
        return (ONECHAR *) buffer;
    }

    // four decimals separated by three dots
    // other forms are not supported!
    // returns INADDR_NONE in error case (syntactical, not logical!)
    UINT32 platformIPAddrConvert( const ONECHAR *ip_addr_dotted_string)
    {
        // returned ip address will be already in network byte order
    
        INT32 ip1, ip2, ip3, ip4;
        UINT32 ip_addr;
    
        int ret = sscanf((const char *) ip_addr_dotted_string, "%d.%d.%d.%d", &ip1, &ip2, &ip3, &ip4); 
        ret = 1; // make compiler happy
    
        if (ip1 < 0 || ip1 > 255) return INADDR_NONE;
        if (ip2 < 0 || ip2 > 255) return INADDR_NONE;
        if (ip2 < 0 || ip2 > 255) return INADDR_NONE;
        if (ip2 < 0 || ip2 > 255) return INADDR_NONE;

        #ifndef PLF_ENDIANCHANGE
            ip_addr = (ip1&0xff) + ((ip2&0xff)<<8) + ((ip3&0xff)<<16) + ((((UINT32)ip4)&0xff)<<24); 
        #else
            ip_addr = (ip4&0xff) + ((ip3&0xff)<<8) + ((ip2&0xff)<<16) + ((((UINT32)ip1)&0xff)<<24);
        #endif
    
        return ip_addr;
    }

    void        platformInitializeSocketSubsystem()
    {
        #ifdef PLF_WINNT_TCPIPSTACK
            WSADATA wsad;

            int ret = WSAStartup( 0x0202, &wsad);
            if (ret != 0) assert( 1==2 );
        #endif
    }

    void        platformDeinitializeSocketSubsystem()
    {
        #ifdef PLF_WINNT_TCPIPSTACK
            WSACleanup();
        #endif  
    }

    //
    socktype platformSocketCreateInet( INT32 type )
    {
        #ifdef PLF_UNIX_TCPIPSTACK
            return( socket( PF_INET, type, 0 ) );
        #endif

        #ifdef PLF_LWIP_TCPIPSTACK
            return( lwip_socket( PF_INET, type, 0 ) ); 
        #endif

        #ifdef PLF_WINNT_TCPIPSTACK
            socktype sockret;
            int cc1,cc2;
            int optval;
    
            sockret = socket( AF_INET, type, 0 );
    
            if (sockret == INVALID_SOCKET) return INVALID_SOCKET;
    
            optval = SO_RECVBUF_SIZE;
            cc1 = setsockopt(sockret,SOL_SOCKET,SO_RCVBUF,(const char *)&optval,sizeof(int));
    
            optval = SO_SENDBUF_SIZE;
            cc2 = setsockopt(sockret,SOL_SOCKET,SO_SNDBUF,(const char *)&optval,sizeof(int));

            if (cc1 != 0 || cc2 != 0) 
            {
                closesocket( sockret );
                return INVALID_SOCKET;
            }
    
            return sockret;
        #endif

        #ifdef PLF_NICHE_TCPIPSTACK
            socktype sockret;
            int cc1,cc2;
            int optval;
    
            sockret = bsd_socket( PF_INET, type, 0 );
    
            if (sockret == INVALID_SOCKET) return INVALID_SOCKET;
    
            optval = NICHE_SO_RECVBUF_SIZE;
            cc1 = t_setsockopt(sockret,SOL_SOCKET,SO_RCVBUF,(void *)&optval,sizeof(int));
    
            optval = NICHE_SO_SENDBUF_SIZE;
            cc2 = t_setsockopt(sockret,SOL_SOCKET,SO_SNDBUF,(void*)&optval,sizeof(int));

            if (cc1 != 0 || cc2 != 0) 
            {
                bsd_close( sockret );
                return INVALID_SOCKET;
            }

            return sockret;
        #endif
    }

    //
    // connect a previously created socket to the remote endpoint defined via Saddr 
    // used inside Network Queue for UDP connects
    //
    //      s       socket to be connected  
    //      Saddr   remote peer address to connect to
    //
    //  return:
    //          SOCKET_ERROR    on error
    //      0               successful connect
    //
    //
    // This function is part of the platform-independence wrapping and will be accessed by 
    // platform-independent parts of the Network Queue.
    //
    INT32 platformSocketConnect(socktype s, const struct sockaddr * Saddr, size_t size_sockaddr)
    {   
        #if defined(PLF_UNIX_TCPIPSTACK) || defined(PLF_WINNT_TCPIPSTACK)
            return( connect( s, Saddr, size_sockaddr) );
        #endif

        #ifdef PLF_LWIP_TCPIPSTACK
            return( lwip_connect( s, (sockaddr *) Saddr, size_sockaddr) );
        #endif

        #ifdef PLF_NICHE_TCPIPSTACK
            return( bsd_connect( s, (sockaddr *) Saddr, size_sockaddr) );
        #endif

    }

    //
    // bind a previously created socket to a local address defined via Saddr 
    // used inside Network Queue for UDP bind
    //
    //      s       socket to be bound
    //      Saddr   local address to bind socket to
    //
    //  return:
    //      SOCKET_ERROR    on error
    //      0               successful bind
    //
    //
    // This function is part of the platform-independence wrapping and will be accessed by 
    // platform-independent parts of the Network Queue.
    //
    INT32 platformSocketBind( socktype s, const struct sockaddr * Saddr, size_t size_sockaddr)
    {
        #if defined(PLF_UNIX_TCPIPSTACK) || defined(PLF_WINNT_TCPIPSTACK)
            return( bind( s, Saddr, size_sockaddr) );
        #endif

        #ifdef PLF_LWIP_TCPIPSTACK
            return( lwip_bind( s, (sockaddr *) Saddr, size_sockaddr) );
        #endif

        #ifdef PLF_NICHE_TCPIPSTACK
            return( bsd_bind( s, (sockaddr *) Saddr, size_sockaddr) );
        #endif
    }

    //
    // close or cleanup a socket (connected, but must work on unconnected sockets, too)
    // used inside Network Queue for UDP close()
    //
    //      s       socket to be cleaned up and closed
    //
    //  return:
    //      SOCKET_ERROR    on error
    //      0               successful close
    //
    //
    // This function is part of the platform-independence wrapping and will be accessed by 
    // platform-independent parts of the Network Queue.
    //
    INT32   platformSocketClose( socktype s )
    {
        #ifdef PLF_UNIX_TCPIPSTACK
            //shutdown(s, SHUT_WR);
    
            return( close( s ) ); 
        #endif
    
        #ifdef PLF_WINNT_TCPIPSTACK
            const int SD_SEND_WIN = 0x01;
            shutdown(s, SD_SEND_WIN);
    
            return( closesocket( s ) );
        #endif
  
        #ifdef PLF_LWIP_TCPIPSTACK
            return( lwip_close( s ) );
        #endif

        #ifdef PLF_NICHE_TCPIPSTACK
            return( bsd_close( s ) );
        #endif

    }

    INT32 platformSocketSelect(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout)
    {
        #if defined(PLF_UNIX_TCPIPSTACK) || defined(PLF_WINNT_TCPIPSTACK)
            return( select( n, readfds, writefds, exceptfds, timeout) );
        #endif

        #ifdef PLF_LWIP_TCPIPSTACK
            return( lwip_select( n, readfds, writefds, exceptfds, timeout) );
        #endif

        #ifdef PLF_NICHE_TCPIPSTACK
            return( bsd_select( n, readfds, writefds, exceptfds, timeout) );
        #endif

    }

/*
// wrapper for receive data on a connected socket
INT32 platformSocketReceiveFunction( socktype s, UINT8 *buf, UINT32 buflen)
{
    return( recv(s, (char *) buf, (INT32) buflen, 0) );
}

// wrapper for receive data on a connected socket
INT32 platformSocketSendFunction( socktype s, const UINT8 *buf, UINT32 buflen)
{
    return( send(s, (const char *) buf, (INT32) buflen, 0) );
}
*/

    INT32       platformSocketReceiveFromFunction( socktype s, UINT8 *buf, UINT32 buflen, UINT32 *ip_hostorder, UINT16 *port_hostorder)
    {
        INT32 retval;

        struct sockaddr_in fromaddr;
    
        #if defined(PLF_UNIX_TCPIPSTACK) || defined(PLF_LWIP_TCPIPSTACK) 
            socklen_t addrlen;
        #endif
        #if defined(PLF_WINNT_TCPIPSTACK) || defined(PLF_NICHE_TCPIPSTACK)
            INT32 addrlen;
        #endif

        addrlen = sizeof(fromaddr);

        #if defined(PLF_UNIX_TCPIPSTACK) || defined(PLF_WINNT_TCPIPSTACK)
            retval = recvfrom(s, (char *) buf, (INT32) buflen, 0, (sockaddr *) &fromaddr, &addrlen );
        #endif

        #ifdef PLF_LWIP_TCPIPSTACK
            retval = lwip_recvfrom(s, (char *) buf, (INT32) buflen, 0, (sockaddr *) &fromaddr, &addrlen );
        #endif
  
        #ifdef PLF_NICHE_TCPIPSTACK
            retval = bsd_recvfrom(s, (char *) buf, (INT32) buflen, 0, (sockaddr *) &fromaddr, &addrlen );
        #endif
  
        if (retval >= 0)
        {
            if (ip_hostorder != NULL)
                *ip_hostorder =  ntohl(fromaddr.sin_addr.s_addr); 
            if (port_hostorder != NULL)
                *port_hostorder = ntohs(fromaddr.sin_port);
        }

        return retval;
    }

    INT32       platformSocketSendToFunction( socktype s, const UINT8 *buf, UINT32 buflen, UINT32 ip_hostorder, UINT16 port_hostorder )
    {
        struct sockaddr_in toaddr;

        toaddr.sin_family = AF_INET;
        toaddr.sin_port = htons(port_hostorder);
        toaddr.sin_addr.s_addr = htonl(ip_hostorder);

        #if defined(PLF_UNIX_TCPIPSTACK) || defined(PLF_WINNT_TCPIPSTACK) 
            return( sendto(s, (const char *) buf, (INT32) buflen, 0, (const sockaddr *) &toaddr, sizeof(toaddr)) );
        #endif
  
        #ifdef PLF_LWIP_TCPIPSTACK
            return( lwip_sendto(s, (void *) buf, (INT32) buflen, 0, (sockaddr *) &toaddr, sizeof(toaddr)) );  
        #endif 

        #ifdef PLF_NICHE_TCPIPSTACK
            return( bsd_sendto(s, (char *) buf, (INT32) buflen, 0, (sockaddr *) &toaddr, sizeof(toaddr)) );  
        #endif 
    }

    INT32   platformSocketDisconnectUDP( socktype s)
    {
        #if defined(PLF_UNIX_TCPIPSTACK) || defined(PLF_WINNT_TCPIPSTACK) 
            struct sockaddr disconn;

            memset(&disconn, 0, sizeof (disconn));
            disconn.sa_family = AF_UNSPEC;      // not really necessary 
            INT32 ret = connect(s, &disconn, sizeof(disconn) );
            if (ret == SOCKET_ERROR) return SOCKET_ERROR;

            return 0; // success
            // -1 failure
        #endif
  
        #ifdef PLF_LWIP_TCPIPSTACK
            // SW! afaik on LWIP side there is no udp disconnect socket function!
            return 0; // success
        #endif

        #ifdef PLF_NICHE_TCPIPSTACK
            struct sockaddr disconn;

            memset(&disconn, 0, sizeof (disconn));
            disconn.sa_family = AF_UNSPEC;      // not really necessary 
            INT32 ret = bsd_connect(s, &disconn, sizeof(disconn) );
            if (ret == SOCKET_ERROR) return SOCKET_ERROR;

            return 0; // success
            // -1 failure
        #endif

    }

    //
    // wrapper in order to put the socket to nonblocking mode 
    //
    // 0 == success
    // or SOCKET_ERROR on error
    //

    INT32 platformSocketSetNonblocking ( socktype s )
    {
        #ifdef PLF_UNIX_TCPIPSTACK
            return fcntl( s, F_SETFL, FNONBLOCK | FASYNC );
        #endif

        #ifdef PLF_WINNT_TCPIPSTACK
            unsigned long nonblock = 1;
    
            return( ioctlsocket( s, FIONBIO, &nonblock) );
        #endif
    
        #ifdef PLF_LWIP_TCPIPSTACK
            unsigned long nonblock = 1;
  
            return( lwip_ioctl( s, FIONBIO, &nonblock) );
        #endif

        #ifdef PLF_NICHE_TCPIPSTACK
            unsigned long nonblock = 1;
  
            return( bsd_ioctl( s, FIONBIO, &nonblock) );
        #endif

    }

#endif // __NEED_SOCKET_FUNCTIONS_SW__




#ifdef PLF_USING_PTHREAD

// PLF_USING_PTHREAD only
int g_plf_send_prio;
void *internalThreadProcSendStatic(  LPVOID p )
{
    CNetworkQueue *q;

    // SW! Thread priorities disabled on solaris!
    //if (setpriority(PRIO_PROCESS, 0, g_plf_send_prio) != 0) 
    //{
    //  NQ_DBG(("Error on SetPriority SendThread %d\n", errno));
    //  assert(1==2);
    //}

    q = (CNetworkQueue *) p;
    q->SendProcessTask();
    
    return NULL;
}

// PLF_USING_PTHREAD only
int g_plf_recv_prio;
void *internalThreadProcReceiveStatic(  LPVOID p )
{
    CNetworkQueue *q;
    // SW! Thread priorities disabled on solaris!
    //if (setpriority(PRIO_PROCESS, 0, g_plf_recv_prio) != 0) 
    //{
    //  NQ_DBG(("Error on SetPriority(to:%d) RecvThread %d\n", g_plf_recv_prio, errno));
    //  assert(1==2);
    //}

    q = (CNetworkQueue *) p;
    q->ReceiveProcessTask();
    
    return NULL;
}


// PLF_USING_PTHREAD only
typedef struct 
{
    pthread_t             threadId1;
    pthread_attr_t        pthread_attr;
} thread_private_struct, *thread_private;


// PLF_USING_PTHREAD only
HANDLE  platformCreateThread( bool sendthread, VOIDP parameter, UINT32 thread_prio_sw)
{
    HANDLE plf_thread;
    thread_private hThread;
    int rc;
    int plf_prio;
    
    switch( thread_prio_sw)
    {
        case SW_THREAD_PRIORITY_ABOVE_NORMAL:
                plf_prio = -5;
                break;

        case SW_THREAD_PRIORITY_NORMAL:
                plf_prio = 0;
                break;

        case SW_THREAD_PRIORITY_BELOW_NORMAL:
                plf_prio = +5;
                break;

        default: return NULL;
            break; // not meaningful, but anyhow
    }
    
    hThread = (thread_private) malloc(sizeof(thread_private_struct));
    if (hThread == NULL) return NULL;
    
    if ( (rc = pthread_attr_init(&(hThread->pthread_attr))) )
    {
           NQ_DBG(( "pthread_attr_init ERROR.\n" ));
           free( hThread );
           return NULL;
    }

    // stacksize was: 120*1024
    // stack size not used on solaris!
    // as it does not harm linux, too, it was left out now also on Linux SW! Aug 29, 2007
    /*if ( (rc = pthread_attr_setstacksize(&(hThread->pthread_attr), stacksize)) )
    {
           NQ_DBG(( "pthread_attr_setstacksize ERROR.\n" ));
           pthread_attr_destroy(&(hThread->pthread_attr));
           free( hThread );
           return NULL;
    }*/

    if (sendthread == true)
    {
        g_plf_send_prio = plf_prio;
        if ( (rc = pthread_create(&(hThread->threadId1), &(hThread->pthread_attr), internalThreadProcSendStatic, parameter )) )
        {
            NQ_DBG(( "pthread_create ERROR.\n" ));
            pthread_attr_destroy(&(hThread->pthread_attr));
            free( hThread );
            
            return NULL;
        }
    }
    else
    {
        g_plf_recv_prio = plf_prio;
        if ( (rc = pthread_create(&(hThread->threadId1), &(hThread->pthread_attr), internalThreadProcReceiveStatic, parameter )) )
        {
            NQ_DBG(( "pthread_create ERROR.\n" ));
            pthread_attr_destroy(&(hThread->pthread_attr));
            free( hThread );
            
            return NULL;
        }
    }
    
    plf_thread = hThread;
    return plf_thread;  
}

// PLF_USING_PTHREAD only
bool        platformDeleteThread( HANDLE threadhandle )
{
    if (threadhandle == NULL) return false;
    
    thread_private hThread = (thread_private) threadhandle;
    
    pthread_attr_destroy(&(hThread->pthread_attr));
    
    free( hThread );

    return true;
}

// PLF_USING_PTHREAD only
typedef struct 
{
    pthread_mutex_t mutex;
    pthread_cond_t      condition;
    int         semCount;   
    int         semMaxCount;
}sem_private_struct, *sem_private;

// PLF_USING_PTHREAD only
HANDLE platformCreateSemaphore( UINT16 maximum_count )
{
    HANDLE sem;
    int rc;
    
    sem_private token;
    
    token = (sem_private) malloc(sizeof(sem_private_struct));

    if ((rc = pthread_mutex_init(&(token->mutex), NULL)))
    {
        free(token);
        
        return NULL; //RC_OBJECT_NOT_CREATED;
    }

    if ((rc = pthread_cond_init(&(token->condition), NULL)))
    {
        pthread_mutex_destroy( &(token->mutex) );
        free(token);

        return NULL; //RC_OBJECT_NOT_CREATED;
    }

    token->semCount = 0;
    token->semMaxCount = maximum_count;

    sem = token;

    return sem;
}

// PLF_USING_PTHREAD only
bool platformDeleteSemaphore( HANDLE semaph )
{
    sem_private token = (sem_private) semaph;
    
    if (token == NULL) return false;
    
    pthread_mutex_destroy(&(token->mutex));

    pthread_cond_destroy(&(token->condition));

    free (token);
        
    return true;
}

// PLF_USING_PTHREAD only
bool platformWaitForSemaphore( HANDLE semaph, UINT32 timeout_msec )
{
    int rc;
    struct timespec tm;
    struct timeb tp;
    long sec, millisec;
    
    sem_private token = (sem_private) semaph;

    if ((rc = pthread_mutex_lock(&(token->mutex)))) return false; //RC_SEM_WAIT_ERROR;

    if (timeout_msec > 0)
    {
        sec = timeout_msec / 1000;
        millisec = timeout_msec % 1000;
        ftime( &tp );
        tp.time += sec;
        tp.millitm += millisec;
    
        if( tp.millitm > 999 )
        {
            tp.millitm -= 1000;
            tp.time++;
        }
    
        tm.tv_sec = tp.time;
        tm.tv_nsec = tp.millitm * 1000000 ;
    }

    while (token->semCount <= 0)
    {
        if (timeout_msec == 0)
        {
            rc = pthread_cond_wait(&(token->condition), &(token->mutex));
        }
        else
        {
            rc = pthread_cond_timedwait(&(token->condition), &(token->mutex), &tm);
        }
        if (rc && (errno != EINTR) )
        break;
    }

    if (rc)
    {
        if ( pthread_mutex_unlock(&(token->mutex)) ) return false; //RC_SEM_WAIT_ERROR );

        if ( rc == ETIMEDOUT ) 
        {
            //NQ_DBG(("Sema timed out.\n"));
            /* we have a time out */ return false; //RC_TIMEOUT );
        }

        return false; //RC_SEM_WAIT_ERROR );
    }

    token->semCount--;

    if ((rc = pthread_mutex_unlock(&(token->mutex)))) return false; //RC_SEM_WAIT_ERROR;

    return true;
}

// PLF_USING_PTHREAD only
bool platformSignalSemaphore( HANDLE semaphore )
{
    bool retval = true;
    int rc;
    
    sem_private token = (sem_private) semaphore;
    
    if (token == NULL) return false;
    
    if ((rc = pthread_mutex_lock(&(token->mutex)))) return false;

    if (token->semCount < token->semMaxCount)
    {
        token->semCount ++;
    }
    else retval = false;
    
    if ((rc = pthread_mutex_unlock(&(token->mutex))))   return false;

    if (retval == true) if ((rc = pthread_cond_signal(&(token->condition)))) return false;  
        
    return retval;
}

// PLF_USING_PTHREAD only
bool        platformIsSemaphoreSignalled( HANDLE semaph )
{
    int rc;
    bool retval = true;
    
    assert( semaph != NULL );
    
    sem_private token = (sem_private) semaph;

    if ((rc = pthread_mutex_lock(&(token->mutex)))) return false; //RC_SEM_WAIT_ERROR;

    // async under posix is (by lack of knowledge) implemented as 1 msec wait and return

    if (token->semCount <= 0) retval = false;
    if (retval == true) token->semCount--;

    if ((rc = pthread_mutex_unlock(&(token->mutex)))) return false; //RC_SEM_WAIT_ERROR;

    return retval;
}

// PLF_USING_PTHREAD only
typedef struct 
{
    pthread_mutex_t     mutex;
    pthread_cond_t      condition;
    bool                            mutex_set;
}mtx_private_struct, *mutex_private;

// PLF_USING_PTHREAD only
HANDLE      platformCreateMutex()
{
    mutex_private     mutexstruct;
    int rc=0;
    HANDLE mutex_ret;

    mutexstruct = (mutex_private) malloc(sizeof(mtx_private_struct));
    if (mutexstruct == NULL) return NULL;
    
    
    if ( (rc = pthread_mutex_init( &(mutexstruct->mutex), NULL) ))
    {
        free( mutexstruct );
        return NULL; //RC_OBJECT_NOT_CREATED;
    }

    if( (rc = pthread_cond_init(&(mutexstruct->condition), NULL)) )
    {
        pthread_mutex_destroy( &(mutexstruct->mutex) );
        free(mutexstruct);
      
        return NULL; //RC_OBJECT_NOT_CREATED;
    }

    mutexstruct->mutex_set = false;

    mutex_ret = mutexstruct;
    
    return mutex_ret;
}

// PLF_USING_PTHREAD only
bool        platformDeleteMutex( HANDLE mutex )
{
    if (mutex == NULL) return false;
    int rc;
    mutex_private mutexstruct = (mutex_private) mutex;

    if ( (rc = pthread_cond_destroy(&(mutexstruct->condition))) ) return false;
    if ( (rc = pthread_mutex_destroy(&(mutexstruct->mutex))) ) return false;

    free(mutexstruct);
    
    return true;
}

// PLF_USING_PTHREAD only
bool        platformWaitForMutex( HANDLE mutex, UINT32 timeout_msec )
{
    if (mutex == NULL) return false;
    
    mutex_private mutexstruct = (mutex_private) mutex;
    int rc=0;
    struct timespec tm;
    struct timeb tp;
    long sec, millisec;

    // wait and lock a mutex
    if ((rc = pthread_mutex_lock(&(mutexstruct->mutex)))) return false; //RC_SEM_WAIT_ERROR;

    if (mutexstruct->mutex_set == false) 
    {
        return true;
    }

    if (timeout_msec > 0)
    {
        sec = timeout_msec / 1000;
        millisec = timeout_msec % 1000;
        ftime( &tp );
        tp.time += sec;
        tp.millitm += millisec;
    
        if( tp.millitm > 999 )
        {
            tp.millitm -= 1000;
            tp.time++;
        }
    
        tm.tv_sec = tp.time;
        tm.tv_nsec = tp.millitm * 1000000 ;
    }

    do 
    {
        if (timeout_msec == 0)
        {
            rc = pthread_cond_wait(&(mutexstruct->condition), &(mutexstruct->mutex));
        }
        else
        {
            rc = pthread_cond_timedwait(&(mutexstruct->condition), &(mutexstruct->mutex), &tm);
        }
        if (rc && (errno != EINTR) ) break;
    } 
    while (mutexstruct->mutex_set == true);


    if (rc)
    {
        if ( pthread_mutex_unlock(&(mutexstruct->mutex)) ) return false; //RC_SEM_WAIT_ERROR );

        if ( rc == ETIMEDOUT ) /* we have a time out */ return false; //RC_TIMEOUT );

        return false; //RC_SEM_WAIT_ERROR );
    }

    if ((rc = pthread_mutex_lock(&(mutexstruct->mutex)))) return false; //RC_SEM_WAIT_ERROR;
    mutexstruct->mutex_set = true;


    return true;
}

// PLF_USING_PTHREAD only
bool        platformSignalMutex( HANDLE mutex )
{
    // unlock a mutex
    
    if (mutex == NULL) return false;
    mutex_private mutexstruct = (mutex_private) mutex;
    int rc=0;
        
    if ((rc = pthread_mutex_unlock(&(mutexstruct->mutex))) ) return false; //RC_UNLOCK_ERROR;
    mutexstruct->mutex_set = false;
    pthread_cond_signal(&(mutexstruct->condition));
    
    return true;
}

#endif // PLF_USING_PTHREAD only

#if defined(PLF_SYSTEM_SOLARIS) || defined(PLF_SYSTEM_LINUX) || defined(PLF_SYSTEM_NIOS2)

    // unix, solaris, nios2 only
    UINT32      platformGetLastError()
    {
        return( errno );
    } 

  // unix, solaris, nios2 only
    INT32       platformSocketGetLastError()
    {
        return( errno );
    }

  // unix, solaris, nios2 only
    ONECHAR    *platformGetOSErrorString( UINT32 intOSLastError, ONECHAR *lasterrorstr, UINT32 maxlength_lasterrorstr)
    {
        char *lbuf = strerror( intOSLastError );
        unsigned int len = strlen(lbuf);

        if (len >= maxlength_lasterrorstr) len = maxlength_lasterrorstr - 1;
        memcpy(lasterrorstr, lbuf, len);
        lasterrorstr[len] = 0;
    
        return lasterrorstr;
    } 


#endif // unix, solaris, nios2 only



#ifdef PLF_SYSTEM_WINNT

    // PLF_SYSTEM_WINNT only
    UINT32      platformGetLastError()
    {
        return( GetLastError() );
    } 

    // PLF_SYSTEM_WINNT only
    INT32 platformSocketGetLastError()
    {
        INT32 lasterr = WSAGetLastError();
        INT32 retcode;

        switch( lasterr )
        {
            case WSAEADDRNOTAVAIL:  retcode = EADDRNOTAVAIL;
                                break;

            case WSAEAFNOSUPPORT:   retcode = EAFNOSUPPORT;
                                break;

            case WSAEALREADY:       retcode = EALREADY;
                                break;

            case WSAEBADF:          retcode = EBADF;
                                break;

            case WSAECONNREFUSED:   retcode = ECONNREFUSED;
                                break;

            case WSAEINPROGRESS:    retcode = EINPROGRESS;
                                break;

            case WSAEINTR:          retcode = EINTR;
                                break;

            case WSAEISCONN:        retcode = EISCONN;
                                break;

            case WSAENETUNREACH:    retcode = ENETUNREACH;
                                break;

            case WSAENOTSOCK:       retcode = ENOTSOCK;
                                break;

            case WSAEPROTOTYPE:     retcode = EPROTOTYPE;
                                break;

            case WSAETIMEDOUT:      retcode = ETIMEDOUT;
                                break;

            case WSAEADDRINUSE:     retcode = EADDRINUSE;
                                break;

            case WSAECONNRESET:     retcode = ECONNRESET;
                                break;

            case WSAEHOSTUNREACH:   retcode = EHOSTUNREACH;
                                break;

            case WSAEINVAL:         retcode = EINVAL;
                                break;

            case WSAEHOSTDOWN:      retcode = EHOSTDOWN;
                                break;

            case WSAENAMETOOLONG:   retcode = ENAMETOOLONG;
                                break;

            case WSAENETDOWN:       retcode = ENETDOWN;
                                break;

            case WSAEWOULDBLOCK:    retcode = EAGAIN;
                                break;

            default:                retcode = EUNKNOWN;
                                break;

        }

        return retcode;
    }

    //
    // This function is a translator. It converts a platform-dependent error code into a descriptive 
    // string that is aimed to give human readable output what error happened (and maybe why).
    //
    // Parameters:
    //  [I]     intOSLastError              the platform-dependent error code to translate
    //  [I/O]   lasterrorstr                pointer to a ONECHAR array to hold the resulting string
    //  [I]     maxlength_lasterrorstr      number of characters in the ONECHAR array at 'lasterrorstr' position
    //
    // Return-value:
    //  pointer to lasterrorstr
    //
  // The error handling is only done by asserts. In case the buffer location behind lasterrorstr is too small, 
  // the created string will be cutted to fit accordingly. Based on experience I recommend to use more than 
  // 80 chars for safety. It MUST contain at least 16 characters.
  //
  // In case the translation failed, the lasterror string will be "Unknown error.".
  //
  // This function is part of the platform-independence wrapping and will be accessed by 
  // platform-independent parts of the Network Queue.
  //
  ONECHAR      *platformGetOSErrorString( UINT32 intOSLastError, ONECHAR *lasterrorstr, UINT32 maxlength_lasterrorstr)
  {
    assert( lasterrorstr != NULL );
  
    LPSTR MessageBuffer;
    DWORD dwBufferLength;
  
    DWORD dwFormatFlags =   FORMAT_MESSAGE_ALLOCATE_BUFFER |
                            FORMAT_MESSAGE_IGNORE_INSERTS |
                            FORMAT_MESSAGE_FROM_SYSTEM ;
  
    //
    // Call FormatMessage() to allow for message 
    //  text to be acquired from the system 
    //  or from the supplied module handle.
    //
  
    strcpy((char *) lasterrorstr, "Unknown error.");
  
    dwBufferLength = FormatMessageA(dwFormatFlags, 
                                    NULL, // module to get message from (NULL == system)
                                    intOSLastError,
                                    MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // default language
                                    (LPSTR) &MessageBuffer,
                                    0,
                                    NULL);
    if (dwBufferLength > 0)
    {
        // remove CRLF from string if it exists!
        if (MessageBuffer[strlen(MessageBuffer)-1] == 10) MessageBuffer[strlen(MessageBuffer)-1] = 0;
        if (MessageBuffer[strlen(MessageBuffer)-1] == 13) MessageBuffer[strlen(MessageBuffer)-1] = 0;
            
  
        unsigned int len = strlen(MessageBuffer);
            
        if (len >= maxlength_lasterrorstr) len = maxlength_lasterrorstr - 1;
        memcpy(lasterrorstr, MessageBuffer, len);
        lasterrorstr[len] = 0;
  
        LocalFree(MessageBuffer);
    }
  
    return lasterrorstr;
  }

  
  //
  //
  // Thread and Task stuff
  //
  //
  
  //
  // internalThreadProcSendStatic()
  //
  // This function is used as a send thread entry point wrapper by platform dependent function
  // platformCreateThread(). It sets the thread priority according to the global parameters
  // listed on top. After that, the send thread/task function inside the CNetworkQueue is called.
  //
  // The function must return at the end what the operating system expects as a normal (graceful) 
  // thread exit. The parameter p is required to contain a pointer reference to the initialized 
  // CNetworkQueue instance.
  //
  // This function is used internally in this platform.cpp file.
  //
  int g_plf_send_prio;
  HANDLE g_plf_send_thread;
  
  DWORD WINAPI internalThreadProcSendStatic( LPVOID p )
  {
    CNetworkQueue *q;
  
    BOOL ret = SetThreadPriority( g_plf_send_thread, g_plf_send_prio);
    assert( ret == TRUE );
  
    q = (CNetworkQueue *) p;
    q->SendProcessTask();
  
    return 0;
  }
  
  //
  // internalThreadProcReceiveStatic()
  //
  // This function is used as a receive thread entry point wrapper by platform dependent function
  // platformCreateThread(). It sets the thread priority according to the global parameters
  // listed on top. After that, the receive thread/task function inside the CNetworkQueue is called.
  //
  // The function must return at the end what the operating system expects as a normal (graceful) 
  // thread exit. The parameter p is required to contain a pointer reference to the initialized 
  // CNetworkQueue instance.
  //
  // This function is used internally in this platform.cpp file.
  //
  int g_plf_recv_prio;
  HANDLE g_plf_recv_thread;
  
  DWORD WINAPI internalThreadProcReceiveStatic(  LPVOID p )
  {
    CNetworkQueue *q;
  
    BOOL ret = SetThreadPriority( g_plf_recv_thread, g_plf_recv_prio);
    assert( ret == TRUE );
  
    q = (CNetworkQueue *) p;
    q->ReceiveProcessTask();
  
    return 0;
  }
  
  //
  // This function is required to start up either Send Task/Thread or Receive Task/Thread.
  // The second variable will be passed to the created task and must contain (in this 
  // NetworkQueue implementation) a pointer address to instance of class CNetworkQueue.
  // The thread priority in a platform-independent manner is passed as third variable.
  //
  // Parameters:
  //    sendthread          true: send thread       false: receive thread
  //  parameter         parameter to pass to newly created thread/task
  //                        MUST contain a reference pointer to an instance of CNetworkQueue
  //    thread_prio_sw      desired thread or task priority in a platform-independent manner
  //
  // Return-value:
  //    NULL                error on create thread/task (bad prio or platform-dependent error)
  //    <>NULL              HANDLE to the thread/task
  //
  // This function is part of the platform-independence wrapping and will be accessed by 
  // platform-independent parts of the Network Queue.
  //
  HANDLE    platformCreateThread( bool sendthread, VOIDP parameter, UINT32 thread_prio_sw)
  {
    HANDLE plf_thread;
    int plf_prio;
  
    switch( thread_prio_sw)
    {
  
        case SW_THREAD_PRIORITY_ABOVE_NORMAL:
                plf_prio = THREAD_PRIORITY_ABOVE_NORMAL;
                break;
  
        case SW_THREAD_PRIORITY_NORMAL:
                plf_prio = THREAD_PRIORITY_NORMAL;
                break;
  
        case SW_THREAD_PRIORITY_BELOW_NORMAL:
                plf_prio = THREAD_PRIORITY_BELOW_NORMAL;
                break;
  
        default: return NULL;
            break; // not meaningful, but anyhow
  
    }
  
    if (sendthread == true)
    {
        DWORD dummy_thread_id_send; 
        plf_thread = CreateThread(NULL, 0, internalThreadProcSendStatic, parameter, CREATE_SUSPENDED, &dummy_thread_id_send );
        if (plf_thread != NULL)
        {
            g_plf_send_prio = plf_prio;
            g_plf_send_thread = plf_thread;
            ResumeThread(g_plf_send_thread);
        }
    }
    else
    {
        DWORD dummy_thread_id_recv; 
        plf_thread = CreateThread(NULL, 0, internalThreadProcReceiveStatic, parameter, CREATE_SUSPENDED, &dummy_thread_id_recv );
        if (plf_thread != NULL)
        {
            g_plf_recv_prio = plf_prio;
            g_plf_recv_thread = plf_thread;
            ResumeThread(g_plf_recv_thread);
        }
    }
  
    if (plf_thread == NULL) return NULL;
  
    return plf_thread;
  }
  
  //
  // This function is used to free a platform-dependent thread handle. The thread/task should
  // have been gracefully ended/exited before this call.
  //
  // The parameter must be of type HANDLE. Passing NULL is not allowed and will result in 
  // returning false. If true is returned, the thread was deleted successfully.
  //
  // This function is part of the platform-independence wrapping and will be accessed by 
  // platform-independent parts of the Network Queue.
  //
  bool      platformDeleteThread( HANDLE threadhandle )
  {
    if (threadhandle == NULL) return false;
  
    if (CloseHandle( threadhandle ) == TRUE) return true;
  
    return false;
  }
  
  
  //
  //
  // Semaphore stuff
  //
  //
  
  //
  // This function is used to create a platform-independent semaphore with the upper bound of
  // 'maximum_count'. 
  //
  // The return value must be of type HANDLE and is either NULL in case of error or a HANDLE
  // referenced semaphore with an initial count of 0 and a maximum count of 'maximum_count'.
  //
  //
  // This function is part of the platform-independence wrapping and will be accessed by 
  // platform-independent parts of the Network Queue.
  //
  HANDLE platformCreateSemaphore( UINT16 maximum_count )
  {
    HANDLE sem;
  
    sem = CreateSemaphore(NULL, 0, maximum_count, NULL);
    if (sem == NULL) return( NULL );
  
    return sem;
  }
  
  //
  // This function is used to delete (free)  a platform-independent semaphore.
  //
  // The parameter must be of type HANDLE. Passing NULL is not allowed and will result in 
  // returning false. If true is returned, the semaphore was deleted successfully
  //
  // This function is part of the platform-independence wrapping and will be accessed by 
  // platform-independent parts of the Network Queue.
  //
  bool platformDeleteSemaphore( HANDLE semaph )
  {
    if (semaph == NULL) return false;
  
    if (CloseHandle( semaph ) == TRUE) return true;
  
    return false;
  }
  
  //
  // This function is used to wait for a state change on a platform-independent semaphore.
  //
  //  Parameters:
  //        semaph          handle to a previously created semaphore
  //        timeout_msec    wait timeout in milliseconds (passing 0 means infinite timeout)
  //
  //    Return-value:
  //        true            event happened within timeout-period
  //        false           something happened (either timeout (most probably) or another error)
  //
  //
  // This function is part of the platform-independence wrapping and will be accessed by 
  // platform-independent parts of the Network Queue.
  //
  bool platformWaitForSemaphore( HANDLE semaph, UINT32 timeout_msec )
  {
    assert( semaph != NULL);
  
    if (timeout_msec == 0) timeout_msec = INFINITE;
  
    DWORD ret = WaitForSingleObject(semaph, timeout_msec); 
    if (ret == WAIT_OBJECT_0) return true;
  
    return false;
  }
  
  
  //
  // This function is used to detect whether the semaphore is signalled (!=0) without waiting.
  // The function directly returns.
  //
  //  Parameters:
  //        semaph          handle to a previously created semaphore
  //        timeout_msec    wait timeout in milliseconds (passing 0 means infinite timeout)
  //
  //    Return-value:
  //        true            semaphore is signalled
  //        false           semaphore is not signalled (or an error happened)
  //
  //
  // This function is part of the platform-independence wrapping and will be accessed by 
  // platform-independent parts of the Network Queue.
  //
  bool platformIsSemaphoreSignalled( HANDLE semaph )
  {
    assert( semaph != NULL);
  
    DWORD ret = WaitForSingleObject(semaph, 0); // 0 == immediate return
    if (ret == WAIT_OBJECT_0) return true;
  
    return false;
  }
  
  
  //
  // This function is used to signal (increment by 1) semaphore count.
  //
  //  Parameters:
  //        semaphore       handle to a previously created semaphore
  //
  //    Return-value:
  //        true            semaphore signalled
  //        false           something happened (error on signalling)
  //
  //
  // This function is part of the platform-independence wrapping and will be accessed by 
  // platform-independent parts of the Network Queue.
  //
  bool platformSignalSemaphore( HANDLE semaphore )
  {
    assert( semaphore != NULL );
  
    BOOL ret = ReleaseSemaphore( semaphore, 1, NULL); 
  
    if (ret == TRUE) return true;
  
    return false;
  }
  
  //
  //
  // Mutex stuff
  //
  //
  
  //
  // This function is used to create a platform-independent mutual exclusion binary semaphore 
  // with the initial count of 1 (not locked).
  //
  // The return value must be of type HANDLE and is either NULL in case of error or a HANDLE
  // referenced mutex object with an initial count of 1 which means that the mutex is not taken.
  //
  //
  // This function is part of the platform-independence wrapping and will be accessed by 
  // platform-independent parts of the Network Queue.
  //
  HANDLE        platformCreateMutex()
  {
    HANDLE sem;
  
    sem = CreateSemaphore(NULL, 1, 1, NULL);
    if (sem == NULL) return( NULL );
  
    return sem;
  }
  
  //
  // This function is used to delete (free) a platform-independent mutex.
  //
  // The parameter must be of type HANDLE. Passing NULL is not allowed and will result in 
  // returning false. If true is returned, the mutex was deleted successfully
  //
  // This function is part of the platform-independence wrapping and will be accessed by 
  // platform-independent parts of the Network Queue.
  //
  bool      platformDeleteMutex( HANDLE binsem )
  {
    if (binsem == NULL) return false;
  
    if (CloseHandle( binsem ) == TRUE) return true;
  
    return false;
  }
  
  //
  // This function is used to wait for a state change on a platform-independent mutex with the 
  // atomic aim to take it (lock it).
  //
  //  Parameters:
  //        mutex           handle to a previously created mutex
  //        timeout_msec    wait timeout in milliseconds (passing 0 means infinite timeout)
  //
  //    Return-value:
  //        true            I have got the mutex, it was locked successfully.
  //        false           something happened (either timeout (most probably) or another error)
  //
  //
  // This function is part of the platform-independence wrapping and will be accessed by 
  // platform-independent parts of the Network Queue.
  //
  bool      platformWaitForMutex( HANDLE binsem, UINT32 timeout_msec )
  {
    UINT32 iter=0;
    bool retval = false;

    assert( binsem != NULL );
  
    if (timeout_msec == 0) timeout_msec = INFINITE; 
    //timeout_msec = INFINITE; SW! Oct 11, 2007 debug
    
    while( 1==1 )
    {
        iter++;
        DWORD ret = WaitForSingleObject(binsem, timeout_msec);
        if (ret == WAIT_OBJECT_0) 
        {
            retval = true;
            break;
        }
        
        NQ_DEBUGMODE_ONLY(if (ret == WAIT_FAILED) NQ_DBG(("plfWaitForMutex(win): WAIT_FAILED glerror=%d\n", GetLastError())));
        NQ_DEBUGMODE_ONLY(if (ret == WAIT_ABANDONED) NQ_DBG(("plfWaitForMutex(win): WAIT_ABANDONED glerror=%d\n", GetLastError() )));
        
        if ((ret == WAIT_FAILED) || (ret == WAIT_ABANDONED)) break;
    }

    NQ_DEBUGMODE_ONLY(if (iter > 1) NQ_DBG(("plfWaitForMutex(win): required %u iterations of %u msec before mutex was signalled.\n", iter, timeout_msec)));

    return retval;
  }
  
  
  //
  // This function is used to release (unlock, increment by 1) a 
  // previously created and locked platform-independent mutex.
  //
  //  Parameters:
  //        mutex           handle to a previously created and locked mutex
  //
  //    Return-value:
  //        true            mutex was unlocked
  //        false           something happened (error on unlocking)
  //
  //
  // This function is part of the platform-independence wrapping and will be accessed by 
  // platform-independent parts of the Network Queue.
  //
  bool      platformSignalMutex( HANDLE binsem )
  {
    assert( binsem != NULL );
    
    if (ReleaseSemaphore(binsem,1, NULL) == TRUE) return true;
  
    return false;
  }
  
#endif // PLF_SYSTEM_WINNT

#ifdef SYSTEM_NIOS2_NICHE
  // SYSTEM_NIOS2_NICHE only
  void internalThreadProcSendStatic(  LPVOID p )
  {
    CNetworkQueue *q;

    q = (CNetworkQueue *) p;
    q->SendProcessTask();
    OSTaskDel(OS_PRIO_SELF);
  }

  // SYSTEM_NIOS2_NICHE only
  void internalThreadProcReceiveStatic(  LPVOID p )
  {
    CNetworkQueue *q;

    q = (CNetworkQueue *) p;
    q->ReceiveProcessTask();
    OSTaskDel(OS_PRIO_SELF);
  }

  //
  //
  // NIOS2 UCOS-ii Thread, Task and Task Stacks stuff
  //
  //

    TK_OBJECT(to_internalThreadProcReceiveStatic);
    TK_ENTRY(internalThreadProcReceiveStatic);

    TK_OBJECT(to_internalThreadProcSendStatic);
    TK_ENTRY(internalThreadProcSendStatic);

    // stack size must be passed in bytes inside these structs! SW! May 11, 2007

    struct inet_taskinfo SendStatic = {
      &to_internalThreadProcSendStatic,
      "send task (network queue)",
      internalThreadProcSendStatic,
      SENDTASK_PRIO_SW,
      TASK_STACK_SIZE_SW,
    };



    struct inet_taskinfo ReceiveStatic = {
      &to_internalThreadProcReceiveStatic,
      "recv task (network queue)",
      internalThreadProcReceiveStatic,
      RECVTASK_PRIO_SW,
      TASK_STACK_SIZE_SW,
      
    };

    HANDLE  platformCreateThread( bool sendthread, VOIDP parameter, UINT32 prio_not_used)
    {
        int err;
        INT32U prio;
  
        if (sendthread == true)
        { 
            SendStatic.task_parameter = parameter;
            err = TK_NEWTASK(&SendStatic);
            prio =  SendStatic.priority;
        }
        else
        {
            ReceiveStatic.task_parameter = parameter;
            err = TK_NEWTASK(&ReceiveStatic);
            prio =  ReceiveStatic.priority;
        }

        if (err == 0) 
        {
            return (OS_EVENT *) prio;
        }
    
        return NULL;
    }

    bool    platformDeleteThread( HANDLE threadhandle )
    {
        INT32U tmp = (INT32U) threadhandle;
        INT8U prio = (INT8U) tmp;
  
        if (threadhandle == NULL) return false;
        INT8U err = OSTaskDel(prio);
        if (err == OS_NO_ERR) return true;

        return false;
    }
#endif

#ifdef SYSTEM_NIOS2_LWIP
  //
  //
  // NIOS2 UCOS-ii Thread, Task and Task Stacks stuff
  //
  //

  // SYSTEM_NIOS2_LWIP only
  UINT32 internalThreadProcSendStatic(  LPVOID p )
  {
    CNetworkQueue *q;

    q = (CNetworkQueue *) p;
    q->SendProcessTask();
    OSTaskDel(OS_PRIO_SELF);
  
    return 0;
  }

  // SYSTEM_NIOS2_LWIP only
  UINT32 internalThreadProcReceiveStatic(  LPVOID p )
  {
    CNetworkQueue *q;

    q = (CNetworkQueue *) p;
    q->ReceiveProcessTask();
    OSTaskDel(OS_PRIO_SELF);

    return 0;
  }

  // in bytes
  // SYSTEM_NIOS2_LWIP only
  static OS_STK SendTaskStack[TASK_STACK_SIZE_SW/sizeof(OS_STK)];

  // SYSTEM_NIOS2_LWIP only
  static OS_STK ReceiveTaskStack[TASK_STACK_SIZE_SW/sizeof(OS_STK)];

  // SYSTEM_NIOS2_LWIP only
  // SW! stacksize is not used on NIOS2
  HANDLE  platformCreateThread( bool sendthread, VOIDP parameter, UINT32 prio_not_used)
  {
    INT8U err;
    INT32U prio;
  
    if (sendthread == true)
    { 

      #if OS_STK_GROWTH == 0
        err = OSTaskCreateExt((void(*)(void*))internalThreadProcSendStatic, parameter, 
                              &SendTaskStack[0], SENDTASK_PRIO_SW, SENDTASK_PRIO_SW, 
                              &SendTaskStack[(TASK_STACK_SIZE_SW/sizeof(OS_STK))-1], (TASK_STACK_SIZE_SW/sizeof(OS_STK)), 
                              NULL, TASK_STACK_CHECKING_SW);
      #else
        err = OSTaskCreateExt((void(*)(void*))internalThreadProcSendStatic, parameter, 
                              &SendTaskStack[(TASK_STACK_SIZE_SW/sizeof(OS_STK))-1], SENDTASK_PRIO_SW,
                              SENDTASK_PRIO_SW, &SendTaskStack[0], (TASK_STACK_SIZE_SW/sizeof(OS_STK)),
                              NULL, TASK_STACK_CHECKING_SW);
      #endif     
      prio =  SENDTASK_PRIO_SW;
    }
    else
    {
      #if OS_STK_GROWTH == 0
        err = OSTaskCreateExt((void(*)(void*))internalThreadProcReceiveStatic, parameter,
                              &ReceiveTaskStack[0], RECVTASK_PRIO_SW, RECVTASK_PRIO_SW,
                              &ReceiveTaskStack[(TASK_STACK_SIZE_SW/sizeof(OS_STK))-1], (TASK_STACK_SIZE_SW/sizeof(OS_STK)),
                              NULL, TASK_STACK_CHECKING_SW);
      #else
        err = OSTaskCreateExt((void(*)(void*))internalThreadProcReceiveStatic, parameter,
                              &ReceiveTaskStack[(TASK_STACK_SIZE_SW/sizeof(OS_STK))-1], RECVTASK_PRIO_SW, 
                              RECVTASK_PRIO_SW, &ReceiveTaskStack[0], (TASK_STACK_SIZE_SW/sizeof(OS_STK)), 
                              NULL, TASK_STACK_CHECKING_SW);
      #endif      
        prio =  RECVTASK_PRIO_SW;
    }

    if (err == OS_NO_ERR) 
    {
      return (OS_EVENT *) prio;
    }
    
    return NULL;
  }

  // SYSTEM_NIOS2_LWIP only
  bool    platformDeleteThread( HANDLE threadhandle )
  {
    INT32U tmp = (INT32U) threadhandle;
    INT8U prio = (INT8U) tmp;
  
    if (threadhandle == NULL) return false;
    INT8U err = OSTaskDel(prio);
    if (err == OS_NO_ERR) return true;

    return false;
  }
#endif  

#ifdef PLF_SYSTEM_NIOS2
  //
  //
  // Semaphore stuff
  //
  //
  // counting semaphore (up to max) was selfimplemented because not directly supported 
  // by ucos-II


  // semaphore requires malloc stuff
  // PLF_SYSTEM_NIOS2 only
  typedef struct 
  {
    OS_EVENT  *binlock;
    OS_EVENT  *ucosSemaphore;
    UINT16  semMaxCount;
  }sem_private_struct, *sem_private;

  // PLF_SYSTEM_NIOS2 only
  HANDLE platformCreateSemaphore( UINT16 maximum_count )
  {
    sem_private token;
    INT8U err;

    if (maximum_count < 1) return NULL;

    token = (sem_private) malloc(sizeof(sem_private_struct));
    if (token == NULL) return NULL;
  
    token->semMaxCount = maximum_count;
    token->ucosSemaphore = OSSemCreate(0);
    if (token->ucosSemaphore == NULL )
    {
      free( token );
      return NULL;
    }

    token->binlock = OSSemCreate(1);
    if (token->binlock == NULL )
    {
      OSSemDel( token->ucosSemaphore, OS_DEL_ALWAYS, &err);
      free( token );
      return NULL;
    }

    return (HANDLE) token;
  }

  // PLF_SYSTEM_NIOS2 only
  // false: no memory freed!, contents might be exhausted!
  bool platformDeleteSemaphore( HANDLE semaph )
  {
    INT8U err;
 
    sem_private token = (sem_private) semaph;
    if (token == NULL) return false;  

    double bintimeouttmp = (BINLOCK_SEM_TIMEOUT / 1000.0)*(OS_TICKS_PER_SEC*1.0);
    INT16U bintimeout_ticks = (INT16U) bintimeouttmp;

    OSSemPend(token->binlock, bintimeout_ticks, &err);
    if (err != OS_NO_ERR) return false;  //timeout binary lock

    OSSemDel( token->ucosSemaphore, OS_DEL_NO_PEND, &err);
    if (err != OS_NO_ERR) 
    {
      OSSemPost(token->binlock);
      return false;
    }
  
    OSSemDel( token->binlock, OS_DEL_ALWAYS, &err);
    if (err != OS_NO_ERR) return false;
  
    free( token );
    
    return true;
  }

  // PLF_SYSTEM_NIOS2 only
  bool platformWaitForSemaphore( HANDLE semaph, UINT32 timeout_msec )
  {
    INT8U err;
    bool retval=true;

    sem_private token = (sem_private) semaph;
    if (token == NULL) return false;  

    INT16U timeout_ticks = (INT16U) ((timeout_msec*OS_TICKS_PER_SEC)/1000);
  
    OSSemPend(token->ucosSemaphore, timeout_ticks, &err);
    if (err != OS_NO_ERR) retval = false;
    //NQ_DBG(("platformWaitSema UCOSII err=%d\n",err));
   
    return retval;
  }

  // PLF_SYSTEM_NIOS2 only
  bool platformSignalSemaphore( HANDLE semaphore )
  {
    static INT16U bintimeout_ticks=0;
    OS_SEM_DATA sembuf;
    INT8U err;
    bool retval = true;

    sem_private token = (sem_private) semaphore;
    if (token == NULL) return false;  

    if (bintimeout_ticks == 0)
    {
      double bintimeouttmp = (BINLOCK_SEM_TIMEOUT / 1000.0)*(OS_TICKS_PER_SEC*1.0);
      bintimeout_ticks = (INT16U) bintimeouttmp;
    }

    OSSemPend(token->binlock, bintimeout_ticks, &err);
    if (err != OS_NO_ERR) return false;  //timeout binary lock

    OSSemQuery(token->ucosSemaphore, &sembuf);
  
    if (sembuf.OSCnt < token->semMaxCount) // count exceeded ?
    {
      err = OSSemPost(token->ucosSemaphore);
      if (err != OS_NO_ERR) retval = false;
    }

    err = OSSemPost(token->binlock);
    if (err != OS_NO_ERR) retval = false;
  
    return retval;
  }

  // PLF_SYSTEM_NIOS2 only
  bool platformIsSemaphoreSignalled( HANDLE semaph )
  {
    INT16U retval;

    assert( semaph != NULL);

    sem_private token = (sem_private) semaph;

    retval = OSSemAccept(token->ucosSemaphore);
    if (retval == 0) return( false );
   
    return true;
  }

  //
  //
  // Mutex stuff
  //
  //
  // SW! Mutex is implemented as a binary semaphore

  // PLF_SYSTEM_NIOS2 only
  HANDLE    platformCreateMutex()
  {
    return OSSemCreate(1);
  }

  // PLF_SYSTEM_NIOS2 only
  bool    platformDeleteMutex( HANDLE mutex )
  {
    INT8U err;

    if (mutex == NULL) return false;  
    OSSemDel( mutex, OS_DEL_NO_PEND, &err);
    if (err == OS_NO_ERR) return true;
  
    return false;
  }

  // PLF_SYSTEM_NIOS2 only
  bool    platformWaitForMutex( HANDLE mutex, UINT32 timeout_msec )
  {
    INT8U err;
  
    if (mutex == NULL) return false;  

    double timeouttmp = (timeout_msec / 1000)*(OS_TICKS_PER_SEC*1.0);
    INT16U timeout_ticks = (INT16U) timeouttmp;
  
    OSSemPend(mutex, timeout_ticks, &err);
    if (err == OS_NO_ERR) return true;
  
    return false;
  }

  // PLF_SYSTEM_NIOS2 only
  bool    platformSignalMutex( HANDLE mutex )
  {
    if (mutex == NULL) return false;  
  
    INT8U err = OSSemPost(mutex);
  
    if (err == OS_NO_ERR) return true;
  
    return false;
  }
  
#endif // PLF_SYSTEM_NIOS2
 


#ifndef PLF_SYSTEM_WINNT
    
  #define MAXLEN 1024
  
  //    convert a given string (*s, array of chars, \0) to upper case 
  
  void stoupper(char *s)
  {
      char *p = (char *) s;
      
      if (p == NULL) return;
      
      while (*p != 0)
      {
        if( islower(*p) ) *p = _toupper(*p);
            ++p;
      }
  }
  
  static char strtmp1[MAXLEN];
  static char strtmp2[MAXLEN];
  
  //    implementation of _strnicmp using stoupper
  int _strnicmp( const char *string1, const char *string2, size_t count)
  {
   if (count > (MAXLEN-1)) return -1;
   
   strncpy(strtmp1, string1, count);
   strtmp1[count] = 0;
   
   strncpy(strtmp2, string2, count);
   strtmp2[count] = 0;
   
   stoupper(strtmp1); 
   stoupper(strtmp2);
   
   return strncmp( strtmp1, strtmp2, count );
  } 

#endif // NO PLF_SYSTEM_WINNT

//
// This function is used as a wrappe for sleep() function(s).
// It pauses the current thread/task execution by 'msec' milliseconds.
//
// This function is part of the platform-independence wrapping and will be accessed by 
// platform-independent parts of the Network Queue.
//

VOID platformSleepMilliseconds( UINT32 msec )
{
    #if defined(PLF_SYSTEM_SOLARIS) || defined(PLF_SYSTEM_LINUX)
        
        struct timespec req={0};
        
        req.tv_sec=(int)(msec/1000);
        req.tv_nsec=(msec%1000)*1000000L;
        
        while(nanosleep(&req,&req)==-1)
        {
        }

    #endif
    
    #ifdef PLF_SYSTEM_WINNT
        Sleep( msec );
    #endif
  
    #ifdef PLF_SYSTEM_NIOS2
        INT8U  lsec =  (INT8U)  (msec / 1000) % 60;
        INT16U lmsec = (INT16U) (msec % 1000);
        INT8U  lmin =  (INT8U)  (((msec / 1000) / 60) % 60);
        INT8U  lhour = (INT8U)  (((msec / 1000) / 60) / 60);

        OSTimeDlyHMSM(lhour,lmin,lsec,lmsec);
    #endif
}

//
// This function returns the number of milliseconds since system start.
// It is used in main program only, based on data type it will wrap around quite often!
// IMPORTANT: It is used (and should be used) only for relative 'time elapsed in between' 
// measurements. In fact, implementations for other platforms beside WINNT is based on time
// difference since first call to function, so only relative time measurements must be done.
//
// This function is part of the platform-independence wrapping.
//
UINT32 platformGetTickCount()
{
    #ifdef PLF_SYSTEM_SOLARIS
        struct timeb current_timeval;

        static bool first_time_set=false;
        static timeb first_timeval;
        
        int ret = ftime(&current_timeval);
        assert(ret == 0);
        ret=ret;// make compiler happy
        
        if (first_time_set == false)
        {
            first_timeval = current_timeval;
            first_time_set = true;
            return 0;
        }
        else
        {
            double passedmilliseconds = difftime(current_timeval.time, first_timeval.time) * 1000.0;

            passedmilliseconds -= ((double)first_timeval.millitm);
            passedmilliseconds += ((double)current_timeval.millitm);            
            
            return( (UINT32) passedmilliseconds );
        }
        
    #endif
    
    #ifdef PLF_SYSTEM_LINUX
        static long tickssincestart = -1;
    
    if (tickssincestart == -1) tickssincestart = sysconf(_SC_CLK_TCK);
    
    struct tms tm;
    return (UINT32)((times(&tm)*1000.0)/tickssincestart); 
    #endif
    
    #ifdef PLF_SYSTEM_WINNT
        return (UINT32) ::GetTickCount();
    #endif
  
  #ifdef PLF_SYSTEM_NIOS2
    INT32U tickssincestart;
    UINT32 msecsincestart;

    tickssincestart = OSTimeGet();

    msecsincestart = (UINT32) ((tickssincestart*1.0) / (1000.0/(OS_TICKS_PER_SEC*1.0)));
    
    return msecsincestart;
  #endif
  
}

#if defined(PLF_SYSTEM_SOLARIS) || defined(PLF_SYSTEM_LINUX)
    static struct termios initial_settings, new_settings;
    static int peek_character = -1;
    static bool runinitonetime = false;
#endif  

#ifdef PLF_SYSTEM_NIOS2
    static int peek_character = -1;
    static int fd_initialized = 0;
    static int unix_fd=0;
    static FILE* stream_fd;
#endif


// on some platforms, console input must be initialized. in addition, kbhit() and getch() are not available
// everywhere, so this functions are wrapped and implemented here. These functions were required for the
// GeneralMain console example but might be interesting anyhow.
//
void   platformInitializeConsoleInput()
{
  #if defined(PLF_SYSTEM_SOLARIS) || defined(PLF_SYSTEM_LINUX)
    fflush(stdout);
    
    if (runinitonetime == false)
    {
        tcgetattr(0,&initial_settings);
        runinitonetime = true;
    }

    tcgetattr(0, &new_settings);
    new_settings.c_lflag &= ~ICANON;
    new_settings.c_lflag &= ~ECHO;
    new_settings.c_lflag &= ~ISIG;
    new_settings.c_cc[VMIN] = 1;
    new_settings.c_cc[VTIME] = 0;
    tcsetattr(0, TCSANOW, &new_settings);
    #endif

  #ifdef PLF_SYSTEM_NIOS2
    if (fd_initialized == 0)
    {
      fd_initialized = 1;

      unix_fd = open("/dev/uart1", O_NONBLOCK | O_RDWR);
      stream_fd = fdopen(unix_fd, "rw");
    }
  #endif
}

void   platformDeinitializeConsoleInput()
{
    #if defined(PLF_SYSTEM_SOLARIS) || defined(PLF_SYSTEM_LINUX)
        if (runinitonetime == true) tcsetattr(0, TCSANOW, &initial_settings);   
    #endif
  
    #ifdef PLF_SYSTEM_NIOS2
        if (fd_initialized == 1)
        {
            fclose(stream_fd);
            //close(unix_fd); MUST not be done, because will be done by fclose automatically

            fd_initialized = 0;
        }
    #endif    
}

// >= 0 == keycode or extended keycode (if extended then read again)
// < 0 error code (not available on some platforms)
INT32  platformgetch()
{
    #if defined(PLF_SYSTEM_SOLARIS) || defined(PLF_SYSTEM_LINUX)
        char ch;

        if(peek_character != -1)
        {
            ch = peek_character;
            peek_character = -1;
            return ch;
        }
        read(0,&ch,1);
        return ch;
    #endif
    
    #ifdef PLF_SYSTEM_WINNT
    
        return( getch() );
    
    #endif

  #ifdef PLF_SYSTEM_NIOS2
        int my_char;

        if(peek_character != -1)
        {
            my_char = peek_character;
            peek_character = -1;
            return my_char;
        }

        my_char = getc(stream_fd);
        clearerr(stream_fd);

        if (my_char == EOF) return -1; else return my_char;
  #endif
}

// 1 == there is a new key input waiting  
// 0 == there is no new key input waiting
INT32  platformkbhit()
{
    #if defined(PLF_SYSTEM_SOLARIS) || defined(PLF_SYSTEM_LINUX)
        unsigned char ch;
        int nread;

        if (peek_character != -1) return 1;
        new_settings.c_cc[VMIN]=0;
        tcsetattr(0, TCSANOW, &new_settings);
        nread = read(0,&ch,1);
        new_settings.c_cc[VMIN]=1;
        tcsetattr(0, TCSANOW, &new_settings);
    
        if(nread == 1)
        {
            peek_character = ch;
            return 1;
        }
        return 0;
    #endif

    #ifdef PLF_SYSTEM_WINNT
        return( kbhit() );
    #endif

    #ifdef PLF_SYSTEM_NIOS2 
        int my_char;
    
        if(peek_character != -1) return 1;

        my_char = getc(stream_fd);
        clearerr(stream_fd);

        peek_character = -1;

        if (my_char != EOF) 
        {
            peek_character = my_char;
            return 1;
        }
    
        return 0;
    #endif
}


#ifdef PLF_ENDIANCHANGE

  // easy, quick, dirty, simple, little<->big endian wrappers

  // SYSTEM_SUN only
  void  platform_put_double_at( UINT8 *p_bufpos, DOUBLE data )
  {
    UINT8 *datap = (UINT8 *) &data;
    UINT8 *bufpos = (UINT8 *) p_bufpos;

    bufpos[0] = datap[7];
    bufpos[1] = datap[6];
    bufpos[2] = datap[5];
    bufpos[3] = datap[4];
    bufpos[4] = datap[3];
    bufpos[5] = datap[2];
    bufpos[6] = datap[1];
    bufpos[7] = datap[0];
  }

  // SYSTEM_SUN only
  DOUBLE    platform_get_double_at( UINT8 *p_bufpos )
  {
    DOUBLE dataloc;
    UINT8 *locp = (UINT8 *) &dataloc;
    UINT8 *bufpos = (UINT8 *) p_bufpos;
    
    locp[7] = bufpos[0];
    locp[6] = bufpos[1];
    locp[5] = bufpos[2];
    locp[4] = bufpos[3];
    locp[3] = bufpos[4];
    locp[2] = bufpos[5];
    locp[1] = bufpos[6];
    locp[0] = bufpos[7];
    
    return dataloc;
  }

  // SYSTEM_SUN only
  void  platform_put_float_at( UINT8 *p_bufpos, FLOAT data )
  {
    UINT8 *datap = (UINT8 *) &data;
    UINT8 *bufpos = (UINT8 *) p_bufpos;

    bufpos[0] = datap[3];
    bufpos[1] = datap[2];
    bufpos[2] = datap[1];
    bufpos[3] = datap[0];
  }

  // SYSTEM_SUN only
  FLOAT platform_get_float_at( UINT8 *p_bufpos )
  {
    FLOAT dataloc;
    UINT8 *locp = (UINT8 *) &dataloc;
    UINT8 *bufpos = (UINT8 *) p_bufpos;

    locp[3] = bufpos[0];
    locp[2] = bufpos[1];
    locp[1] = bufpos[2];
    locp[0] = bufpos[3];

    return dataloc;
  }

  // SYSTEM_SUN only
  void  platform_put_uint16_at( UINT8 *p_bufpos, UINT16 data )
  {
    UINT8 *datap = (UINT8 *) &data;
    UINT8 *bufpos = (UINT8 *) p_bufpos;

    bufpos[0] = datap[1];
    bufpos[1] = datap[0];
  }

  // SYSTEM_SUN only
  UINT16    platform_get_uint16_at( UINT8 *p_bufpos )
  {
    UINT16 dataloc;
    UINT8 *locp = (UINT8 *) &dataloc;
    UINT8 *bufpos = (UINT8 *) p_bufpos;
    
    locp[1] = bufpos[0];
    locp[0] = bufpos[1];

    return dataloc;
  }

  // SYSTEM_SUN only
  void  platform_put_uint32_at( UINT8 *p_bufpos, UINT32 data )
  {
    UINT8 *datap = (UINT8 *) &data;
    UINT8 *bufpos = (UINT8 *) p_bufpos;

    bufpos[0] = datap[3];
    bufpos[1] = datap[2];
    bufpos[2] = datap[1];
    bufpos[3] = datap[0];
  } 

  // SYSTEM_SUN only
  UINT32    platform_get_uint32_at( UINT8 *p_bufpos )
  {
    UINT32 dataloc;
    UINT8 *locp = (UINT8 *) &dataloc;
    UINT8 *bufpos = (UINT8 *) p_bufpos;

    locp[3] = bufpos[0];
    locp[2] = bufpos[1];
    locp[1] = bufpos[2];
    locp[0] = bufpos[3];
    
    return dataloc;
  }

  // SYSTEM_SUN only
  void  platform_put_uint8_at( UINT8 *p_bufpos, UINT8 data )
  {
    *((UINT8 *) p_bufpos) = data;
  }

  // SYSTEM_SUN only
  UINT8 platform_get_uint8_at( UINT8 *p_bufpos )
  {
    return *((UINT8 *) p_bufpos);
  }

  // SYSTEM_SUN only
  void  platform_put_int16_at( UINT8 *p_bufpos, INT16 data )
  {
    UINT8 *datap = (UINT8 *) &data;
    UINT8 *bufpos = (UINT8 *) p_bufpos; 
    
    bufpos[0] = datap[1];
    bufpos[1] = datap[0];
  }

  // SYSTEM_SUN only
  INT16 platform_get_int16_at( UINT8 *p_bufpos )
  {
    INT16 dataloc;
    UINT8 *locp = (UINT8 *) &dataloc;
    UINT8 *bufpos = (UINT8 *) p_bufpos;

    locp[1] = bufpos[0];
    locp[0] = bufpos[1];

    return dataloc;
  }

  // SYSTEM_SUN only
  void  platform_put_int32_at( UINT8 *p_bufpos, INT32 data )
  {
    UINT8 *datap = (UINT8 *) &data;
    UINT8 *bufpos = (UINT8 *) p_bufpos;

    bufpos[0] = datap[3];
    bufpos[1] = datap[2];
    bufpos[2] = datap[1];
    bufpos[3] = datap[0];
  }

  // SYSTEM_SUN only
  INT32 platform_get_int32_at( UINT8 *p_bufpos )
  {
    INT32 dataloc;
    UINT8 *locp = (UINT8 *) &dataloc;
    UINT8 *bufpos = (UINT8 *) p_bufpos;
    
    locp[3] = bufpos[0];
    locp[2] = bufpos[1];
    locp[1] = bufpos[2];
    locp[0] = bufpos[3];
    
    return dataloc;
  }

  // SYSTEM_SUN only
  void  platform_put_int8_at( UINT8 *bufpos, INT8 data )
  {
    *((INT8 *) bufpos) = data;
  }

  // SYSTEM_SUN only
  INT8  platform_get_int8_at( UINT8 *bufpos )
  {
    return *((INT8 *) bufpos);
  }

#endif // PLF_ENDIANCHANGE

---