Retro68/LaunchAPPL/Server/OpenTptStream.cc

/*
    Copyright 2019 Wolfgang Thaller.

    This file is part of Retro68.

    Retro68 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 3 of the License, or
    (at your option) any later version.

    Retro68 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 Retro68.  If not, see <http://www.gnu.org/licenses/>.
*/

#include <ConditionalMacros.h>
#if TARGET_API_MAC_CARBON
#define OTCARBONAPPLICATION 1
#endif

#include "OpenTptStream.h"

#include <Files.h> /* in UniversalHeaders 3.4.2 requires Files.h to be included before OpenTransportProviders.h */
#include <OpenTransport.h>
#include <OpenTransportProviders.h>

#include <string.h>
#include <TextUtils.h>

#ifdef DEBUG_CONSOLE
#include <stdio.h>
#endif

OpenTptStream::OpenTptStream()
{
    InitOpenTransport();
    OSStatus err;


    listenerEndpoint = OTOpenEndpoint(OTCreateConfiguration(kTCPName), 0, nullptr, &err);
    endpoint = nullptr;

    InetAddress addr, retAddr;
    OTInitInetAddress(&addr, 1984, 0);

    TBind req, ret;

    req.addr.len = sizeof(addr);
    req.addr.buf = (UInt8*) &addr;
    req.qlen = 1;
    ret.addr.maxlen = sizeof(retAddr);
    ret.addr.buf = (UInt8*) &retAddr;


    listenerEndpoint->Bind(&req, &ret);

    listenerEndpoint->SetSynchronous();
    
    tryListening();
}

void OpenTptStream::tryListening()
{
    if(connected)
        DebugStr("\pDouble connect");

    InetAddress clientAddr;
    memset(&call, 0, sizeof(call));
    call.addr.maxlen = sizeof(clientAddr);
    call.addr.len = sizeof(clientAddr);
    call.addr.buf = (UInt8*) &clientAddr;

    OSStatus err;
    
    listenerEndpoint->SetNonBlocking();
    err = listenerEndpoint->Listen(&call);
#ifdef DEBUG_CONSOLE
    printf("Listen: err = %d.\n", (int)err);
#endif

    if(err < 0)
        return; // hopefully, kOTNoData

    if(!endpoint)
    {
        endpoint = OTOpenEndpoint(OTCreateConfiguration(kTCPName), 0, nullptr, &err);
        endpoint->SetSynchronous();
    }

    listenerEndpoint->SetBlocking();
            
    err = listenerEndpoint->Accept(endpoint, &call);
#ifdef DEBUG_CONSOLE
    printf("Accept: err = %d.\n", (int)err);
#endif

    endpoint->SetNonBlocking();

    connected = true;
    tryReading();
}

OpenTptStream::~OpenTptStream()
{
    if(endpoint)
    {
        endpoint->SetNonBlocking();
        if(connected)
        	endpoint->SndDisconnect(&call);
        endpoint->Unbind();
        OTCloseProvider(endpoint);
    }
    listenerEndpoint->SetNonBlocking();
    listenerEndpoint->Unbind();
    OTCloseProvider(listenerEndpoint);
    CloseOpenTransport();
}

void OpenTptStream::write(const void* p, size_t n)
{
    endpoint->SetBlocking();
    endpoint->Snd((void*)p, n, 0);
    endpoint->SetNonBlocking();
}

void OpenTptStream::tryReading()
{
    OTResult result;
    OTFlags flags;
    do
    {
        result = endpoint->Rcv(readBuffer, kReadBufferSize, &flags);
        if(result > 0)
        {
            notifyReceive(readBuffer, result);
        }
    } while(result > 0);
}

void OpenTptStream::idle()
{
    OSStatus err;
    if(connected)
    {
        switch(endpoint->Look())
        {
            case T_DISCONNECT:
                endpoint->RcvDisconnect(nullptr);
                connected = false;
                tryListening();
                break;
            case T_ORDREL:
                err = endpoint->RcvOrderlyDisconnect();
                if(err == noErr)
                    endpoint->SndOrderlyDisconnect();
                connected = false;
                tryListening();
                break;
            case T_DATA:
                tryReading();
                break;
        }
    }
    else
    {
        switch(listenerEndpoint->Look())
        {
            case T_LISTEN:
                tryListening();
                break;
        }
    }
}