src/shell/LSCPClient.cpp

/*
 * LSCP Shell
 *
 * Copyright (c) 2014 Christian Schoenebeck
 *
 * This program is part of LinuxSampler and released under the same terms.
 */

#include "LSCPClient.h"

#include <strings.h>

LSCPClient::LSCPClient() :
    Thread(false, false, 1, -1),
    hSocket(-1), m_callback(NULL),
    m_multiLineExpected(false), m_multiLineComplete(false)
{
}

LSCPClient::~LSCPClient() {
    disconnect();
}

bool LSCPClient::connect(String host, int port) {
    m_lineBuffer.clear();
    m_lines.clear();
    // resolve given host name
    hostent* server = ::gethostbyname(host.c_str());
    if (!server) {
        std::cerr << "Error: Could not resolve host \"" << host << "\".\n";
        return false;
    }
    // create local TCP socket
    hSocket = ::socket(AF_INET, SOCK_STREAM, 0);
    if (hSocket < 0) {
        std::cerr << "Error: Could not create local socket.\n";
        return false;
    }
    // TCP connect to server
    sockaddr_in addr;
    bzero((char*)&addr, sizeof(addr));
    addr.sin_family = AF_INET;
    bcopy((char*)server->h_addr, (char*)&addr.sin_addr.s_addr, server->h_length);
    addr.sin_port = htons(port);
    if (::connect(hSocket, (sockaddr*)&addr, sizeof(addr)) < 0) {
        std::cerr << "Error: Could not connect to host \"" << host << "\".\n";
        disconnect();
        return false;
    }
    StartThread();
    return true; // success
}

void LSCPClient::disconnect() {
    if (hSocket >= 0) {
        StopThread();
        ::close(hSocket);
        hSocket = -1;
    }
}

bool LSCPClient::isConnected() const {
    return hSocket >= 0;
}

bool LSCPClient::send(char c) {
    String s;
    s += c;
    return send(s);
}

bool LSCPClient::send(String s) {
    if (!isConnected()) return false;
    int n = ::write(hSocket, &s[0], s.size());
    return n == s.size();
}

String LSCPClient::sendCommandSync(String s) {
    m_linesMutex.Lock();
    m_lines.clear();
    m_linesMutex.Unlock();

    m_sync.Set(true);
    if (!send(s + "\n")) return "";
    m_sync.WaitIf(true);

    m_linesMutex.Lock();
    String sResponse = m_lines.back();
    m_lines.clear();
    m_linesMutex.Unlock();

    return sResponse;
}

optional<String> LSCPClient::popLine() {
    String s;
    LockGuard guard(m_linesMutex);
    if (m_lines.empty()) return optional<String>::nothing;
    s = m_lines.front();
    m_lines.pop_front();
    //FIXME: this is incorrect when having multiple complete messages in the queue
    if (m_multiLineExpected && s.substr(0, 1) == ".")
        m_multiLineExpected = m_multiLineComplete = false;
    return s;
}

optional<String> LSCPClient::lookAheadLine(int index) {
    LockGuard guard(m_linesMutex);
    if (index < 0 || index >= m_lines.size())
        return optional<String>::nothing;
    std::list<String>::iterator it = m_lines.begin();
    for (int i = 0; i < index; ++i) ++it;
    String s = *it;
    return s;
}

bool LSCPClient::messageComplete() {
    if (!lineAvailable()) return false;
    LockGuard guard(m_linesMutex);
    if (!m_multiLineExpected) return true;
    return m_multiLineComplete;
}

bool LSCPClient::multiLine() {
    //FIXME: returns falsely "true" in case the first message is single-line response but there is already a multi-line response in the FIFO
    return m_multiLineExpected;
}

bool LSCPClient::lineAvailable() const {
    return !m_lines.empty(); // is thread safe
}

void LSCPClient::setCallback(Callback_t fn) {
    m_callback = fn;
}

optional<String> LSCPClient::receiveLine() {
    if (!isConnected()) return optional<String>::nothing;
    for (char c; true; ) {
        int n = ::read(hSocket, &c, 1);
        if (n < 1) return optional<String>::nothing;
        if (c == '\r') continue;
        if (c == '\n') {
            String s = m_lineBuffer;
            m_lineBuffer.clear();
            return s;
        }
        //printf("->%c\n", c);
        m_lineBuffer += c;
    }
    return optional<String>::nothing;
}

