X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FServer.cpp;h=566f8f334400b6594cf587f71f5de43016ff7326;hb=7950ace3d96543e3099aa3bde823f970a1ce6a86;hp=77c1a5981a86fdfce8c91793bc5e7df9bdbdcd9b;hpb=fc978618030ebfaa4b624764330a0d7be4bd23e8;p=lyx.git

diff --git a/src/Server.cpp b/src/Server.cpp
index 77c1a5981a..566f8f3344 100644
--- a/src/Server.cpp
+++ b/src/Server.cpp
@@ -34,29 +34,36 @@
 	   received LyX will inform the client that it's listening its
 	   messages, and 'bye' will inform that lyx is closing.
 
-	   See development/server_monitor.c for an example client.
+	   See development/lyxserver/server_monitor.cpp for an example client.
   Purpose: implement a client/server lib for LyX
 */
 
 #include <config.h>
 
 #include "Server.h"
+
+#include "DispatchResult.h"
 #include "FuncRequest.h"
+#include "LyX.h"
 #include "LyXAction.h"
-#include "LyXFunc.h"
 
 #include "frontends/Application.h"
 
 #include "support/debug.h"
 #include "support/FileName.h"
+#include "support/filetools.h"
+#include "support/lassert.h"
 #include "support/lstrings.h"
 #include "support/os.h"
+#include "support/signals.h"
 
-#include <boost/bind.hpp>
+#include <iostream>
 
 #ifdef _WIN32
+#include <io.h>
 #include <QCoreApplication>
 #endif
+#include <QThread>
 
 #include <cerrno>
 #ifdef HAVE_SYS_STAT_H
@@ -78,114 +85,423 @@ namespace lyx {
 
 #if defined(_WIN32)
 
-class PipeEvent : public QEvent {
+class ReadReadyEvent : public QEvent {
 public:
 	///
-	PipeEvent(HANDLE inpipe) : QEvent(QEvent::User), inpipe_(inpipe)
+	ReadReadyEvent(DWORD inpipe) : QEvent(QEvent::User), inpipe_(inpipe)
 	{}
 	///
-	HANDLE pipe() const { return inpipe_; }
+	DWORD inpipe() const { return inpipe_; }
 
 private:
-	HANDLE inpipe_;
+	DWORD inpipe_;
 };
 
 namespace {
 
-char * errormsg()
+string errormsg(DWORD const error)
 {
 	void * msgbuf;
-	DWORD error = GetLastError();
-	FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
-		      FORMAT_MESSAGE_FROM_SYSTEM |
-		      FORMAT_MESSAGE_IGNORE_INSERTS,
-		      NULL, error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-		      (LPTSTR) &msgbuf, 0, NULL);
-	return static_cast<char *>(msgbuf);
+	string message;
+	if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
+			  FORMAT_MESSAGE_FROM_SYSTEM |
+			  FORMAT_MESSAGE_IGNORE_INSERTS,
+			  NULL, error,
+			  MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+			  (LPTSTR) &msgbuf, 0, NULL)) {
+		message = static_cast<char *>(msgbuf);
+		LocalFree(msgbuf);
+	} else
+		message = "Unknown error";
+
+	return message;
 }
 
+} // namespace
 
-extern "C" {
 
 DWORD WINAPI pipeServerWrapper(void * arg)
 {
 	LyXComm * lyxcomm = reinterpret_cast<LyXComm *>(arg);
-	lyxcomm->pipeServer();
+	if (!lyxcomm->pipeServer()) {
+		// Error exit; perform cleanup.
+		lyxcomm->ready_ = false;
+		lyxcomm->closeHandles();
+		CloseHandle(lyxcomm->server_thread_);
+		CloseHandle(lyxcomm->stopserver_);
+		CloseHandle(lyxcomm->outbuf_mutex_);
+		lyxerr << "LyXComm: Closing connection" << endl;
+	}
 	return 1;
 }
 
-}
-
-} // namespace anon
 
 LyXComm::LyXComm(string const & pip, Server * cli, ClientCallbackfct ccb)
-	: pipename_(pip), client_(cli), clientcb_(ccb)
+	: stopserver_(0),
+	  ready_(false), pipename_(pip), client_(cli), clientcb_(ccb),
+	  deferred_loading_(false)
 {
-	ready_ = false;
+	for (int i = 0; i < MAX_PIPES; ++i) {
+		event_[i] = 0;
+		pipe_[i].handle = INVALID_HANDLE_VALUE;
+	}
 	openConnection();
 }
 
 
