lyx_mirror/src/ServerSocket.cpp
Jean-Marc Lasgouttes 8cc7e00cfd Turn th message about disabled socket into optional debug, since many
windows users believe that it actually means something, see e.g.
http://thread.gmane.org/gmane.editors.lyx.general/50338
http://thread.gmane.org/gmane.editors.lyx.general/39680



git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@26670 a592a061-630c-0410-9148-cb99ea01b6c8
2008-10-01 09:37:25 +00:00

287 lines
7.1 KiB
C++

/**
* \file ServerSocket.cpp
* This file is part of LyX, the document processor.
* Licence details can be found in the file COPYING.
*
* \author Lars Gullik Bjønnes
* \author Jean-Marc Lasgouttes
* \author Angus Leeming
* \author John Levon
* \author João Luis M. Assirati
*
* Full author contact details are available in file CREDITS.
*/
#include <config.h>
#include "ServerSocket.h"
#include "FuncRequest.h"
#include "LyXAction.h"
#include "LyXFunc.h"
#include "frontends/Application.h"
#include "support/debug.h"
#include "support/environment.h"
#include "support/FileName.h"
#include "support/socktools.h"
#include <boost/bind.hpp>
#include <cerrno>
#include <ostream>
#if defined (_WIN32)
# include <io.h>
#endif
using namespace std;
using namespace lyx::support;
using boost::shared_ptr;
namespace lyx {
// Address is the unix address for the socket.
// MAX_CLIENTS is the maximum number of clients
// that can connect at the same time.
ServerSocket::ServerSocket(LyXFunc * f, FileName const & addr)
: func(f),
fd_(socktools::listen(addr, 3)),
address_(addr)
{
if (fd_ == -1) {
LYXERR(Debug::LYXSERVER, "lyx: Disabling LyX socket.");
return;
}
// These env vars are used by DVI inverse search
// Needed by xdvi
setEnv("XEDITOR", "lyxclient -g %f %l");
// Needed by lyxclient
setEnv("LYXSOCKET", address_.absFilename());
theApp()->registerSocketCallback(
fd_,
boost::bind(&ServerSocket::serverCallback, this)
);
LYXERR(Debug::LYXSERVER, "lyx: New server socket "
<< fd_ << ' ' << address_.absFilename());
}
// Close the socket and remove the address of the filesystem.
ServerSocket::~ServerSocket()
{
if (fd_ != -1) {
BOOST_ASSERT (theApp());
theApp()->unregisterSocketCallback(fd_);
if (::close(fd_) != 0)
lyxerr << "lyx: Server socket " << fd_
<< " IO error on closing: " << strerror(errno)
<< endl;
}
address_.removeFile();
LYXERR(Debug::LYXSERVER, "lyx: Server socket quitting");
}
string const ServerSocket::address() const
{
return address_.absFilename();
}
// Creates a new LyXDataSocket and checks to see if the connection
// is OK and if the number of clients does not exceed MAX_CLIENTS
void ServerSocket::serverCallback()
{
int const client_fd = socktools::accept(fd_);
if (fd_ == -1) {
LYXERR(Debug::LYXSERVER, "lyx: Failed to accept new client");
return;
}
if (clients.size() >= MAX_CLIENTS) {
writeln("BYE:Too many clients connected");
return;
}
// Register the new client.
clients[client_fd] =
shared_ptr<LyXDataSocket>(new LyXDataSocket(client_fd));
theApp()->registerSocketCallback(
client_fd,
boost::bind(&ServerSocket::dataCallback,
this, client_fd)
);
}
// Reads and processes input from client and check
// if the connection has been closed
void ServerSocket::dataCallback(int fd)
{
shared_ptr<LyXDataSocket> client = clients[fd];
string line;
size_t pos;
bool saidbye = false;
while (!saidbye && client->readln(line)) {
// The protocol must be programmed here
// Split the key and the data
if ((pos = line.find(':')) == string::npos) {
client->writeln("ERROR:" + line + ":malformed message");
continue;
}
string const key = line.substr(0, pos);
if (key == "LYXCMD") {
string const cmd = line.substr(pos + 1);
func->dispatch(lyxaction.lookupFunc(cmd));
string const rval = to_utf8(func->getMessage());
if (func->errorStat()) {
client->writeln("ERROR:" + cmd + ':' + rval);
} else {
client->writeln("INFO:" + cmd + ':' + rval);
}
} else if (key == "HELLO") {
// no use for client name!
client->writeln("HELLO:");
} else if (key == "BYE") {
saidbye = true;
} else {
client->writeln("ERROR:unknown key " + key);
}
}
if (saidbye || !client->connected()) {
clients.erase(fd);
}
}
void ServerSocket::writeln(string const & line)
{
string const linen = line + '\n';
int const size = linen.size();
int const written = ::write(fd_, linen.c_str(), size);
if (written < size) { // Always mean end of connection.
if (written == -1 && errno == EPIPE) {
// The program will also receive a SIGPIPE
// that must be caught
lyxerr << "lyx: Server socket " << fd_
<< " connection closed while writing." << endl;
} else {
// Anything else, including errno == EAGAIN, must be
// considered IO error. EAGAIN should never happen
// when line is small
lyxerr << "lyx: Server socket " << fd_
<< " IO error: " << strerror(errno);
}
}
}
// Debug
// void ServerSocket::dump() const
// {
// lyxerr << "ServerSocket debug dump.\n"
// << "fd = " << fd_ << ", address = " << address_.absFilename() << ".\n"
// << "Clients: " << clients.size() << ".\n";
// map<int, shared_ptr<LyXDataSocket> >::const_iterator client = clients.begin();
// map<int, shared_ptr<LyXDataSocket> >::const_iterator end = clients.end();
// for (; client != end; ++client)
// lyxerr << "fd = " << client->first << '\n';
// }
LyXDataSocket::LyXDataSocket(int fd)
: fd_(fd), connected_(true)
{
LYXERR(Debug::LYXSERVER, "lyx: New data socket " << fd_);
}
LyXDataSocket::~LyXDataSocket()
{
if (::close(fd_) != 0)
lyxerr << "lyx: Data socket " << fd_
<< " IO error on closing: " << strerror(errno);
theApp()->unregisterSocketCallback(fd_);
LYXERR(Debug::LYXSERVER, "lyx: Data socket " << fd_ << " quitting.");
}
bool LyXDataSocket::connected() const
{
return connected_;
}
// Returns true if there was a complete line to input
bool LyXDataSocket::readln(string & line)
{
int const charbuf_size = 100;
char charbuf[charbuf_size]; // buffer for the ::read() system call
int count;
// read and store characters in buffer
while ((count = ::read(fd_, charbuf, charbuf_size - 1)) > 0) {
buffer_.append(charbuf, charbuf + count);
}
// Error conditions. The buffer must still be
// processed for lines read
if (count == 0) { // EOF -- connection closed
LYXERR(Debug::LYXSERVER, "lyx: Data socket " << fd_
<< ": connection closed.");
connected_ = false;
} else if ((count == -1) && (errno != EAGAIN)) { // IO error
lyxerr << "lyx: Data socket " << fd_
<< ": IO error." << endl;
connected_ = false;
}
// Cut a line from buffer
size_t pos = buffer_.find('\n');
if (pos == string::npos) {
LYXERR(Debug::LYXSERVER, "lyx: Data socket " << fd_
<< ": line not completed.");
return false; // No complete line stored
}
line = buffer_.substr(0, pos);
buffer_.erase(0, pos + 1);
return true;
}
// Write a line of the form <key>:<value> to the socket
void LyXDataSocket::writeln(string const & line)
{
string const linen = line + '\n';
int const size = linen.size();
int const written = ::write(fd_, linen.c_str(), size);
if (written < size) { // Always mean end of connection.
if (written == -1 && errno == EPIPE) {
// The program will also receive a SIGPIPE
// that must be catched
lyxerr << "lyx: Data socket " << fd_
<< " connection closed while writing." << endl;
} else {
// Anything else, including errno == EAGAIN, must be
// considered IO error. EAGAIN should never happen
// when line is small
lyxerr << "lyx: Data socket " << fd_
<< " IO error: " << strerror(errno);
}
connected_ = false;
}
}
} // namespace lyx