robot.c

   1 /*
   2  * Netris -- A free networked version of T*tris
   3  * Copyright (C) 1994,1995,1996  Mark H. Weaver <mhw@netris.org>
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License
   7  * as published by the Free Software Foundation; either version 2
   8  * of the License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18  *
  19  * $Id: robot.c,v 1.8 1996/02/09 08:22:15 mhw Exp $
  20  */
  21
  22 #include "netris.h"
  23 #include <unistd.h>
  24 #include <stdlib.h>
  25 #include <ctype.h>
  26 #include <string.h>
  27 #include <stdarg.h>
  28 #include <sys/types.h>
  29 #include <fcntl.h>
  30 #include <errno.h>
  31
  32 static MyEventType RobotGenFunc(EventGenRec *gen, MyEvent *event);
  33
  34 static EventGenRec robotGen =
  35                 { NULL, 0, FT_read, -1, RobotGenFunc, EM_robot };
  36
  37 static int robotProcess;
  38 static FILE *toRobot;
  39 static int toRobotFd, fromRobotFd;
  40
  41 static char robotBuf[128];
  42 static int robotBufSize, robotBufMsg;
  43
  44 static int gotSigPipe;
  45
  46 ExtFunc void InitRobot(char *robotProg)
  47 {
  48         int to[2], from[2];
  49         int status;
  50         MyEvent event;
  51
  52         signal(SIGPIPE, CatchPipe);
  53         AtExit(CloseRobot);
  54         if (pipe(to) || pipe(from))
  55                 die("pipe");
  56         robotProcess = fork();
  57         if (robotProcess < 0)
  58                 die("fork");
  59         if (robotProcess == 0) {
  60                 dup2(to[0], STDIN_FILENO);
  61                 dup2(from[1], STDOUT_FILENO);
  62                 close(to[0]);
  63                 close(to[1]);
  64                 close(from[0]);
  65                 close(from[1]);
  66                 execl("/bin/sh", "sh", "-c", robotProg, NULL);
  67                 die("execl failed");
  68         }
  69         close(to[0]);
  70         close(from[1]);
  71         toRobotFd = to[1];
  72         robotGen.fd = fromRobotFd = from[0];
  73         if (!(toRobot = fdopen(toRobotFd, "w")))
  74                 die("fdopen");
  75         if ((status = fcntl(fromRobotFd, F_GETFL, 0)) < 0)
  76                 die("fcntl/F_GETFL");
  77         status |= O_NONBLOCK;
  78         if (fcntl(fromRobotFd, F_SETFL, status) < 0)
  79                 die("fcntl/F_SETFL");
  80         AddEventGen(&robotGen);
  81         RobotCmd(1, "Version %d\n", ROBOT_VERSION);
  82         if (WaitMyEvent(&event, EM_robot) != E_robot)
  83                 fatal("Robot didn't start successfully");
  84         if (1 > sscanf(event.u.robot.data, "Version %d", &robotVersion)
  85                         || robotVersion < 1)
  86                 fatal("Invalid Version line from robot");
  87         if (robotVersion > ROBOT_VERSION)
  88                 robotVersion = ROBOT_VERSION;
  89 }
  90
  91 ExtFunc void CatchPipe(int sig)
  92 {
  93         robotGen.ready = gotSigPipe = 1;
  94 }
  95
  96 ExtFunc void RobotCmd(int flush, char *fmt, ...)
  97 {
  98         va_list args;
  99
 100         va_start(args, fmt);
 101         vfprintf(toRobot, fmt, args);
 102         va_end(args);
 103         if (flush)
 104                 fflush(toRobot);
 105 }
 106
 107 ExtFunc void RobotTimeStamp(void)
 108 {
 109         RobotCmd(1, "TimeStamp %.3f\n", CurTimeval() / 1.0e6);
 110 }
 111
 112 ExtFunc void CloseRobot(void)
 113 {
 114         RemoveEventGen(&robotGen);
 115         if (robotProcess > 0)
 116                 RobotCmd(1, "Exit\n");
 117         fclose(toRobot);
 118         close(fromRobotFd);
 119 }
 120
 121 static MyEventType RobotGenFunc(EventGenRec *gen, MyEvent *event)
 122 {
 123         static int more;
 124         int result, i;
 125         char *p;
 126
 127         if (gotSigPipe) {
 128                 gotSigPipe = 0;
 129                 robotGen.ready = more;
 130                 return E_lostRobot;
 131         }
 132         if (robotBufMsg > 0) {
 133                 /*
 134                  *      Grrrrrr!  SunOS 4.1 doesn't have memmove (or atexit)
 135                  *  I'm told some others have a broken memmove
 136                  *
 137                  *      memmove(robotBuf, robotBuf + robotBufMsg,
 138                  *                      robotBufSize - robotBufMsg);
 139                  */
 140                 for (i = robotBufMsg; i < robotBufSize; ++i)
 141                         robotBuf[i - robotBufMsg] = robotBuf[i];
 142
 143                 robotBufSize -= robotBufMsg;
 144                 robotBufMsg = 0;
 145         }
 146         if (more)
 147                 more = 0;
 148         else {
 149                 do {
 150                         result = read(fromRobotFd, robotBuf + robotBufSize,
 151                                         sizeof(robotBuf) - robotBufSize);
 152                 } while (result < 0 && errno == EINTR);
 153                 if (result <= 0)
 154                         return E_lostRobot;
 155                 robotBufSize += result;
 156         }
 157         if (!(p = memchr(robotBuf, '\n', robotBufSize))) {
 158                 if (robotBufSize >= sizeof(robotBuf))
 159                         fatal("Line from robot is too long");
 160                 return E_none;
 161         }
 162         *p = 0;
 163         robotBufMsg = p - robotBuf + 1;
 164         robotGen.ready = more = (memchr(robotBuf + robotBufMsg, '\n',
 165                         robotBufSize - robotBufMsg) != NULL);
 166         event->u.robot.size = p - robotBuf;
 167         event->u.robot.data = robotBuf;
 168         return E_robot;
 169 }
 170
 171 /*
 172  * vi: ts=4 ai
 173  * vim: noai si
 174  */