int LSCPClient::Main() {
    static const String multiLineKey = LSCP_SHK_EXPECT_MULTI_LINE;
    while (true) {
        optional<String> pLine = receiveLine();
        if (pLine) {
            String s = *pLine;
            //printf("->line '%s'\n", s.c_str());
            m_linesMutex.Lock();
            if (s.substr(0, multiLineKey.length()) == multiLineKey) {
                m_multiLineExpected = true;
                m_multiLineComplete = false;
            } else {
                if (m_multiLineExpected && s.substr(0, 1) == ".") {
                    m_multiLineComplete = true;
                }
                m_lines.push_back(s);
            }
            m_linesMutex.Unlock();

            if (m_sync.GetUnsafe()) m_sync.Set(false);
            else if (m_callback) (*m_callback)(this);
        }
        TestCancel();
    }
    return 0; // just to avoid a warning with some old compilers
}
1	schoenebeck	2515	/*
2			* LSCP Shell
3			*
4			* Copyright (c) 2014 Christian Schoenebeck
5			*
6			* This program is part of LinuxSampler and released under the same terms.
7			*/
8
9			#include "LSCPClient.h"
10
11			#include <strings.h>
12
13			LSCPClient::LSCPClient() :
14			Thread(false, false, 1, -1),
15			hSocket(-1), m_callback(NULL),
16			m_multiLineExpected(false), m_multiLineComplete(false)
17			{
18			}
19
20			LSCPClient::~LSCPClient() {
21			disconnect();
22			}
23
24			bool LSCPClient::connect(String host, int port) {
25			m_lineBuffer.clear();
26			m_lines.clear();
27			// resolve given host name
28			hostent* server = ::gethostbyname(host.c_str());
29			if (!server) {
30			std::cerr << "Error: Could not resolve host \"" << host << "\".\n";
31			return false;
32			}
33			// create local TCP socket
34			hSocket = ::socket(AF_INET, SOCK_STREAM, 0);
35			if (hSocket < 0) {
36			std::cerr << "Error: Could not create local socket.\n";
37			return false;
38			}
39			// TCP connect to server
40			sockaddr_in addr;
41			bzero((char*)&addr, sizeof(addr));
42			addr.sin_family = AF_INET;
43			bcopy((char)server->h_addr, (char)&addr.sin_addr.s_addr, server->h_length);
44			addr.sin_port = htons(port);
45			if (::connect(hSocket, (sockaddr*)&addr, sizeof(addr)) < 0) {
46			std::cerr << "Error: Could not connect to host \"" << host << "\".\n";
47			disconnect();
48			return false;
49			}
50			StartThread();
51			return true; // success
52			}
53
54			void LSCPClient::disconnect() {
55			if (hSocket >= 0) {
56			StopThread();
57			::close(hSocket);
58			hSocket = -1;
59			}
60			}
61
62			bool LSCPClient::isConnected() const {
63			return hSocket >= 0;
64			}
65
66			bool LSCPClient::send(char c) {
67			String s;
68			s += c;
69			return send(s);
70			}
71
72			bool LSCPClient::send(String s) {
73			if (!isConnected()) return false;
74			int n = ::write(hSocket, &s[0], s.size());
75			return n == s.size();
76			}
77
78			String LSCPClient::sendCommandSync(String s) {
79			m_linesMutex.Lock();
80			m_lines.clear();
81			m_linesMutex.Unlock();
82
83			m_sync.Set(true);
84			if (!send(s + "\n")) return "";
85			m_sync.WaitIf(true);
86
87			m_linesMutex.Lock();
88			String sResponse = m_lines.back();
89			m_lines.clear();
90			m_linesMutex.Unlock();
91
92			return sResponse;
93			}
94
95			optional<String> LSCPClient::popLine() {
96			String s;
97			LockGuard guard(m_linesMutex);
98			if (m_lines.empty()) return optional<String>::nothing;
99			s = m_lines.front();
100			m_lines.pop_front();
101			//FIXME: this is incorrect when having multiple complete messages in the queue
102			if (m_multiLineExpected && s.substr(0, 1) == ".")
103			m_multiLineExpected = m_multiLineComplete = false;
104			return s;
105			}
106
107			optional<String> LSCPClient::lookAheadLine(int index) {
108			LockGuard guard(m_linesMutex);
109			if (index < 0 \|\| index >= m_lines.size())
110			return optional<String>::nothing;
111			std::list<String>::iterator it = m_lines.begin();
112			for (int i = 0; i < index; ++i) ++it;
113			String s = *it;
114			return s;
115			}
116
117			bool LSCPClient::messageComplete() {
118			if (!lineAvailable()) return false;
119			LockGuard guard(m_linesMutex);
120			if (!m_multiLineExpected) return true;
121			return m_multiLineComplete;
122			}
123
124			bool LSCPClient::multiLine() {
125			//FIXME: returns falsely "true" in case the first message is single-line response but there is already a multi-line response in the FIFO
126			return m_multiLineExpected;
127			}
128
129			bool LSCPClient::lineAvailable() const {
130			return !m_lines.empty(); // is thread safe
131			}
132
133			void LSCPClient::setCallback(Callback_t fn) {
134			m_callback = fn;
135			}
136
137			optional<String> LSCPClient::receiveLine() {
138			if (!isConnected()) return optional<String>::nothing;
139			for (char c; true; ) {
140			int n = ::read(hSocket, &c, 1);
141			if (n < 1) return optional<String>::nothing;
142			if (c == '\r') continue;
143			if (c == '\n') {
144			String s = m_lineBuffer;
145			m_lineBuffer.clear();
146			return s;
147			}
148			//printf("->%c\n", c);
149			m_lineBuffer += c;
150			}
151			return optional<String>::nothing;
152			}
153
154			int LSCPClient::Main() {
155			static const String multiLineKey = LSCP_SHK_EXPECT_MULTI_LINE;
156			while (true) {
157			optional<String> pLine = receiveLine();
158			if (pLine) {
159			String s = *pLine;
160			//printf("->line '%s'\n", s.c_str());
161			m_linesMutex.Lock();
162			if (s.substr(0, multiLineKey.length()) == multiLineKey) {
163			m_multiLineExpected = true;
164			m_multiLineComplete = false;
165			} else {
166			if (m_multiLineExpected && s.substr(0, 1) == ".") {
167			m_multiLineComplete = true;
168			}
169			m_lines.push_back(s);
170			}
171			m_linesMutex.Unlock();
172
173			if (m_sync.GetUnsafe()) m_sync.Set(false);
174			else if (m_callback) (*m_callback)(this);
175			}
176			TestCancel();
177			}
178			return 0; // just to avoid a warning with some old compilers
179			}