Subversion Repositories w11

// $Id: RtclSystem.cpp 521 2013-05-20 22:16:45Z mueller $
//
// Copyright 2013- by Walter F.J. Mueller <W.F.J.Mueller@gsi.de>
//
// This program is free software; you may redistribute and/or modify it under
// the terms of the GNU General Public License as published by the Free
// Software Foundation, either version 2, or at your option any later version.
//
// This program is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY, without even the implied warranty of MERCHANTABILITY
// or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
// for complete details.
// 
// Revision History: 
// Date         Rev Version  Comment
// 2013-05-17   521   1.0    Initial version
// ---------------------------------------------------------------------------
 
/*!
  \file
  \version $Id: RtclSystem.cpp 521 2013-05-20 22:16:45Z mueller $
  \brief   Implemenation of RtclSystem.
*/
 
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
 
#include <iostream>
#include <string>
#include <algorithm>
 
#include "librtools/RerrMsg.hpp"
#include "librtcltools/RtclArgs.hpp"
 
#include "RtclSignalAction.hpp"
 
#include "RtclSystem.hpp"
 
using namespace std;
 
/*!
  \class Retro::RtclSystem
  \brief FIXME_docs
*/
 
// all method definitions in namespace Retro
namespace Retro {
 
static const int kOK  = TCL_OK;
static const int kERR = TCL_ERROR;
 
//------------------------------------------+-----------------------------------
//! FIXME_docs
 
void RtclSystem::CreateCmds(Tcl_Interp* interp)
{
  Tcl_CreateObjCommand(interp, "rutil::isatty", Isatty, 
                       (ClientData) 0, NULL);
  Tcl_CreateObjCommand(interp, "rutil::sigaction", SignalAction, 
                       (ClientData) 0, NULL);
  Tcl_CreateObjCommand(interp, "rutil::waitpid", WaitPid, 
                       (ClientData) 0, NULL);
  return;
}
 
//------------------------------------------+-----------------------------------
//! FIXME_docs
 
int RtclSystem::Isatty(ClientData cdata, Tcl_Interp* interp, 
                       int objc, Tcl_Obj* const objv[])
{
  RtclArgs args(interp, objc, objv);
  string file = "stdin";
  if (!args.GetArg("?file", file)) return kERR;
  if (!args.AllDone()) return kERR;
 
  transform(file.begin(), file.end(), file.begin(), ::tolower);
  int fileno = -1;
  if (file == "stdin")  fileno = STDIN_FILENO;
  if (file == "stdout") fileno = STDOUT_FILENO;
  if (file == "stderr") fileno = STDERR_FILENO;
  if (fileno == -1) return args.Quit("file must be stdin, stdout, or stderr");
 
  args.SetResult(bool(::isatty(fileno)));
 
  return kOK;
}
 
//------------------------------------------+-----------------------------------
 
static int signam2num(const std::string& signam)
{
  string sn = signam;
  transform(sn.begin(), sn.end(), sn.begin(), ::toupper);
  if (sn == "SIGHUP")  return SIGHUP;
  if (sn == "SIGINT")  return SIGINT;
  if (sn == "SIGTERM") return SIGTERM;
  if (sn == "SIGUSR1") return SIGUSR1;
  if (sn == "SIGUSR2") return SIGUSR2;
  return -1;
}
 
static const char* signum2nam(int signum)
{
  if (signum == SIGHUP)  return "SIGHUP";
  if (signum == SIGINT)  return "SIGINT";
  if (signum == SIGTERM) return "SIGTERM";
  if (signum == SIGUSR1) return "SIGUSR1";
  if (signum == SIGUSR2) return "SIGUSR2";
  return "???";
}
 
//------------------------------------------+-----------------------------------
//! FIXME_docs
 
int RtclSystem::SignalAction(ClientData cdata, Tcl_Interp* interp, 
                             int objc, Tcl_Obj* const objv[])
{
  RtclArgs args(interp, objc, objv);
  RerrMsg emsg;
 
  // check if initialized, if not, do it
  if (!RtclSignalAction::Obj()) {
    RerrMsg emsg;
    if (!RtclSignalAction::Init(interp, emsg)) return args.Quit(emsg);
  }
  RtclSignalAction* pact = RtclSignalAction::Obj();
 
  // blank 'sigaction' is a noop (initialize as side effect)
  if (objc == 1) return kOK;  
 
  // handle cases with only options (no signal name first)
 
  if (args.PeekArgString(0)[0] == '-') {
    static RtclNameSet optset("-init|-info");
    string opt;
    if (args.NextOpt(opt, optset)) {
 
      if        (opt == "-init") {          // -init
        if (!args.AllDone()) return kERR;
        return kOK;
 
      } else if (opt == "-info") {          // -info
        RtclOPtr pres(Tcl_NewListObj(0,0));
        int siglist[] = {SIGHUP,SIGINT,SIGTERM,SIGUSR1,SIGUSR2};
        for (size_t i=0; i<sizeof(siglist)/sizeof(int); i++) {
          Tcl_Obj* pobj;
          if (pact->GetAction(siglist[i], pobj, emsg)) {
            RtclOPtr pele(Tcl_NewListObj(0,0));
            Tcl_ListObjAppendElement(NULL, pele, 
                     Tcl_NewStringObj(signum2nam(siglist[i]),-1));
            if (pobj) {
              Tcl_ListObjAppendElement(NULL, pele, pobj);
            } else {
              Tcl_ListObjAppendElement(NULL, pele, Tcl_NewStringObj("{}",-1));
            }
            Tcl_ListObjAppendElement(NULL, pres, pele);
          }
        }
        args.SetResult(pres);
        return kOK;
      }
    }
    if (!args.OptValid()) return kERR;
    if (!args.AllDone()) return kERR;
    return kERR;
  }
 
  // handle cases which start with a signal name
 
  string signam;
  if (!args.GetArg("signam", signam)) return kERR;
  int signum = signam2num(signam);
  if (signum < 0) return args.Quit("invalid signal name");
 
  static RtclNameSet optset("-action|-revert");
  string opt;
  if (args.NextOpt(opt, optset)) {
    if        (opt == "-action") {          // signam -action script
      string script;
      if (!args.GetArg("script", script)) return kERR;
      if (!args.AllDone()) return kERR;
      RtclOPtr pobj(Tcl_NewStringObj(script.c_str(), -1));
      if (!pact->SetAction(signum, pobj, emsg)) 
        return args.Quit(emsg);
 
    } else if (opt == "-revert") {          // signam -revert
      if (!args.AllDone()) return kERR;
      if (!pact->ClearAction(signum, emsg)) 
        return args.Quit(emsg);
    }
 
  } else {                                  // signam
    if (!args.OptValid()) return kERR;
    if (!args.AllDone()) return kERR;
    Tcl_Obj* pobj;
    if (!pact->GetAction(signum, pobj, emsg))
      return args.Quit("no handler defined");
    if (pobj == 0) pobj = Tcl_NewStringObj("{}",-1);
    args.SetResult(pobj);
  }
 
  return kOK;
}
 
//------------------------------------------+-----------------------------------
//! FIXME_docs
 
int RtclSystem::WaitPid(ClientData cdata, Tcl_Interp* interp, 
                        int objc, Tcl_Obj* const objv[])
{
  RtclArgs args(interp, objc, objv);
  int pid;
  if (!args.GetArg("pid", pid)) return kERR;
  if (!args.AllDone()) return kERR;
 
  int status;
  int irc = ::waitpid(pid, &status, WNOHANG);
  if (irc < 0) {
    RerrMsg emsg("RtclSystem::WaitPid", "waitpid() failed: ", errno);
    return args.Quit(emsg);  
  }
  args.SetResult(status);
  return kOK;
}
 
 
} // end namespace Retro