-void LyXComm::pipeServer()
+bool LyXComm::pipeServer()
 {
-	int const bufsize = 1024;
-	HANDLE inpipe;
+	DWORD i;
+	DWORD error;
+
+	for (i = 0; i < MAX_PIPES; ++i) {
+		bool const is_outpipe = i >= MAX_CLIENTS;
+		DWORD const open_mode = is_outpipe ? PIPE_ACCESS_OUTBOUND
+						   : PIPE_ACCESS_INBOUND;
+		string const pipename = external_path(pipeName(i));
+
+		// Manual-reset event, initial state = signaled
+		event_[i] = CreateEvent(NULL, TRUE, TRUE, NULL);
+		if (!event_[i]) {
+			error = GetLastError();
+			lyxerr << "LyXComm: Could not create event for pipe "
+			       << pipename << "\nLyXComm: "
+			       << errormsg(error) << endl;
+			return false;
+		}
 
-	outpipe_ = CreateNamedPipe(external_path(outPipeName()).c_str(),
-				   PIPE_ACCESS_OUTBOUND, PIPE_NOWAIT,
-				   PIPE_UNLIMITED_INSTANCES,
-				   bufsize, 0, 0, NULL);
-	if (outpipe_ == INVALID_HANDLE_VALUE) {
-		lyxerr << "LyXComm: Could not create pipe "
-		       << outPipeName() << '\n' << errormsg() << endl;
-		return;
-	}
-	ConnectNamedPipe(outpipe_, NULL);
-	// Now change to blocking mode
-	DWORD mode = PIPE_WAIT;
-	SetNamedPipeHandleState(outpipe_, &mode, NULL, NULL);
-
-	while (!checkStopServerEvent()) {
-		inpipe = CreateNamedPipe(external_path(inPipeName()).c_str(),
-					 PIPE_ACCESS_INBOUND, PIPE_WAIT,
-					 PIPE_UNLIMITED_INSTANCES,
-					 0, bufsize, 0, NULL);
-		if (inpipe == INVALID_HANDLE_VALUE) {
+		pipe_[i].overlap.hEvent = event_[i];
+		pipe_[i].iobuf.erase();
+		pipe_[i].handle = CreateNamedPipe(pipename.c_str(),
+				open_mode | FILE_FLAG_OVERLAPPED, PIPE_WAIT,
+				MAX_CLIENTS, PIPE_BUFSIZE, PIPE_BUFSIZE,
+				PIPE_TIMEOUT, NULL);
+
+		if (pipe_[i].handle == INVALID_HANDLE_VALUE) {
+			error = GetLastError();
 			lyxerr << "LyXComm: Could not create pipe "
-			       << inPipeName() << '\n' << errormsg() << endl;
+			       << pipename << "\nLyXComm: "
+			       << errormsg(error) << endl;
+			return false;
+		}
+
+		if (!startPipe(i))
+			return false;
+		pipe_[i].state = pipe_[i].pending_io ?
+			CONNECTING_STATE : (is_outpipe ? WRITING_STATE
+						       : READING_STATE);
+	}
+
+	// Add the stopserver_ event
+	event_[MAX_PIPES] = stopserver_;
+
+	// We made it!
+	LYXERR(Debug::LYXSERVER, "LyXComm: Connection established");
+	ready_ = true;
+	outbuf_.erase();
+	DWORD status;
+	bool success;
+
+	while (!checkStopServer()) {
+		// Indefinitely wait for the completion of an overlapped
+		// read, write, or connect operation.
+		DWORD wait = WaitForMultipleObjects(MAX_PIPES + 1, event_,
+						    FALSE, INFINITE);
+
+		// Determine which pipe instance completed the operation.
+		i = wait - WAIT_OBJECT_0;
+		LASSERT(i <= MAX_PIPES, /**/);
+
+		// Check whether we were waked up for stopping the pipe server.
+		if (i == MAX_PIPES)
 			break;
+
+		bool const is_outpipe = i >= MAX_CLIENTS;
+
+		// Get the result if the operation was pending.
+		if (pipe_[i].pending_io) {
+			success = GetOverlappedResult(pipe_[i].handle,
+					&pipe_[i].overlap, &status, FALSE);
+
+			switch (pipe_[i].state) {
+			case CONNECTING_STATE:
+				// Pending connect operation
+				if (!success) {
+					error = GetLastError();
+					lyxerr << "LyXComm: "
+					       << errormsg(error) << endl;
+					if (!resetPipe(i, true))
+						return false;
+					continue;
+				}
+				pipe_[i].state = is_outpipe ? WRITING_STATE
+							    : READING_STATE;
+				break;
+
+			case READING_STATE:
+				// Pending read operation
+				LASSERT(!is_outpipe, /**/);
+				if (!success || status == 0) {
+					if (!resetPipe(i, !success))
+						return false;
+					continue;
+				}
+				pipe_[i].nbytes = status;
+				pipe_[i].state = WRITING_STATE;
+				break;
+
+			case WRITING_STATE:
+				// Pending write operation
+				LASSERT(is_outpipe, /**/);
+				// Let's see whether we have a reply
+				if (!outbuf_.empty()) {
+					// Yep. Deliver it to all pipe
+					// instances if we get ownership
+					// of the mutex, otherwise we'll
+					// try again the next round.
+					DWORD result = WaitForSingleObject(
+							outbuf_mutex_, 200);
+					if (result == WAIT_OBJECT_0) {
+						DWORD j = MAX_CLIENTS;
+						while (j < MAX_PIPES) {
+							pipe_[j].iobuf = outbuf_;
+							++j;
+						}
+						outbuf_.erase();
+					}
+					ReleaseMutex(outbuf_mutex_);
+				}
+				if (pipe_[i].iobuf.empty())
+					pipe_[i].pending_io = false;
+				break;
+			}
 		}
 
-		BOOL connected = ConnectNamedPipe(inpipe, NULL);
-		// Check whether we are signaled to shutdown the pipe server.
-		if (checkStopServerEvent()) {
-			CloseHandle(inpipe);
+		// Operate according to the pipe state
+		switch (pipe_[i].state) {
+		case READING_STATE:
+			// The pipe instance is connected to a client
+			// and is ready to read a request.
+			LASSERT(!is_outpipe, /**/);
+			success = ReadFile(pipe_[i].handle,
+					pipe_[i].readbuf, PIPE_BUFSIZE - 1,
+					&pipe_[i].nbytes, &pipe_[i].overlap);
+
+			if (success && pipe_[i].nbytes != 0) {
+				// The read operation completed successfully.
+				pipe_[i].pending_io = false;
+				pipe_[i].state = WRITING_STATE;
+				continue;
+			}
+
+			error = GetLastError();
+
+			if (!success && error == ERROR_IO_PENDING) {
+				// The read operation is still pending.
+				pipe_[i].pending_io = true;
+				continue;
+			}
+
+			success = error == ERROR_BROKEN_PIPE;
+
+			// Client closed connection (ERROR_BROKEN_PIPE) or
+			// an error occurred; in either case, reset the pipe.
+			if (!success) {
+				lyxerr << "LyXComm: " << errormsg(error) << endl;
+				if (!pipe_[i].iobuf.empty()) {
+					lyxerr << "LyXComm: truncated command: "
+					       << pipe_[i].iobuf << endl;
+					pipe_[i].iobuf.erase();
+				}
+			}
+			if (!resetPipe(i, !success))
+				return false;
+			break;
+
+		case WRITING_STATE:
+			if (!is_outpipe) {
+				// The request was successfully read
+				// from the client; commit it.
+				ReadReadyEvent * event = new ReadReadyEvent(i);
+				QCoreApplication::postEvent(this,
+						static_cast<QEvent *>(event));
+				// Wait for completion
+				while (pipe_[i].nbytes && !checkStopServer(100))
+					;
+				pipe_[i].pending_io = false;
+				pipe_[i].state = READING_STATE;
+				continue;
+			}
+
+			// This is an output pipe instance. Initiate the
+			// overlapped write operation or monitor its progress.
+
+			if (pipe_[i].pending_io) {
+				success = WriteFile(pipe_[i].handle,
+						pipe_[i].iobuf.c_str(),
+						pipe_[i].iobuf.length(),
+						&status,
+						&pipe_[i].overlap);
+			}
+
+			if (success && !pipe_[i].iobuf.empty()
+			    && status == pipe_[i].iobuf.length()) {
+				// The write operation completed successfully.
+				pipe_[i].iobuf.erase();
+				pipe_[i].pending_io = false;
+				if (!resetPipe(i))
+					return false;
+				continue;
+			}
+
+			error = GetLastError();
+
+			if (success && (error == ERROR_IO_PENDING || error == NO_ERROR)) {
+				// The write operation is still pending.
+				// We get here when a reader is started
+				// well before a reply is ready, so delay
+				// a bit in order to not burden the cpu.
+				checkStopServer(100);
+				pipe_[i].pending_io = true;
+				continue;
+			}
+
+			success = error == ERROR_NO_DATA;
+
+			// Client closed connection (ERROR_NO_DATA) or
+			// an error occurred; in either case, reset the pipe.
+			if (!success) {
+				lyxerr << "LyXComm: Error sending message: "
+				       << pipe_[i].iobuf << "\nLyXComm: "
+				       << errormsg(error) << endl;
+			}
+			if (!resetPipe(i, !success))
+				return false;
 			break;
 		}
-		if (connected || GetLastError() == ERROR_PIPE_CONNECTED) {
-			PipeEvent * event = new PipeEvent(inpipe);
-			QCoreApplication::postEvent(this,
-					static_cast<QEvent *>(event));
-		} else
-			CloseHandle(inpipe);
 	}
-	CloseHandle(outpipe_);
+
+	ready_ = false;
+	closeHandles();
+	return true;
+}
+
+
+void LyXComm::closeHandles()
+{
+	for (int i = 0; i < MAX_PIPES; ++i) {
+		if (event_[i]) {
+			ResetEvent(event_[i]);
+			CloseHandle(event_[i]);
+			event_[i] = 0;
+		}
+		if (pipe_[i].handle != INVALID_HANDLE_VALUE) {
+			CloseHandle(pipe_[i].handle);
+			pipe_[i].handle = INVALID_HANDLE_VALUE;
+		}
+	}
 }
 
 
 bool LyXComm::event(QEvent * e)
 {
 	if (e->type() == QEvent::User) {
-		read_ready(static_cast<PipeEvent *>(e)->pipe());
+		read_ready(static_cast<ReadReadyEvent *>(e)->inpipe());
 		return true;
 	}
 	return false;
 }
 
 
-BOOL LyXComm::checkStopServerEvent()
+bool LyXComm::checkStopServer(DWORD timeout)
 {
-	return WaitForSingleObject(stopserver_, 0) == WAIT_OBJECT_0;
+	return WaitForSingleObject(stopserver_, timeout) == WAIT_OBJECT_0;
+}
+
+
+bool LyXComm::startPipe(DWORD index)
+{
+	pipe_[index].pending_io = false;
+	pipe_[index].overlap.Offset = 0;
+	pipe_[index].overlap.OffsetHigh = 0;
+
+	// Overlapped ConnectNamedPipe should return zero.
+	if (ConnectNamedPipe(pipe_[index].handle, &pipe_[index].overlap)) {
+		DWORD const error = GetLastError();
+		lyxerr << "LyXComm: Could not connect pipe "
+		       << external_path(pipeName(index))
+		       << "\nLyXComm: " << errormsg(error) << endl;
+		return false;
+	}
+
+	switch (GetLastError()) {
+	case ERROR_IO_PENDING:
+		// The overlapped connection is in progress.
+		pipe_[index].pending_io = true;
+		break;
+
+	case ERROR_PIPE_CONNECTED:
+		// Client is already connected, so signal an event.
+		if (SetEvent(pipe_[index].overlap.hEvent))
+			break;
+		// fall through
+	default:
+		// Anything else is an error.
+		DWORD const error = GetLastError();
+		lyxerr << "LyXComm: An error occurred while connecting pipe "
+		       << external_path(pipeName(index))
+		       << "\nLyXComm: " << errormsg(error) << endl;
+		return false;
+	}
+
+	return true;
+}
+
+
+bool LyXComm::resetPipe(DWORD index, bool close_handle)
+{
+	// This method is called when an error occurs or when a client
+	// closes the connection. We first disconnect the pipe instance,
+	// then reconnect it, ready to wait for another client.
+
+	if (!DisconnectNamedPipe(pipe_[index].handle)) {
+		DWORD const error = GetLastError();
+		lyxerr << "LyXComm: Could not disconnect pipe "
+		       << external_path(pipeName(index))
+		       << "\nLyXComm: " << errormsg(error) << endl;
+		// What to do now? Let's try whether re-creating the pipe helps.
+		close_handle = true;
+	}
+
+	bool const is_outpipe = index >= MAX_CLIENTS;
+
+	if (close_handle) {
+		DWORD const open_mode = is_outpipe ? PIPE_ACCESS_OUTBOUND
+						   : PIPE_ACCESS_INBOUND;
+		string const name = external_path(pipeName(index));
+
+		CloseHandle(pipe_[index].handle);
+
+		pipe_[index].iobuf.erase();
+		pipe_[index].handle = CreateNamedPipe(name.c_str(),
+				open_mode | FILE_FLAG_OVERLAPPED, PIPE_WAIT,
+				MAX_CLIENTS, PIPE_BUFSIZE, PIPE_BUFSIZE,
+				PIPE_TIMEOUT, NULL);
+
+		if (pipe_[index].handle == INVALID_HANDLE_VALUE) {
+			DWORD const error = GetLastError();
+			lyxerr << "LyXComm: Could not reset pipe " << name
+			       << "\nLyXComm: " << errormsg(error) << endl;
+			return false;
+		}
+	}
+
+	if (!startPipe(index))
+		return false;
+	pipe_[index].state = pipe_[index].pending_io ?
+			CONNECTING_STATE : (is_outpipe ? WRITING_STATE
+						       : READING_STATE);
+	return true;
 }
 
 
@@ -195,31 +511,62 @@ void LyXComm::openConnection()
 
 	// If we are up, that's an error
 	if (ready_) {
-		lyxerr << "LyXComm: Already connected" << endl;
+		LYXERR(Debug::LYXSERVER, "LyXComm: Already connected");
 		return;
 	}
-	// We assume that we don't make it
-	ready_ = false;
 
 	if (pipename_.empty()) {
 		LYXERR(Debug::LYXSERVER, "LyXComm: server is disabled, nothing to do");
 		return;
 	}
 
+	// Check whether the pipe name is being used by some other instance.
+	if (!stopserver_ && WaitNamedPipe(inPipeName().c_str(), 0)) {
+		// Tell the running instance to load the files
+		if (run_mode == USE_REMOTE && loadFilesInOtherInstance()) {
+			deferred_loading_ = true;
+			pipename_.erase();
+			return;
+		}
+		lyxerr << "LyXComm: Pipe " << external_path(inPipeName())
+		       << " already exists.\nMaybe another instance of LyX"
+			  " is using it." << endl;
+		pipename_.erase();
+		return;
+	}
+
+	// Mutex with no initial owner for synchronized access to outbuf_
+	outbuf_mutex_ = CreateMutex(NULL, FALSE, NULL);
+	if (!outbuf_mutex_) {
+		DWORD const error = GetLastError();
+		lyxerr << "LyXComm: Could not create output buffer mutex"
+		       << "\nLyXComm: " << errormsg(error) << endl;
+		pipename_.erase();
+		return;
+	}
+
+	// Manual-reset event, initial state = not signaled
 	stopserver_ = CreateEvent(NULL, TRUE, FALSE, NULL);
-	DWORD tid;
-	HANDLE thread = CreateThread(NULL, 0, pipeServerWrapper,
-				     static_cast<void *>(this), 0, &tid);
-	if (!thread) {
-		lyxerr << "LyXComm: Could not create pipe server thread: "
-		       << errormsg() << endl;
+	if (!stopserver_) {
+		DWORD const error = GetLastError();
+		lyxerr << "LyXComm: Could not create stop server event"
+		       << "\nLyXComm: " << errormsg(error) << endl;
+		pipename_.erase();
+		CloseHandle(outbuf_mutex_);
 		return;
-	} else
-		CloseHandle(thread);
+	}
 
-	// We made it!
-	ready_ = true;
-	LYXERR(Debug::LYXSERVER, "LyXComm: Connection established");
+	server_thread_ = CreateThread(NULL, 0, pipeServerWrapper,
+				     static_cast<void *>(this), 0, NULL);
+	if (!server_thread_) {
+		DWORD const error = GetLastError();
+		lyxerr << "LyXComm: Could not create pipe server thread"
+		       << "\nLyXComm: " << errormsg(error) << endl;
+		pipename_.erase();
+		CloseHandle(stopserver_);
+		CloseHandle(outbuf_mutex_);
+		return;
+	}
 }
 
 
@@ -234,138 +581,122 @@ void LyXComm::closeConnection()
 	}
 
 	if (!ready_) {
-		LYXERR0("LyXComm: Already disconnected");
+		LYXERR(Debug::LYXSERVER, "LyXComm: Already disconnected");
 		return;
 	}
 
 	SetEvent(stopserver_);
-	HANDLE hpipe = CreateFile(external_path(inPipeName()).c_str(),
-				  GENERIC_WRITE, 0, NULL, OPEN_EXISTING,
-				  FILE_ATTRIBUTE_NORMAL, NULL);
-	if (hpipe != INVALID_HANDLE_VALUE)
-		CloseHandle(hpipe);
-
-	ready_ = false;
+	// Wait for the pipe server to finish
+	WaitForSingleObject(server_thread_, INFINITE);
+	CloseHandle(server_thread_);
+	ResetEvent(stopserver_);
+	CloseHandle(stopserver_);
+	CloseHandle(outbuf_mutex_);
 }
 
 
 void LyXComm::emergencyCleanup()
 {
-	if (!pipename_.empty()) {
+	if (ready_) {
 		SetEvent(stopserver_);
-		HANDLE hpipe = CreateFile(external_path(inPipeName()).c_str(),
-					  GENERIC_WRITE, 0, NULL, OPEN_EXISTING,
-					  FILE_ATTRIBUTE_NORMAL, NULL);
-		if (hpipe != INVALID_HANDLE_VALUE)
-			CloseHandle(hpipe);
+		// Forcibly terminate the pipe server thread if it does
+		// not finish quickly.
+		if (WaitForSingleObject(server_thread_, 200) != WAIT_OBJECT_0) {
+			TerminateThread(server_thread_, 0);
+			ready_ = false;
+			closeHandles();
+		}
+		CloseHandle(server_thread_);
+		ResetEvent(stopserver_);
+		CloseHandle(stopserver_);
+		CloseHandle(outbuf_mutex_);
 	}
 }
 
-void LyXComm::read_ready(HANDLE inpipe)
+
+void LyXComm::read_ready(DWORD inpipe)
 {
-	string read_buffer_;
-	read_buffer_.erase();
+	// Turn the pipe buffer into a C string
+	DWORD const nbytes = pipe_[inpipe].nbytes;
+	pipe_[inpipe].readbuf[nbytes] = '\0';
 
-	int const charbuf_size = 100;
-	char charbuf[charbuf_size];
+	pipe_[inpipe].iobuf += rtrim(pipe_[inpipe].readbuf, "\r");
 
-	DWORD status;
-	while (ReadFile(inpipe, charbuf, charbuf_size - 1, &status, NULL)) {
-		if (status > 0) {
-			charbuf[status] = '\0'; // turn it into a c string
-			read_buffer_ += rtrim(charbuf, "\r");
-			// commit any commands read
-			while (read_buffer_.find('\n') != string::npos) {
-				// split() grabs the entire string if
-				// the delim /wasn't/ found. ?:-P
-				string cmd;
-				read_buffer_= split(read_buffer_, cmd, '\n');
-				cmd = rtrim(cmd, "\r");
-				LYXERR(Debug::LYXSERVER, "LyXComm: status:" << status
-					<< ", read_buffer_:" << read_buffer_
-					<< ", cmd:" << cmd);
-				if (!cmd.empty())
-					clientcb_(client_, cmd);
-					//\n or not \n?
-			}
-		}
-	}
-	if (GetLastError() != ERROR_BROKEN_PIPE) {
-		// An error occurred
-		LYXERR0("LyXComm: " << errormsg());
-		if (!read_buffer_.empty()) {
-			LYXERR0("LyXComm: truncated command: " << read_buffer_);
-			read_buffer_.erase();
-		}
+	// Commit any commands read
+	while (pipe_[inpipe].iobuf.find('\n') != string::npos) {
+		// split() grabs the entire string if
+		// the delim /wasn't/ found. ?:-P
+		string cmd;
+		pipe_[inpipe].iobuf = split(pipe_[inpipe].iobuf, cmd, '\n');
+		cmd = rtrim(cmd, "\r");
+		LYXERR(Debug::LYXSERVER, "LyXComm: nbytes:" << nbytes
+			<< ", iobuf:" << pipe_[inpipe].iobuf
+			<< ", cmd:" << cmd);
+		if (!cmd.empty())
+			clientcb_(client_, cmd);
+			//\n or not \n?
 	}
-	// Client closed the pipe, so disconnect and close.
-	DisconnectNamedPipe(inpipe);
-	CloseHandle(inpipe);
-	FlushFileBuffers(outpipe_);
-	DisconnectNamedPipe(outpipe_);
-	// Temporarily change to non-blocking mode otherwise
-	// ConnectNamedPipe() would block waiting for a connection.
-	DWORD mode = PIPE_NOWAIT;
-	SetNamedPipeHandleState(outpipe_, &mode, NULL, NULL);
-	ConnectNamedPipe(outpipe_, NULL);
-	mode = PIPE_WAIT;
-	SetNamedPipeHandleState(outpipe_, &mode, NULL, NULL);
+	// Signal that we are done.
+	pipe_[inpipe].nbytes = 0;
 }
 
 
 void LyXComm::send(string const & msg)
 {
 	if (msg.empty()) {
-		LYXERR0("LyXComm: Request to send empty string. Ignoring.");
+		lyxerr << "LyXComm: Request to send empty string. Ignoring."
+		       << endl;
 		return;
 	}
 
 	LYXERR(Debug::LYXSERVER, "LyXComm: Sending '" << msg << '\'');
 
-	if (pipename_.empty()) return;
+	if (pipename_.empty())
+		return;
 
 	if (!ready_) {
-		LYXERR0("LyXComm: Pipes are closed. Could not send " << msg);
+		lyxerr << "LyXComm: Pipes are closed. Could not send "
+		       << msg << endl;
 		return;
 	}
 
-	bool success;
-	int count = 0;
-	do {
-		DWORD sent;
-		success = WriteFile(outpipe_, msg.c_str(), msg.length(), &sent, NULL);
-		if (!success) {
-			DWORD error = GetLastError();
-			if (error == ERROR_NO_DATA) {
-				DisconnectNamedPipe(outpipe_);
-				DWORD mode = PIPE_NOWAIT;
-				SetNamedPipeHandleState(outpipe_, &mode, NULL, NULL);
-				ConnectNamedPipe(outpipe_, NULL);
-				mode = PIPE_WAIT;
-				SetNamedPipeHandleState(outpipe_, &mode, NULL, NULL);
-			} else if (error != ERROR_PIPE_LISTENING)
-				break;
-		}
-		Sleep(100);
-		++count;
-	} while (!success && count < 100);
-
-	if (!success) {
+	// Request ownership of the outbuf_mutex_
+	DWORD result = WaitForSingleObject(outbuf_mutex_, PIPE_TIMEOUT);
+
+	if (result == WAIT_OBJECT_0) {
+		// If a client doesn't care to read a reply (JabRef is one
+		// such client), the output buffer could grow without limit.
+		// So, we empty it when its size is larger than PIPE_BUFSIZE.
+		if (outbuf_.size() > PIPE_BUFSIZE)
+			outbuf_.erase();
+		outbuf_ += msg;
+		ReleaseMutex(outbuf_mutex_);
+	} else {
+		// Something is fishy, better resetting the connection.
+		DWORD const error = GetLastError();
 		lyxerr << "LyXComm: Error sending message: " << msg
-		       << '\n' << errormsg()
+		       << "\nLyXComm: " << errormsg(error)
 		       << "\nLyXComm: Resetting connection" << endl;
+		ReleaseMutex(outbuf_mutex_);
 		closeConnection();
 		openConnection();
 	}
 }
 
 
+string const LyXComm::pipeName(DWORD index) const
+{
+	return index < MAX_CLIENTS ? inPipeName() : outPipeName();
+}
+
+
 #elif !defined (HAVE_MKFIFO)
 // We provide a stub class that disables the lyxserver.
 
 LyXComm::LyXComm(string const &, Server *, ClientCallbackfct)
 {}
 
+
 void LyXComm::openConnection()
 {}
 
@@ -387,6 +718,7 @@ void LyXComm::endPipe(int & fd, string const & filename, bool write)
 void LyXComm::emergencyCleanup()
 {}
 
+
 void LyXComm::read_ready()
 {}
 
@@ -397,11 +729,11 @@ void LyXComm::send(string const & msg)
 
 #else // defined (HAVE_MKFIFO)
 
-
 LyXComm::LyXComm(string const & pip, Server * cli, ClientCallbackfct ccb)
-	: pipename_(pip), client_(cli), clientcb_(ccb)
+	: infd_(-1), outfd_(-1),
+	  ready_(false), pipename_(pip), client_(cli), clientcb_(ccb),
+	  deferred_loading_(false)
 {
-	ready_ = false;
 	openConnection();
 }
 
@@ -479,6 +811,12 @@ int LyXComm::startPipe(string const & file, bool write)
 			if (fd >= 0) {
 				// Another LyX instance is using it.
 				::close(fd);
+				// Tell the running instance to load the files
+				if (run_mode == USE_REMOTE && loadFilesInOtherInstance()) {
+					deferred_loading_ = true;
+					pipename_.erase();
+					return -1;
+				}
 			} else if (errno == ENXIO) {
 				// No process is reading from the other end.
 				stalepipe = true;
@@ -520,8 +858,12 @@ int LyXComm::startPipe(string const & file, bool write)
 	}
 
 	if (!write) {
-		theApp()->registerSocketCallback(fd,
-			boost::bind(&LyXComm::read_ready, this));
+		// Make sure not to call read_ready after destruction.
+		weak_ptr<void> tracker = tracker_.p();
+		theApp()->registerSocketCallback(fd, [=](){
+				if (!tracker.expired())
+					read_ready();
+			});
 	}
 
 	return fd;
@@ -541,7 +883,7 @@ void LyXComm::endPipe(int & fd, string const & filename, bool write)
 		       << '\n' << strerror(errno) << endl;
 	}
 
-	if (FileName(filename).removeFile() < 0) {
+	if (!FileName(filename).removeFile()) {
 		lyxerr << "LyXComm: Could not remove pipe " << filename
 		       << '\n' << strerror(errno) << endl;
 	}
@@ -579,7 +921,6 @@ void LyXComm::read_ready()
 	int status;
 	// the single = is intended here.
 	while ((status = ::read(infd_, charbuf, charbuf_size - 1))) {
-
 		if (status > 0) {
 			charbuf[status] = '\0'; // turn it into a c string
 			read_buffer_ += rtrim(charbuf, "\r");
@@ -630,7 +971,8 @@ void LyXComm::send(string const & msg)
 
 	LYXERR(Debug::LYXSERVER, "LyXComm: Sending '" << msg << '\'');
 
-	if (pipename_.empty()) return;
+	if (pipename_.empty())
+		return;
 
 	if (!ready_) {
 		LYXERR0("LyXComm: Pipes are closed. Could not send " << msg);
@@ -645,6 +987,49 @@ void LyXComm::send(string const & msg)
 
 #endif // defined (HAVE_MKFIFO)
 
+namespace {
+
+struct Sleep : QThread
+{
+	static void millisec(unsigned long ms)
+	{
+		QThread::usleep(ms * 1000);
+	}
+};
+
+} // namespace
+
+
+bool LyXComm::loadFilesInOtherInstance()
+{
+	int pipefd;
+	int loaded_files = 0;
+	FileName const pipe(inPipeName());
+	vector<string>::iterator it = theFilesToLoad().begin();
+	while (it != theFilesToLoad().end()) {
+		FileName fname = fileSearch(string(), os::internal_path(*it),
+						"lyx", may_not_exist);
+		if (fname.empty()) {
+			++it;
+			continue;
+		}
+		// Wait a while to allow time for the other
+		// instance to reset the connection
+		Sleep::millisec(200);
+		pipefd = ::open(pipe.toFilesystemEncoding().c_str(), O_WRONLY);
+		if (pipefd < 0)
+			break;
+		string const cmd = "LYXCMD:pipe:file-open:" +
+					fname.absFileName() + '\n';
+		if (::write(pipefd, cmd.c_str(), cmd.length()) < 0)
+			LYXERR0("Cannot write to pipe!");
+		::close(pipefd);
+		++loaded_files;
+		it = theFilesToLoad().erase(it);
+	}
+	return loaded_files > 0;
+}
+
 
 string const LyXComm::inPipeName() const
 {
@@ -669,8 +1054,8 @@ void ServerCallback(Server * server, string const & msg)
 	server->callback(msg);
 }
 
-Server::Server(LyXFunc * f, string const & pipes)
-	: numclients_(0), func_(f), pipes_(pipes, this, &ServerCallback)
+Server::Server(string const & pipes)
+	: numclients_(0), pipes_(pipes, this, &ServerCallback)
 {}
 
 
@@ -689,7 +1074,6 @@ Server::~Server()
 
 int compare(char const * a, char const * b, unsigned int len)
 {
-	using namespace std;
 	return strncmp(a, b, len);
 }
 
@@ -778,7 +1162,7 @@ void Server::callback(string const & msg)
 						<< client << " said goodbye");
 				} else {
 					LYXERR(Debug::LYXSERVER,
-						"Server: ignoring bye messge from unregistered client" << client);
+						"Server: ignoring bye message from unregistered client" << client);
 				}
 			} else {
 				LYXERR0("Server: Undefined server command " << cmd << '.');
@@ -791,17 +1175,20 @@ void Server::callback(string const & msg)
 			// The correct solution would be to have a
 			// specialized (non-gui) BufferView. But how do
 			// we do it now? Probably we should just let it
-			// connect to the lyxfunc in the single LyXView we
+			// connect to the lyxfunc in the single GuiView we
 			// support currently. (Lgb)
 
-			func_->dispatch(FuncRequest(lyxaction.lookupFunc(cmd), arg));
-			string const rval = to_utf8(func_->getMessage());
+			FuncRequest fr(lyxaction.lookupFunc(cmd), from_utf8(arg));
+			fr.setOrigin(FuncRequest::LYXSERVER);
+			DispatchResult dr;
+			theApp()->dispatch(fr, dr);
+			string const rval = to_utf8(dr.message());
 
 			// all commands produce an INFO or ERROR message
 			// in the output pipe, even if they do not return
 			// anything. See chapter 4 of Customization doc.
 			string buf;
-			if (func_->errorStat())
+			if (dr.error())
 				buf = "ERROR:";
 			else
 				buf = "INFO:";