Quiet annoying mutex debug logging messages

[clinton/bobotpp.git] / source / ScriptCommands.C

// ScriptCommands.C  -*- C++ -*-
// Copyright (c) 1998 Etienne BERNARD
// Copyright (C) 2002,2005,2008,2009 Clinton Ebadi

// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// 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 more details.

// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
// 02110-1301, USA.

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#ifdef USESCRIPTS

#include "ScriptCommands.H"

#include <libguile.h>

#include "Bot.H"
#include "BotInterp.H"
#include "ChannelList.H"
#include "Commands.H"
#include "DCCManager.H"
#include "DCCPerson.H"
#include "Interp.H"
#include "Message.H"
#include "Parser.H"
#include "Server.H"
#include "ServerConnection.H"
#include "ServerList.H"
#include "ServerQueue.H"
#include "User.H"
#include "Utils.H"

#define VERIFY_STRING(par) if (!scm_is_string((par))) \
                             return scm_from_int(-17)

#define VERIFY_NUMBER(par) if (!SCM_NUMBERP((par))) \
                             return scm_from_int(-17)

SCM
ScriptCommands::Action(SCM channel, SCM message)
{
  VERIFY_STRING(channel);
  VERIFY_STRING(message);
  Message m = Commands::Action(Interp::bot, Utils::scm2str(channel),
                               Utils::scm2str(message));
  return scm_from_int(m.getCode());
}

SCM
ScriptCommands::AddUser(SCM who, SCM maskChannel, SCM level, 
			SCM prot, SCM aop, SCM expire, SCM password)
{
  // It segfaults when not online, but otherwise appears to work
  VERIFY_STRING (who);
  VERIFY_STRING (maskChannel);
  VERIFY_NUMBER (level);

  String wwho = Utils::scm2str (who);
  String mask = Utils::scm2str (maskChannel);
  String passwd; 
  std::time_t eexpire;

  if (SCM_UNBNDP (password))
    passwd = "";
  else
    {
      VERIFY_STRING (password);
      passwd = Utils::scm2str (password);
    }
  if (SCM_UNBNDP (expire))
    eexpire = -1;
  else
    {
      VERIFY_STRING (expire);
      eexpire = Utils::str2time (Utils::scm2str (expire));
      if (!eexpire) eexpire = -1;
    }

  int protect = scm_to_int (prot);
  bool aaop = scm_is_true (aop);
  int llevel = scm_to_int (level);

  Message m = Commands::AddUser (Interp::bot, wwho, mask, llevel, 
				 protect, aaop, eexpire, passwd);

  return scm_from_int(m.getCode ());
}

SCM
ScriptCommands::AddServer(SCM servername, SCM port)
{
  int p = 6667;
  if (SCM_NUMBERP(port))
    p = scm_to_int (port);
  Message m = Commands::AddServer(Interp::bot,
                                  Utils::scm2str(servername),
                                  p);
  return scm_from_int(m.getCode());
}

SCM
ScriptCommands::AddShit(SCM mask, SCM maskChannel, SCM level, 
			SCM expiration, SCM reason)
{
  // This appears to work...not much testing though
  VERIFY_STRING (mask);
  VERIFY_STRING (maskChannel);
  VERIFY_NUMBER (level);
  String mmask = Utils::scm2str (mask);
  String mmaskChannel = Utils::scm2str (maskChannel);
  int llevel = scm_to_int (level);
  std::time_t expire;
  String rreason;

  if (SCM_UNBNDP (expiration))
    expire = -1;
  else
    {
      VERIFY_STRING (expiration);
      expire = Utils::str2time (Utils::scm2str (expiration));
      if (!expire) expire = -1;
    }
  if (SCM_UNBNDP (reason))
    rreason = "You're on my shitlist, lamer";
  else
    {
      VERIFY_STRING (reason);
      rreason = Utils::scm2str (reason);
    }
  Message m = Commands::AddShit (Interp::bot, mmask, mmaskChannel,
				 llevel, expire, rreason);

  return scm_from_int(m.getCode ());
}

SCM
ScriptCommands::Ban(SCM channel, SCM who)
{
  VERIFY_STRING(channel);
  VERIFY_STRING(who);
  Message m = Commands::Ban(Interp::bot, Utils::scm2str(channel),
                            Utils::scm2str(who));
  return scm_from_int(m.getCode());
}

