// Sun, 18 Jun 2000
// Y.Takagi

#include <sys/socket.h>
#include <netdb.h>

#include <errno.h>
#include <string.h>

#include <iomanip>
#include <algorithm>
#include "LpsClient.h"
#include "Socket.h"


using namespace std;


#define LPS_SERVER_PORT         515
#define LPS_CLIENT_PORT_S       721
#define LPS_CLIENT_PORT_E       731

#define LPS_CHECK_QUEUE                         '\001'
#define LPS_PRINT_JOB                           '\002'
#define LPS_DISPLAY_SHORT_QUEUE         '\003'
#define LPS_DISPLAY_LONG_QUEUE          '\004'
#define LPS_REMOVE_JOB                          '\005'
#define LPS_END_TRANSFER                        '\000'
#define LPS_ABORT                                       '\001'
#define LPS_RECEIVE_CONTROL_FILE        '\002'
#define LPS_RECEIVE_DATA_FILE           '\003'

#define LPS_OK                                          '\0'
#define LPS_ERROR                                       '\1'
#define LPS_NO_SPOOL_SPACE                      '\2'

#ifndef INADDR_NONE
#define INADDR_NONE             0xffffffff
#endif

#define ERRNO   errno


LpsClient::LpsClient(const char *host)
        :
        fConnected(false),
        fHost(host),
        fSock(NULL)
{
}


LpsClient::~LpsClient()
{
        close();
}


void
LpsClient::connect()
{
        for (int localPort = LPS_CLIENT_PORT_S; localPort <=  LPS_CLIENT_PORT_E;
                localPort++) {

                if (fSock) {
                        delete fSock;
                }
                fSock = new Socket(fHost.c_str(), LPS_SERVER_PORT, localPort);
                if (fSock->good()) {
                        fInput = &fSock->getInputStream();
                        fOutput = &fSock->getOutputStream();
                        fConnected = true;
                        return;
                }
        }

        throw(LPSException(fSock->getLastError()));
}


void
LpsClient::close()
{
        fConnected = false;
        if (fSock) {
                delete fSock;
                fSock = NULL;
        }
}


void
LpsClient::receiveJob(const char *printer)
{
        if (fConnected) {
                *fOutput << LPS_PRINT_JOB << printer << '\n' << flush;
                checkAck();
        }
}


void
LpsClient::receiveControlFile(int size, const char *name)
{
        if (fConnected) {

                char cfname[32];
                strncpy(cfname, name, sizeof(cfname));
                cfname[sizeof(cfname) - 1] = '\0';

                *fOutput << LPS_RECEIVE_CONTROL_FILE << size << ' ' << cfname << '\n' << flush;

                checkAck();
        }
}

void
LpsClient::receiveDataFile(int size, const char *name)
{
        if (fConnected) {

                char dfname[32];
                strncpy(dfname, name, sizeof(dfname));
                dfname[sizeof(dfname) - 1] = '\0';

                *fOutput << LPS_RECEIVE_DATA_FILE << size << ' ' << dfname << '\n' << flush;

                checkAck();
        }
}


void
LpsClient::transferData(const char *buffer, int size)
{
        if (fConnected) {

                if (size < 0) {
                        size = strlen(buffer);
                }

                if (!fOutput->write(buffer, size)) {
                        close();
                        throw(LPSException("error talking to lpd server"));
                }
        }
}


void
LpsClient::transferData(istream &is, int size)
{
        if (fConnected) {

                if (size < 0) {
                        is.seekg(0, ios::end);
                        size = is.tellg();
                        is.seekg(0, ios::beg);
                }

                char c;
                while (is.get(c)) {
                        if (!fOutput->put(c)) {
                                close();
                                throw(LPSException("error reading file."));
                                return;
                        }
                }
        }
}


void
LpsClient::endTransfer()
{
        if (fConnected) {
                *fOutput << LPS_END_TRANSFER << flush;
                checkAck();
        }
}


void
LpsClient::checkAck()
{
        if (fConnected) {

                char c;

                if (!fInput->get(c)) {
                        close();
                        throw(LPSException("server not responding."));
                        return;
                }

                switch (c) {
                        case LPS_OK:
                                break;
                        case LPS_ERROR:
                                close();
                                throw(LPSException("server error."));
                                break;
                        case LPS_NO_SPOOL_SPACE:
                                close();
                                throw(LPSException("not enough spool space on server."));
                                break;
                }
        }
}