home *** CD-ROM | disk | FTP | other *** search
/ Dream 52 / Amiga_Dream_52.iso / Linux / Divers / lyx-0.13.2.tar.gz / lyx-0.13.2.tar / lyx-0.13.2 / src / lyxserver.C < prev    next >
C/C++ Source or Header  |  1998-04-23  |  14KB  |  509 lines
  1. // -*- C++ -*-
  2. /* This file is part of
  3.  * ======================================================
  4. * 
  5. *           LyX, The Document Processor
  6. *        
  7. *           Copyright (C) 1995 Matthias Ettrich
  8. *           Copyright (C) 1995-1998 The LyX Team.
  9. *
  10. *======================================================*/
  11.  
  12. /**
  13.   Docu   : To use the lyxserver define the name of the pipe in your
  14.            lyxrc:
  15.            \serverpipe "/home/myhome/.lyxpipe"
  16.            Then use .lyxpipe.in and .lyxpipe.out to communicate to LyX.
  17.            Each message consists of a single line in ASCII. Input lines
  18.            (client -> LyX) have the following format:
  19.             "LYXCMD:<clientname>:<functionname>:<argument>"
  20.            Answers from LyX look like this:
  21.            "INFO:<clientname>:<functionname>:<data>"
  22.  [asierra970531] Or like this in case of error:
  23.            "ERROR:<clientname>:<functionname>:<error message>"
  24.            where <clientname> and <functionname> are just echoed.
  25.            If LyX notifies about a user defined extension key-sequence,
  26.            the line looks like this:
  27.            "NOTIFY:<key-sequence>"
  28.  [asierra970531] New server-only messages to implement a simple protocol
  29.            "LYXSRV:<clientname>:<protocol message>"
  30.            where <protocol message> can be "hello" or "bye". If hello is
  31.            received LyX will inform the client that it's listening its
  32.            messages, and 'bye' will inform that lyx is closing.
  33.  
  34.            See development/server_monitor.c for an example client.
  35.   Purpose: implement a client/server lib for LyX
  36. */
  37.  
  38. #include <config.h>
  39.  
  40. #include <string.h>
  41. #include <stdio.h>
  42. #include <sys/types.h>
  43. #include <sys/stat.h>
  44. #include <unistd.h>
  45. #include <fcntl.h>
  46. #include <errno.h>
  47. #include FORMS_H_LOCATION
  48.  
  49. #ifdef __GNUG__
  50. #pragma implementation
  51. #endif
  52.  
  53. #include "lyxserver.h"
  54. #include "lyxfunc.h"
  55. #include "lyx_main.h"
  56. #include "error.h"
  57.  
  58. #ifdef __EMX__
  59. #include <stdlib.h>
  60. #include <io.h>
  61. #define OS2EMX_PLAIN_CHAR
  62. #define INCL_DOSNMPIPES
  63. #define INCL_DOSERRORS
  64. #include <os2.h>
  65. #include "os2_errortable.h"
  66. #endif
  67.  
  68. //     $Id: lyxserver.C,v 1.1.1.1 1998/04/23 16:02:54 larsbj Exp $    
  69.  
  70. #if !defined(lint) && !defined(WITH_WARNINGS)
  71. static char vcid[] = "$Id: lyxserver.C,v 1.1.1.1 1998/04/23 16:02:54 larsbj Exp $";
  72. #endif /* lint */
  73.     
  74. /* === variables ========================================================= */
  75.  
  76. extern LyXAction lyxaction;
  77.  
  78. // LyXComm class
  79.  
  80.  // Open pipes
  81. void LyXComm::openConnection() {
  82.     lyxerr.debug("LyXComm: Opening connection", Error::LYXSERVER);
  83.        
  84.     // If we are up, that's an error
  85.     if (ready) {
  86.         lyxerr.print("LyXComm: Already connected");
  87.         return;
  88.     }
  89.     // We assume that we don't make it
  90.     ready = false;
  91.  
  92.     if (pipename.empty()) return;
  93.  
  94.     // --- prepare input pipe ---------------------------------------
  95.  
  96.     LString tmp = pipename + ".in";
  97.        
  98. #ifdef __EMX__
  99.     HPIPE fd;
  100.     APIRET rc;
  101.     int errnum;
  102.     // Try create one instance of named pipe with the mode O_RDONLY|O_NONBLOCK.
  103.     // The current emx implementation of access() won't work with pipes.
  104.     rc = DosCreateNPipe(tmp.c_str(), &fd, NP_ACCESS_INBOUND,
  105.         NP_NOWAIT|0x01, 0600, 0600, 0);
  106.     if (rc == ERROR_PIPE_BUSY) {
  107. #else
  108.     if (access(tmp.c_str(), F_OK) == 0) {
  109. #endif
  110.         lyxerr.print("LyXComm: Pipe " + tmp + " already exists.");
  111.         lyxerr.print("If no other LyX program is active, please delete"
  112.                  " the pipe by hand and try again.");
  113.         pipename = LString();
  114.         return;
  115.     }
  116. #ifndef __EMX__
  117.     if (mkfifo(tmp.c_str(), 0600) < 0) {
  118.         lyxerr.print("LyXComm: Could not create pipe " + tmp);
  119.         lyxerr.print(strerror(errno));
  120.         return;
  121.     };
  122.     infd = open(tmp.c_str(), O_RDONLY|O_NONBLOCK);
  123. #else
  124.     if (rc != NO_ERROR) {
  125.         errnum = TranslateOS2Error(rc);
  126.         lyxerr.print("LyXComm: Could not create pipe " + tmp);
  127.         lyxerr.print(strerror(errnum));
  128.         return;
  129.     };
  130.     // Listen to it.
  131.     rc = DosConnectNPipe(fd);
  132.     if (rc != NO_ERROR && rc != ERROR_PIPE_NOT_CONNECTED) {
  133.         errnum = TranslateOS2Error(rc);
  134.         lyxerr.print("LyXComm: Could not create pipe " + tmp);
  135.         lyxerr.print(strerror(errnum));
  136.         return;
  137.     };
  138.     // Imported handles can be used both with OS/2 APIs and emx library functions.
  139.     infd = _imphandle(fd);
  140. #endif
  141.     if (infd < 0) {
  142.         lyxerr.print("LyXComm: Could not open pipe " + tmp);
  143.         lyxerr.print(strerror(errno));
  144.         return;
  145.     }
  146.     fl_add_io_callback(infd, FL_READ, callback, (void*)this);
  147.  
  148.     // --- prepare output pipe ---------------------------------------
  149.  
  150.     tmp = pipename + ".out";
  151.        
  152. #ifndef __EMX__       
  153.     if (access(tmp.c_str(), F_OK) == 0) {
  154. #else
  155.     rc = DosCreateNPipe(tmp.c_str(), &fd, NP_ACCESS_DUPLEX,
  156.         NP_NOWAIT|0x01, 0600, 0600, 0);
  157.  
  158.     if (rc == ERROR_PIPE_BUSY) {
  159. #endif
  160.         lyxerr.print("LyXComm: Pipe " + tmp + " already exists.");
  161.         lyxerr.print("If no other LyX program is active, please delete"
  162.                  " the pipe by hand and try again.");
  163.         pipename = LString();
  164.         return;
  165.     }
  166. #ifndef __EMX__
  167.     if (mkfifo(tmp.c_str(), 0600) < 0) {
  168.         lyxerr.print("LyXComm: Could not create pipe " + tmp);
  169.         lyxerr.print(strerror(errno));
  170.         return;
  171.     };
  172.     if (access(tmp.c_str(), F_OK) != 0) {
  173.         lyxerr.print("LyXComm: Pipe " + tmp + " does not exist");
  174.         return;
  175.     }
  176.     outfd = open(tmp.c_str(), O_RDWR);
  177. #else
  178.     if (rc != NO_ERROR) {
  179.         errnum = TranslateOS2Error(rc);
  180.         lyxerr.print("LyXComm: Could not create pipe " + tmp);
  181.         lyxerr.print(strerror(errnum));
  182.         return;
  183.     }
  184.     rc = DosConnectNPipe(fd);
  185.     if (rc == ERROR_BAD_PIPE) {
  186.         lyxerr.print("LyXComm: Pipe " + tmp + " does not exist");
  187.         return;
  188.     }
  189.     if (rc != NO_ERROR && rc != ERROR_PIPE_NOT_CONNECTED) {
  190.         errnum = TranslateOS2Error(rc);
  191.         lyxerr.print("LyXComm: Could not create pipe " + tmp);
  192.         lyxerr.print(strerror(errnum));
  193.         return;
  194.     }
  195.     outfd = _imphandle(fd);
  196. #endif
  197.     if (outfd < 0) {
  198.         lyxerr.print("LyXComm: Could not open pipe " + tmp);
  199.         lyxerr.print(strerror(errno));
  200.         return;
  201.     }
  202.     if (fcntl(outfd, F_SETFL, O_NONBLOCK) < 0) {
  203.         lyxerr.print("LyXComm: Could not set flags on pipe " + tmp);
  204.         lyxerr.print(strerror(errno));
  205.         return;
  206.     };
  207.     // We made it!
  208.     ready = true;
  209.     lyxerr.debug("LyXComm: Connection established", Error::LYXSERVER);
  210. }
  211.  
  212. /// Close pipes
  213. void LyXComm::closeConnection() {
  214. #ifdef __EMX__
  215.     APIRET rc;
  216.     int errnum;
  217. #endif
  218.            lyxerr.debug("LyXComm: Closing connection", Error::LYXSERVER);
  219.  
  220.     if (pipename.empty()) {
  221.             return;
  222.     }
  223.  
  224.     if (!ready) {
  225.         lyxerr.print("LyXComm: Already disconnected");
  226.         return;
  227.     }
  228.  
  229.     if(infd > -1) {
  230.         fl_remove_io_callback(infd, FL_READ, callback);
  231.  
  232.         LString tmp = pipename + ".in";
  233. #ifdef __EMX__        // Notify the operating system.
  234.         rc = DosDisConnectNPipe(infd);
  235.         if (rc != NO_ERROR) {
  236.             errnum = TranslateOS2Error(rc);
  237.             lyxerr.print("LyXComm: Could not disconnect pipe " + tmp);
  238.             lyxerr.print(strerror(errnum));
  239.             return;
  240.         }
  241. #endif
  242.         if (close(infd) < 0) {
  243.             lyxerr.print("LyXComm: Could not close pipe " + tmp);
  244.             lyxerr.print(strerror(errno));
  245.         }
  246. #ifndef __EMX__        // OS/2 named pipes will be automatically removed.
  247.         if (unlink(tmp.c_str()) < 0){
  248.             lyxerr.print("LyXComm: Could not remove pipe " + tmp);
  249.             lyxerr.print(strerror(errno));
  250.         };
  251. #endif
  252.     }
  253.     if(outfd > -1) {
  254.         LString tmp = pipename + ".out";
  255. #ifdef __EMX__
  256.         rc = DosDisConnectNPipe(outfd);
  257.         if (rc != NO_ERROR) {
  258.             errnum = TranslateOS2Error(rc);
  259.             lyxerr.print("LyXComm: Could not disconnect pipe " + tmp);
  260.             lyxerr.print(strerror(errnum));
  261.             return;
  262.         }
  263. #endif
  264.         if (close(outfd) < 0) {
  265.             lyxerr.print("LyXComm: Could not close pipe " + tmp);
  266.             lyxerr.print(strerror(errno));
  267.         }
  268. #ifndef __EMX__
  269.         if (unlink(tmp.c_str()) < 0){
  270.             lyxerr.print("LyXComm: Could not remove pipe " + tmp);
  271.             lyxerr.print(strerror(errno));
  272.         };
  273. #endif
  274.     }
  275.     ready = false;
  276. }
  277.  
  278. // Receives messages and sends then to client
  279. void LyXComm::callback(int fd, void *v)
  280. {
  281.     LyXComm * c = (LyXComm *) v;
  282.  
  283.     // --- read everything -------------------------------------------
  284.  
  285.     if (lyxerr.debugging(Error::LYXSERVER)) {
  286.         lyxerr.print(LString("LyXComm: Receiving from fd ") + int(fd));
  287.     }
  288.  
  289.     LString string;
  290.     bool more = false;
  291.     int retries = 0;
  292.     do {
  293.         char s[100];
  294.         int res = read(fd, s, 99);
  295.         more = false;
  296.         if (res == -1) {
  297.             lyxerr.print(LString("LyXComm: Read error from pipe ") + int(fd));
  298.             lyxerr.print(strerror(errno));
  299.             if (errno == EAGAIN || errno == EINTR) {
  300.                 retries++;
  301.                 if (retries == 5) {
  302.                     lyxerr.print("LyXComm: Doesn't seem to help... Resetting connection.");
  303.                     c->closeConnection();
  304.                     c->openConnection();
  305.                     retries = 0;
  306.                     return;
  307.                 }
  308.                 more = true;
  309.                 lyxerr.print("LyXComm: Trying again");
  310.             } else
  311.                 return;
  312.         } else {
  313.             retries = 0;
  314.             s[res] = 0;
  315.             if (res==99) {
  316.                 more = true;
  317.             } else if (res==0) {
  318.                 lyxerr.debug("LyXComm: EOF received - resetting connection...",
  319.                          Error::LYXSERVER);
  320.                 c->closeConnection();
  321.                 c->openConnection();
  322.                 return;
  323.             }
  324.             string += s;
  325.         }
  326.     } while (more);
  327.  
  328.     string.strip('\n');
  329.     string.strip('\r');
  330.     if (string.empty()) {
  331.         lyxerr.print("LyXComm: Received empty request. Ignoring.");
  332.         return;
  333.     }
  334.  
  335.     if (lyxerr.debugging(Error::LYXSERVER)) {
  336.         lyxerr.print("LyXComm: Received '" + string + '\'');
  337.     }
  338.  
  339.     // And call client
  340.     c->clientcb(c->client, string);
  341. }
  342.  
  343. void LyXComm::send(LString const & msg) {
  344.     if (msg.empty()) {
  345.         lyxerr.print("LyXComm: Request to send empty string. Ignoring.");
  346.         return;
  347.     }
  348.  
  349.     if (lyxerr.debugging(Error::LYXSERVER)) {
  350.         lyxerr.print("LyXComm: Sending '" + msg + '\'');
  351.     }
  352.  
  353.     if (pipename.empty()) return;
  354.  
  355.     if (!ready) {
  356.         lyxerr.print("LyXComm: Pipes are closed. Could not send "+ msg);
  357.     } else if (write(outfd, msg.c_str(), msg.length()) < 0) {
  358.         lyxerr.print("LyXComm: Error sending message: " + msg);
  359.         lyxerr.print(strerror(errno));
  360.         lyxerr.print("LyXComm: Resetting connection");
  361.         closeConnection();
  362.         openConnection();
  363.     }
  364. #ifdef __EMX__
  365.     APIRET rc;
  366.     int errnum;
  367.     rc = DosResetBuffer(outfd);    // To avoid synchronization problems.
  368.     if (rc != NO_ERROR) {
  369.         errnum = TranslateOS2Error(rc);
  370.         lyxerr.print("LyXComm: Message could not be flushed: " +msg);
  371.         lyxerr.print(strerror(errnum));
  372.     }
  373. #endif
  374. }
  375.  
  376.  
  377. // LyXServer class
  378.  
  379. LyXServer::~LyXServer()
  380. {
  381.     // say goodbye to clients so they stop sending messages
  382.     if (clients > 0) pipes.send("LYXSRV:*:bye");
  383. }
  384.  
  385.  
  386. /* ---F+------------------------------------------------------------------ *\
  387.    Function  : ServerCallback
  388.     Called by : LyXComm
  389.     Purpose   : handle data gotten from communication
  390. \* ---F------------------------------------------------------------------- */
  391.  
  392. void LyXServer::callback(LyXServer * serv, LString const & msg)
  393. {
  394.     lyxerr.print("LyXServer: Received: '" + msg + '\'');
  395.  
  396.     char const *p = msg.c_str();
  397.  
  398.     // --- parse the string --------------------------------------------
  399.     //
  400.     //  Format: LYXCMD:<client>:<func>:<argstring>\n
  401.     //
  402.     bool server_only = false;
  403.     while(*p) {
  404.         // --- 1. check 'header' ---
  405.             if (strncmp(p, "LYXSRV:", 7)==0) {
  406.             server_only = true; 
  407.         } else if(0!=strncmp(p, "LYXCMD:", 7)) {
  408.             lyxerr.print("LyXServer: Unknown request");
  409.             return;
  410.         }
  411.         p += 7;
  412.         
  413.         // --- 2. for the moment ignore the client name ---
  414.         LString client;
  415.         while(*p && *p != ':')
  416.             client += char(*p++);
  417.         if(*p == ':') p++;
  418.         if(!*p) return;
  419.         
  420.         // --- 3. get function name ---
  421.         LString cmd;
  422.         while(*p && *p != ':')
  423.             cmd += char(*p++);
  424.         
  425.         // --- 4. parse the argument ---
  426.         LString arg;
  427.         if(!server_only && *p == ':' && *(++p)) {
  428.             while(*p && *p != '\n')
  429.                 arg += char(*p++);
  430.             if(*p) p++;
  431.         }
  432.  
  433.         lyxerr.debug("LyXServer: Client: '" + client + "' Command: '" + cmd + "' Argument: '" + arg + '\'', Error::LYXSERVER);
  434.         
  435.         // --- lookup and exec the command ------------------
  436.  
  437.         if (server_only) {
  438.             LString buf;
  439.             // return the greeting to inform the client that 
  440.             // we are listening.
  441.             if (cmd == "hello") {
  442.                 // One more client
  443.                 serv->clients++;
  444.                 buf = "LYXSRV:" + client + ":hello";
  445.                 lyxerr.print("LyXServer: Greeting " + client);
  446.                 serv->pipes.send(buf);
  447.             } else if (cmd == "bye") {
  448.                 // If clients==0 maybe we should reset the pipes
  449.                 // to prevent fake callbacks
  450.                 serv->clients--;
  451.                 lyxerr.print("LyXServer: Client " + client + " said goodbye");
  452.             } else {
  453.                 lyxerr.print("LyXServer: Undefined server command " + cmd + ".");
  454.             }
  455.             return;
  456.         }
  457.  
  458.         if (!cmd.empty()) {
  459.             // which lyxfunc should we let it connect to?
  460.             // The correct solution would be to have a
  461.             // specialized (non-gui) BufferView. But how do
  462.             // we do it now? Probably we should just let it
  463.             // connect to the lyxfunc in the single LyXView we
  464.             // support currently. (Lgb)
  465.  
  466.             int action = lyxaction.LookupFunc(cmd.c_str());
  467.             //int action = -1;
  468.             LString rval, buf;
  469.             
  470.             if (action>=0) {
  471.                 rval = serv->func->Dispatch(action, arg.c_str());
  472.             } else {
  473.                 rval = "Unknown command";
  474.             }
  475.  
  476.             if(!rval.empty()) {
  477.                     if (action<0 || serv->func->errorStat())
  478.                     buf = "ERROR:";
  479.                 else
  480.                     buf = "INFO:";
  481.                 buf += LString(client) + ":" + cmd + ":" + rval + "\n";
  482.                 serv->pipes.send(buf);
  483.                 // !!! we don't do any error checking -
  484.                 //  if the client won't listen, the
  485.                 //  message is lost and others too
  486.                 //  maybe; so the client should empty
  487.                 //  the outpipe before issuing a request.
  488.             }
  489.             // not found
  490.         }
  491.     }  /* while *p */
  492. }
  493.  
  494.  
  495. /* ---F+------------------------------------------------------------------ *\
  496.    Function  : LyxNotifyClient
  497.    Called by : WorkAreaKeyPress
  498.    Purpose   : send a notify messge to a client
  499.    Parameters: s - string to send
  500.    Returns   : nothing
  501.    \* ---F------------------------------------------------------------------- */
  502.  
  503. void LyXServer::notifyClient(LString const & s)
  504. {
  505.     LString buf = LString("NOTIFY:") + s + "\n";
  506.     pipes.send(buf);
  507. }
  508.  
  509.