SCM
ScriptCommands::ChangeCommandLevel(SCM command, SCM level)
{
  VERIFY_STRING (command);
  VERIFY_NUMBER (level);

  std::string ccommand = scm_to_locale_string (command);
  unsigned int llevel = scm_to_uint (level);

  if (llevel > 4)
    return SCM_BOOL_F;

  std::map<std::string, class userFunction*, 
    std::less<std::string> >::const_iterator  uf_iter 
    = Interp::bot->userFunctions.find (ccommand);
  userFunction * f = 0;
  
  if (uf_iter != Interp::bot->userFunctions.end ())
    f = uf_iter->second;
  else
    return SCM_BOOL_F;

  f->minLevel = llevel;
  return SCM_BOOL_T;
}


void
ScriptCommands::collect_channel_users::operator() (SCM *list, User user)
  const
{
  *list = scm_cons (scm_list_n (Utils::str2scm (user.get_nick()),
				Utils::str2scm (user.get_userhost ()),
				scm_from_int (user.get_mode ()),
				SCM_UNDEFINED),
		    *list);
}

SCM
ScriptCommands::ChannelUsers (SCM channel_name)
{
  VERIFY_STRING (channel_name);

  Channel *channel = Interp::bot->channelList->getChannel (Utils::scm2str (channel_name));

  if (!channel)
    return SCM_BOOL_F;

  SCM* list = (SCM*)scm_gc_malloc (sizeof (SCM), "ScriptCommands::ChannelUsers");
  *list = SCM_EOL;

  collect_channel_users c;
  
  channel->for_each_channel_users (std::bind1st (c, list));
						 
  scm_remember_upto_here_1 (list);
  return scm_reverse_x (*list, SCM_UNDEFINED);
}

SCM
ScriptCommands::CTCP(SCM to, SCM command , SCM message)
{
  VERIFY_STRING(to);
  VERIFY_STRING(command);
  VERIFY_STRING(message);

  Commands::CTCP (Interp::bot, Utils::scm2str (to), 
		      Utils::scm2str (command),
		      Utils::scm2str (message));

  return SCM_UNSPECIFIED;
}

SCM
ScriptCommands::CTCPReply (SCM to, SCM command , SCM message)
{
  VERIFY_STRING(to);
  VERIFY_STRING(command);
  VERIFY_STRING(message);

  Commands::CTCPReply (Interp::bot, Utils::scm2str (to), 
		       Utils::scm2str (command),
		       Utils::scm2str (message));

  return SCM_UNSPECIFIED;
}

SCM
ScriptCommands::Cycle(SCM channel)
{
  VERIFY_STRING(channel);
  Message m = Commands::Cycle(Interp::bot, Utils::scm2str(channel));
  return scm_from_int(m.getCode());
}

SCM
ScriptCommands::Deban(SCM channel, SCM who)
{
  VERIFY_STRING(channel);
  VERIFY_STRING(who);
  Message m = Commands::Deban(Interp::bot, Utils::scm2str(channel),
                              Utils::scm2str(who));
  return scm_from_int(m.getCode());
}

SCM
ScriptCommands::DelServer(SCM number)
{
  VERIFY_NUMBER(number);
  Message m = Commands::DelServer(Interp::bot, scm_to_int (number));
  return scm_from_int(m.getCode());
}

SCM
ScriptCommands::DelUser(SCM who, SCM maskChannel)
{
  VERIFY_STRING(who);
  VERIFY_STRING(maskChannel);
  Message m = Commands::DelUser(Interp::bot, Utils::scm2str(who),
                                Utils::scm2str(maskChannel));
  return scm_from_int(m.getCode());
}

SCM
ScriptCommands::DelShit(SCM who, SCM maskChannel)
{
  VERIFY_STRING(who);
  VERIFY_STRING(maskChannel);
  Message m = Commands::DelShit(Interp::bot, Utils::scm2str(who),
                                Utils::scm2str(maskChannel));
  return scm_from_int(m.getCode());
}

SCM
ScriptCommands::Deop(SCM channel, SCM who)
{
  VERIFY_STRING(channel);
  VERIFY_STRING(who);
  Message m = Commands::Deop(Interp::bot, Utils::scm2str(channel),
                             Utils::scm2str(who));
  return scm_from_int(m.getCode());
}

