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";
        std::cerr << "Is linuxsampler running and listening on port " << port << " ?\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	schoenebeck	2517	std::cerr << "Is linuxsampler running and listening on port " << port << " ?\n";
48	schoenebeck	2515	disconnect();
49			return false;
50			}
51			StartThread();
52			return true; // success
53			}
54
55			void LSCPClient::disconnect() {
56			if (hSocket >= 0) {
57			StopThread();
58			::close(hSocket);
59			hSocket = -1;
60			}
61			}
62
63			bool LSCPClient::isConnected() const {
64			return hSocket >= 0;
65			}
66
67			bool LSCPClient::send(char c) {
68			String s;
69			s += c;
70			return send(s);
71			}
72
73			bool LSCPClient::send(String s) {
74			if (!isConnected()) return false;
75			int n = ::write(hSocket, &s[0], s.size());
76			return n == s.size();
77			}
78
79			String LSCPClient::sendCommandSync(String s) {
80			m_linesMutex.Lock();
81			m_lines.clear();
82			m_linesMutex.Unlock();
83
84			m_sync.Set(true);
85			if (!send(s + "\n")) return "";
86			m_sync.WaitIf(true);
87
88			m_linesMutex.Lock();
89			String sResponse = m_lines.back();
90			m_lines.clear();
91			m_linesMutex.Unlock();
92
93			return sResponse;
94			}
95
96			optional<String> LSCPClient::popLine() {
97			String s;
98			LockGuard guard(m_linesMutex);
99			if (m_lines.empty()) return optional<String>::nothing;
100			s = m_lines.front();
101			m_lines.pop_front();
102			//FIXME: this is incorrect when having multiple complete messages in the queue
103			if (m_multiLineExpected && s.substr(0, 1) == ".")
104			m_multiLineExpected = m_multiLineComplete = false;
105			return s;
106			}
107
108			optional<String> LSCPClient::lookAheadLine(int index) {
109			LockGuard guard(m_linesMutex);
110			if (index < 0 \|\| index >= m_lines.size())
111			return optional<String>::nothing;
112			std::list<String>::iterator it = m_lines.begin();
113			for (int i = 0; i < index; ++i) ++it;
114			String s = *it;
115			return s;
116			}
117
118			bool LSCPClient::messageComplete() {
119			if (!lineAvailable()) return false;
120			LockGuard guard(m_linesMutex);
121			if (!m_multiLineExpected) return true;
122			return m_multiLineComplete;
123			}
124
125			bool LSCPClient::multiLine() {
126			//FIXME: returns falsely "true" in case the first message is single-line response but there is already a multi-line response in the FIFO
127			return m_multiLineExpected;
128			}
129
130			bool LSCPClient::lineAvailable() const {
131			return !m_lines.empty(); // is thread safe
132			}
133
134			void LSCPClient::setCallback(Callback_t fn) {
135			m_callback = fn;
136			}
137
138			optional<String> LSCPClient::receiveLine() {
139			if (!isConnected()) return optional<String>::nothing;
140			for (char c; true; ) {
141			int n = ::read(hSocket, &c, 1);
142			if (n < 1) return optional<String>::nothing;
143			if (c == '\r') continue;
144			if (c == '\n') {
145			String s = m_lineBuffer;
146			m_lineBuffer.clear();
147			return s;
148			}
149			//printf("->%c\n", c);
150			m_lineBuffer += c;
151			}
152			return optional<String>::nothing;
153			}
154
155			int LSCPClient::Main() {
156			static const String multiLineKey = LSCP_SHK_EXPECT_MULTI_LINE;
157			while (true) {
158			optional<String> pLine = receiveLine();
159			if (pLine) {
160			String s = *pLine;
161			//printf("->line '%s'\n", s.c_str());
162			m_linesMutex.Lock();
163			if (s.substr(0, multiLineKey.length()) == multiLineKey) {
164			m_multiLineExpected = true;
165			m_multiLineComplete = false;
166			} else {
167			if (m_multiLineExpected && s.substr(0, 1) == ".") {
168			m_multiLineComplete = true;
169			}
170			m_lines.push_back(s);
171			}
172			m_linesMutex.Unlock();
173
174			if (m_sync.GetUnsafe()) m_sync.Set(false);
175			else if (m_callback) (*m_callback)(this);
176			}
177			TestCancel();
178			}
179			return 0; // just to avoid a warning with some old compilers
180			}