SCM
ScriptCommands::Die(SCM reason)
{
  String r = "Leaving";
  if (scm_is_string(reason))
    r = Utils::scm2str(reason);
  Message m = Commands::Die(Interp::bot, r);
  return scm_from_int(m.getCode());
}

SCM
ScriptCommands::Do(SCM command)
{
  VERIFY_STRING(command);
  Message m = Commands::Do(Interp::bot, Utils::scm2str(command));
  return scm_from_int(m.getCode());
}

SCM
ScriptCommands::Invite(SCM channel, SCM who)
{
  VERIFY_STRING(channel);
  VERIFY_STRING(who);
  Message m = Commands::Invite(Interp::bot, Utils::scm2str(channel),
                               Utils::scm2str(who));
  return scm_from_int(m.getCode());
}

SCM
ScriptCommands::Join(SCM channel, SCM key)
{
  VERIFY_STRING(channel);
  String k = "";
  if (scm_is_string(key))
    k = Utils::scm2str(key);
  Message m = Commands::Join(Interp::bot, Utils::scm2str(channel),
                             k);
  return scm_from_int(m.getCode());
}

SCM
ScriptCommands::Keep(SCM channel, SCM modes)
{
  VERIFY_STRING(channel);
  VERIFY_STRING(modes);
  Message m = Commands::Keep(Interp::bot, Utils::scm2str(channel),
                             Utils::scm2str(modes));
  return scm_from_int(m.getCode());
}

SCM
ScriptCommands::Kick(SCM channel, SCM who, SCM reason)
{
  VERIFY_STRING(channel);
  VERIFY_STRING(who);

  String r = "";
  if (scm_is_string(reason))
    r = Utils::scm2str(reason);

  Message m = Commands::Kick(Interp::bot, Utils::scm2str(channel),
                             Utils::scm2str(who), r);
  return scm_from_int(m.getCode());
}

SCM
ScriptCommands::KickBan(SCM channel, SCM who, SCM reason)
{
  VERIFY_STRING(channel);
  VERIFY_STRING(who);
  String r = "";
  if (scm_is_string(reason))
    r = Utils::scm2str(reason);
  Message m = Commands::KickBan(Interp::bot, Utils::scm2str(channel),
                                Utils::scm2str(who), r);
  return scm_from_int(m.getCode());
}

SCM
ScriptCommands::Lock(SCM channel)
{
  VERIFY_STRING(channel);
  Message m = Commands::Lock(Interp::bot, Utils::scm2str(channel));
  return scm_from_int(m.getCode());
}

SCM
ScriptCommands::LogPort(void)
{
  return Interp::bot->botInterp->logPort;
}

SCM
ScriptCommands::Mode(SCM channel, SCM mode)
{
  VERIFY_STRING(channel);
  VERIFY_STRING(mode);
  Message m = Commands::Mode(Interp::bot, Utils::scm2str(channel),
                             Utils::scm2str(mode));
  return scm_from_int(m.getCode());
}

SCM
ScriptCommands::Msg(SCM nick, SCM message)
{
  VERIFY_STRING(nick);
  VERIFY_STRING(message);
  Message m = Commands::Msg(Interp::bot, Utils::scm2str(nick),
                            Utils::scm2str(message));
  return scm_from_int(m.getCode());

}

SCM
ScriptCommands::NextServer(void)
{
  Message m = Commands::NextServer(Interp::bot);
  return scm_from_int(m.getCode());
}

SCM
ScriptCommands::Nick(SCM nick)
{
  VERIFY_STRING(nick);
  Message m = Commands::Nick(Interp::bot, Utils::scm2str(nick));
  return scm_from_int(m.getCode());
}

SCM
ScriptCommands::Notice (SCM to, SCM message)
{
  VERIFY_STRING (to);
  VERIFY_STRING (message);

  return (scm_from_int 
	  (Commands::Notice (Interp::bot, 
			     Utils::scm2str (to),
			     Utils::scm2str (message)).getCode ()));
  
}

SCM
ScriptCommands::Op(SCM channel, SCM who)
{
  VERIFY_STRING(channel);
  VERIFY_STRING(who);
  Message m = Commands::Op(Interp::bot, Utils::scm2str(channel),
                           Utils::scm2str(who));
  return scm_from_int(m.getCode());
}

SCM
ScriptCommands::Part(SCM channel)
{
  VERIFY_STRING(channel);
  Message m = Commands::Part(Interp::bot, Utils::scm2str(channel));
  return scm_from_int(m.getCode());
}

SCM
ScriptCommands::Reconnect(void)
{
  Message m = Commands::Reconnect(Interp::bot);
  return scm_from_int(m.getCode());
}

SCM
ScriptCommands::Say(SCM channel, SCM message)
{
  VERIFY_STRING(channel);
  VERIFY_STRING(message);
  Message m = Commands::Say(Interp::bot, Utils::scm2str(channel),
                            Utils::scm2str(message));
  return scm_from_int(m.getCode());
}

SCM
ScriptCommands::Server(SCM number)
{
  VERIFY_NUMBER(number);
  Message m = Commands::Server(Interp::bot, scm_to_int(number));
  return scm_from_int(m.getCode());
}

SCM
ScriptCommands::SetFloodRate(SCM rate)
{
  VERIFY_NUMBER(rate);
  Message m = Commands::SetFloodRate(Interp::bot, scm_to_uint (rate));
  return scm_from_int(m.getCode());
}

SCM
ScriptCommands::SetVersion(SCM version)
{
  Message m = Commands::SetVersion(Interp::bot, Utils::scm2str(version));
  return scm_from_int(m.getCode());
}

SCM
ScriptCommands::TBan(SCM channel, SCM who, SCM seconds)
{
  VERIFY_STRING(channel);
  VERIFY_STRING(who);
  VERIFY_NUMBER(seconds);
  Message m = Commands::TBan(Interp::bot, Utils::scm2str(channel),
                             Utils::scm2str(who), scm_to_int(seconds));
  return scm_from_int(m.getCode());
}

SCM
ScriptCommands::TKBan(SCM channel, SCM who, SCM seconds, SCM reason)
{
  VERIFY_STRING(channel);
  VERIFY_STRING(who);
  VERIFY_NUMBER(seconds);
  String r = "";
  if (scm_is_string(reason))
    r = Utils::scm2str(reason);
  Message m = Commands::TKBan(Interp::bot, Utils::scm2str(channel),
                              Utils::scm2str(who),
                              scm_to_int(seconds), r);
  return scm_from_int(m.getCode());
}

SCM
ScriptCommands::Topic(SCM channel, SCM topic)
{
  VERIFY_STRING(channel);
  VERIFY_STRING(topic);
  Message m = Commands::Topic(Interp::bot, Utils::scm2str(channel),
                              Utils::scm2str(topic));
  return scm_from_int(m.getCode());
}

SCM
ScriptCommands::Unlock(SCM channel)
{
  VERIFY_STRING(channel);
  Message m = Commands::Unlock(Interp::bot, Utils::scm2str(channel));
  return scm_from_int(m.getCode());
}

SCM
ScriptCommands::Who (SCM target)
{
  VERIFY_STRING (target);

  Message m = Commands::Who (Interp::bot, Utils::scm2str (target));

  return scm_from_int (m.getCode ());
}

SCM
ScriptCommands::Whois (SCM nick)
{
  VERIFY_STRING (nick);

  Message m = Commands::Whois (Interp::bot, Utils::scm2str (nick));

  return scm_from_int (m.getCode ());
}

SCM
ScriptCommands::getNickname(void)
{
  return Utils::str2scm(Interp::bot->nickName);
}

SCM
ScriptCommands::getServer(void)
{
  ::Server *serv = Interp::bot->serverList->currentServer();
  int serverNumber = Interp::bot->serverList->currentNumber;

  return scm_list_n(scm_from_int(serverNumber),
                 Utils::str2scm(serv->getHostName()),
                 scm_from_int(serv->getPort()),
                 Utils::str2scm(serv->getPassword()),
                 SCM_UNDEFINED);
}

SCM
ScriptCommands::getServerList(void)
{
  SCM res = scm_list_n(SCM_UNDEFINED);
  ::Server *s;
  int i = 0;
  std::vector<class Server *>::iterator it = 
    Interp::bot->serverList->begin();

  for ( ; it != Interp::bot->serverList->end(); ++it) {
    s = (*it);
    res = 
      scm_append 
      (scm_list_2 (res,
		   scm_list_n(scm_list_n(scm_from_int(i++),
					 Utils::str2scm(s->getHostName()),
					 scm_from_int(s->getPort()),
					 Utils::str2scm(s->getPassword()),
					 SCM_UNDEFINED), SCM_UNDEFINED)));
       }
  return res;
}

SCM
ScriptCommands::flushQueue(void)
{
  if (!Interp::bot->serverConnection)
    return SCM_BOOL_F;
  Interp::bot->serverConnection->queue->flush();
  return SCM_BOOL_T;
}

SCM
ScriptCommands::flushPort(void)
{
  scm_flush(Interp::bot->botInterp->logPort);
  return SCM_BOOL_T;
}

SCM
ScriptCommands::random(SCM scm_max)
{
  int max = 0;
  //srand(time(NULL));
  if (SCM_NUMBERP(scm_max))
    max = scm_to_int(scm_max);
  return scm_from_int(max ? rand() % max : 0);
}

SCM
ScriptCommands::addCommand(SCM scm_commandName, SCM scm_function,
                           SCM scm_needsChannel, SCM scm_args,
                           SCM scm_minLevel)
{
  // We check that commandName is a string
  if (!scm_is_string(scm_commandName))
    return SCM_BOOL_F;

  // We check that the command does not exist
  String commandName = Utils::to_upper (Utils::scm2str(scm_commandName));
  if (Interp::bot->userFunctions[commandName])
    return SCM_BOOL_F;

  // Next we check that needsChannel is a boolean
  if (!scm_is_bool (scm_needsChannel))
    return SCM_BOOL_F;
  bool needsChannel = scm_to_bool(scm_needsChannel);

  // We check that minLevel is an integer and that it's
  // a valid level
  if (!SCM_NUMBERP(scm_minLevel))
    return SCM_BOOL_F;

  int minLevel = scm_to_int(scm_minLevel);
  if (minLevel < User::NONE || minLevel > User::MASTER)
    return SCM_BOOL_F;

  // We check that "scm_function" is a Scheme procedure
  if (!scm_is_true (scm_procedure_p(scm_function)))
    return SCM_BOOL_F;

  // We check that args is an integer and is between 0 and 20 (arbitrary limit)
  if (!SCM_NUMBERP(scm_args))
    return SCM_BOOL_F;

  int args = scm_to_int(scm_args);
  if (args < 0 || args > 20)
    return SCM_BOOL_F;

  // We add the command in the commands list
  Interp::bot->userFunctions[commandName] = 
    new userFunction(0, minLevel, needsChannel, args, scm_function);
  
  return SCM_BOOL_T;
}

SCM
ScriptCommands::delCommand(SCM scm_commandName)
{
  // We check that commandName is a string
  if (!scm_is_string(scm_commandName))
    return SCM_BOOL_F;

  // We check that the command does exist
  String commandName = Utils::to_upper (Utils::scm2str(scm_commandName));
  if (!Interp::bot->userFunctions[commandName])
    return SCM_BOOL_F;

  // We delete the command
  Interp::bot->userFunctions.erase(commandName);

  return SCM_BOOL_T;
}

SCM
ScriptCommands::AddHook(SCM type, SCM regex, SCM function, SCM pri, SCM fall,
			SCM name)
{
  int priority = 0;
  bool fallt = true; // does this hook fall through?
  String rname = "DEFAULT";

  if (!SCM_UNBNDP (pri))
    priority = scm_to_int (pri);
  if (!SCM_UNBNDP (fall))
    fallt = scm_is_true (fall);
  if (!SCM_UNBNDP (name))
    rname = Utils::scm2str (name);
  return scm_from_bool (Interp::bot->botInterp->AddHook(scm_to_int(type),
						   regex, function,
						   priority, fallt, rname));
}

SCM
ScriptCommands::AddTimer(SCM when, SCM function)
{
  return Interp::bot->botInterp->AddTimer(scm_to_int(when), function);
}

SCM
ScriptCommands::DelTimer(SCM timer)
{
  return scm_from_bool (Interp::bot->botInterp->DelTimer(timer));
}

SCM
ScriptCommands::sendDCCChatMessage (SCM to, SCM message)
{

  return scm_from_bool (Interp::bot->dccConnections->sendMessage 
		   (Utils::scm2str (to),
		    Utils::scm2str (message)));
}






#endif