Пример #1
0
static value ex(const string &s, size_t curr) {
  value ret, id;
  bool running = true;
  while (running) {
    vector<value> tok;
    for (;;) {
      const auto next = s.find_first_of("; \r\t\n[(", curr);
      const auto last = next == string::npos ? s.size() : next;
      const auto len = last-curr;
      const auto c = s[last];
      if (len!=0) tok.push_back(stov(s.substr(curr,len)));
      if (c == '(' || c == '[') {
        const auto v = expr(s, c, curr);
        tok.push_back(v.first);
        curr = v.second;
      } else if (c == ';' || c == '\n') {curr=last+1; break;}
      else if (c == '\0') {curr=last; running=false; break;}
      else curr=last+1;
    }

    if (tok.size() == 0) return btov(false);
    auto const it = unique<builtinmap>()->find(vtos(tok[0]));
    if (it!=unique<builtinmap>()->end()) // try to call a builtin
      ret = it->second(tok);
    else if (tok.size() == 1 && vtos(tok[0]) == s) return stov(s); // literals
    else { // function call
      scope frame;
      for (size_t i = 1; i < tok.size(); ++i) new_local(to_string(i-1),tok[i]);
      ret = ex(vtos(tok[0]));
    }
  }
  return ret;
}
Пример #2
0
void NexuizColorpickerString_configureNexuizColorpickerString(entity me, string theCvar, string theDefaultCvar)
{
	me.cvarName = theCvar;
	me.configureImage(me, me.image);
	if(cvar_string(theCvar) != "")
		me.prevcoords = color_hslimage(stov(cvar_string(theCvar)), me.imagemargin);
	else // use default
		me.prevcoords = color_hslimage(stov(cvar_string(theDefaultCvar)), me.imagemargin);
}
void XonoticCrosshairButton_draw(entity me)
{
	vector sz, rgb;
	float a;

	rgb = stov(cvar_string("crosshair_color"));
	a = cvar("crosshair_alpha");

	if(!me.checked && !me.focused && me.cvarValueFloat != -1)
	{
		a *= me.disabledAlpha;
		rgb = '1 1 1';
	}

	if(me.cvarValueFloat == -1) // update the preview if this is the preview button
	{
		if(me.src3)
			strunzone(me.src3);
		me.src3 = strzone(strcat("/gfx/crosshair", cvar_string("crosshair")));
		me.focused = 1;
		me.checked = 0;
	}

	SUPER(XonoticCrosshairButton).draw(me);

	sz = draw_PictureSize(me.src3);
	sz = globalToBoxSize(sz, draw_scale);
	if(me.cvarValueFloat == -1)
	{
		sz = (6 * '1 1 0' + sz * cvar("crosshair_size")) * 0.08; // (6 * '1 1 0' + ...) * 0.08 here to make visible size changes happen also at bigger sizes
		if(sz_x > 0.95)
			sz = sz * (0.95 / sz_x);
		if(sz_y > 0.95)
			sz = sz * (0.95 / sz_y);
	}
	else // show the crosshair picker at full size
		sz = '0.95 0.95 0';

	draw_Picture('0.5 0.5 0' - 0.5 * sz, me.src3, sz, rgb, a);
	if(cvar("crosshair_dot"))
    {
        if(cvar_string("crosshair_dot_color") != "0")
            rgb = stov(cvar_string("crosshair_dot_color"));
		draw_Picture('0.5 0.5 0' - 0.5 * sz * cvar("crosshair_dot_size"), me.src4, sz * cvar("crosshair_dot_size"), rgb, a * cvar("crosshair_dot_alpha"));
    }
}
Пример #4
0
static value loop_builtin(args arg) {
  value last;
  auto const n = int(vtod(get(arg,2)));
  for (int i = 0; i < n; ++i) {
    try {
      new_local(vtos(get(arg,1)), stov(to_string(i)));
      last = ex(vtos(get(arg,3)));
    } catch (bool b) { if (b) break; else continue; }
  }
  return last;
}
Пример #5
0
static pair<value,size_t> expr(const string &s, char c, size_t curr) {
  const char *match = c=='['?"[]@":"()";
  stringstream ss;
  size_t opened = 1, next = curr;
  while (opened) {
    if ((next = s.find_first_of(match,next+1)) == string::npos)
      throw boodew_exception(format("missing %c", c=='['?']':')'));
    if (c == '[' && s[next] == '@') {
      ss << s.substr(curr+1, next-curr-1);
      if (s[next+1] == '(') {
        const auto v = expr(s, '(', next+1);
        ss << vtos(v.first);
        if (s[v.second]!=']'||opened!=1) ss << s[v.second];
        curr = v.second;
        next = curr > 0 ? curr-1 : 0;
      } else
        do ss << s[curr = ++next]; while (s[next] == '@');
    } else
      opened += s[next] == c ? +1 : -1;
  }
  if (next>curr) ss << s.substr(curr+1, next-curr-1);
  return make_pair((c=='[' ? stov(ss.str()) : ex(ss.str())), next+1);
}
Пример #6
0
      last = ex(vtos(get(arg,3)));
    } catch (bool b) { if (b) break; else continue; }
  }
  return last;
}
static value if_builtin(args arg) {
  return vtob(get(arg,1)) ? ex(vtos(get(arg,2))):
    (arg.size()>3?ex(vtos(get(arg,3))):btov(false));
}
#define O(S)CMDL(#S,[](args arg){return dtov(vtod(get(arg,1)) S vtod(get(arg,2)));})
O(+) O(-) O(/) O(*)
#undef O
#define O(S)CMDL(#S,[](args arg){return btov(vtod(get(arg,1)) S vtod(get(arg,2)));})
O(==) O(!=) O(<) O(>) O(<=) O(>=)
#undef O
CMDL("int",[](args arg){return stov(to_string(int(vtod(get(arg,1)))));})
CMDL("var",[](args arg){return new_local(vtos(get(arg,1)),arg.size()<3?btov(false):get(arg,2));})
CMDL("#", [](args){return btov(false);})
CMDL("..", [](args arg){return stov(vtos(get(arg,1))+vtos(get(arg,2)));})
CMDL("echo", [](args arg){cout<<vtos(get(arg,1));return get(arg,1);})
CMDL("^", [](args arg){return get(arg,1);})
CMDL("return", [](args arg)->value {throw get(arg,1);})
CMDL("do", [](args arg){try {return ex(vtos(get(arg,1)));} catch (value v) {return v;}})
CMDL("break", [](args arg)->value {throw true;})
CMDL("continue", [](args arg)->value {throw false;})
CMDN("while", while_builtin)
CMDN("loop", loop_builtin)
CMDN("?", if_builtin)
CMDN("$", getvar)
pair<string,bool> exec(const string &s) {
  try {ex(s); return make_pair("",true);}
Пример #7
0
int main (int argc, char const *argv []) 

{
	extern char const *host_name;
	extern char const *domain_name;
	static char const *optv [] = 
	{
		"a:df:" 

#ifdef SYSLOGD_INETAF

		"hi:l:" 

#endif

		"m:no:p:" 

#ifdef SYSLOGD_INETAF

		"rs:" 

#endif

		"xvw:",
		"System Logging Daemon",
		"a s\tadd unix socket path s",
		"d\trun as daemon (background)",
		"f s\tuse configuration file s [" _PATH_SYSLOG_CONF "]",

#ifdef SYSLOGD_INETAF

		"h\tforward messages to other hosts",
		"i n\tadd inet socket on port n",
		"l s\tlist of hostnames separated by ':'",

#endif

		"m nn\tmark internal is nn[s|S|m|M|h|H]",
		"n\trun as normal program (foreground)",
		"o s\toutput file is s",
		"p s\tlocal log device path is s [" _PATH_SYSLOG "]",

#ifdef SYSLOGD_UNIXAF

		"r\treceive messages from other hosts",
		"s s\tdomain list is s",

#endif

		"v\tdisplay version and exit",
		"w n\twait n seconds for klogd to start",
		"x\tnot implemented",
		(char const *) (0)
	};

#ifdef SYSLOGD_INETAF

	struct servent *servent;
	struct sockaddr_in *sockaddr_inet;

#endif
#ifdef SYSLOGD_UNIXAF

	struct socket * socket;
	struct sockaddr_un *sockaddr_unix;

#endif

	struct hostent *hostent;
	char fqdn [HOSTNAME_MAX];
	time_t delay = SYSLOGD_DELAY_TIME;
	file_t fd;
	int c;
	chdir ("/");

/*--------------------------------------------------------------------*
 * point host_name and domain_name to constant strings; technically,
 * the fqdn is the name returned by gethostbyname when given the name 
 * returned by gethostname; store the fqdn then break it at the first  
 * '.', if present; 
 *--------------------------------------------------------------------*/

	gethostname (fqdn, sizeof (fqdn));
	if ((hostent = gethostbyname (fqdn)) != (struct hostent *) (0)) 
	{
		strncpy (fqdn, hostent->h_name, sizeof (fqdn));
	}
	strlwr (fqdn);
	for (host_name = domain_name = fqdn; *domain_name != (char) (0); domain_name++) 
	{
		if (*domain_name == '.') 
		{
			fqdn [domain_name++ - host_name] = (char) (0);
			break;
		}
	}

#ifdef SYSLOGD_INETAF

/*--------------------------------------------------------------------*
 * confirm that the service is registered; the name is "syslog", the 
 * type is "udp" and it should appear in "/etc/services"; record the
 * port number in struct sockaddr_in for global reference;
 *--------------------------------------------------------------------*/

	servent = getservbyname (SYSLOGD_SERVICE_NAME, SYSLOGD_SERVICE_TYPE);
	if (servent == (struct servent *) (0)) 
	{
		error (1, ENOTSUP, "The %s %s service is not registered on %s", SYSLOGD_SERVICE_NAME, SYSLOGD_SERVICE_TYPE, host_name);
	}
	if (servent != (struct servent *) (0)) 
	{
		inetsock_addr.sin_port = servent->s_port;
	}

#endif

	optind = 1;
	opterr = 1;
	while ((c = getoptv (argc, argv, optv)) != -1) 
	{
		switch ((char) (c)) 
		{

#ifdef SYSLOGD_UNIXAF

/*--------------------------------------------------------------------*
 * create additional unix socket with specified pathname and append 
 * it to the sockets list; 
 *--------------------------------------------------------------------*/

		case 'a':
			sockaddr_unix = NEW (struct sockaddr_un);
			if (sockaddr_unix == (struct sockaddr_un *)(0)) 
			{
				break;
			}
			memset (sockaddr_unix, 0, sizeof (struct sockaddr_un));
			sockaddr_unix->sun_family = AF_UNIX;
			memcpy (&sockaddr_unix->sun_path, optarg, sizeof (sockaddr_unix->sun_path));
			socket = NEW (struct socket);
			if (socket == (struct socket *)(0)) 
			{
				error (0, errno, "Can't add socket %s", optarg);
				free (sockaddr_unix);
				break;
			}
			memset (socket, 0, sizeof (struct socket));
			socket->desc = -1;
			socket->socksize = sizeof (struct sockaddr_un);
			socket->sockaddr = (struct sockaddr *)(sockaddr_unix);
			socket->next = &unixsock;
			socket->prev = unixsock.prev;
			unixsock.prev->next = socket;
			unixsock.prev = socket;
			break;

#endif
#ifdef SYSLOGD_INETAF

		case 'i':
			sockaddr_inet = NEW (struct sockaddr_in);
			if (sockaddr_inet == (struct sockaddr_in *)(0)) 
			{
				break;
			}
			sockaddr_inet->sin_family = AF_INET;
			sockaddr_inet->sin_port = (unsigned short)(uintspec (optarg, IPPORT_RESERVED, IPPORT_USERRESERVED));
			socket = NEW (struct socket);
			if (socket == (struct socket *)(0)) 
			{
				error (0, errno, "Can't add socket %s", optarg);
				free (sockaddr_inet);
				break;
			}
			memset (socket, 0, sizeof (struct socket));
			socket->desc = -1;
			socket->socksize = sizeof (struct sockaddr_in);
			socket->sockaddr = (struct sockaddr *)(sockaddr_inet);
			socket->next = &inetsock;
			socket->prev = inetsock.prev;
			inetsock.prev->next = socket;
			inetsock.prev = socket;
			break;

#endif

		case 'd':
			_setbits (state, SYSLOGD_STATE_DAEMON);
			break;
		case 'f':
			cfgfile = optarg;
			break;

#ifdef SYSLOGD_INETAF

		case 'h':
			_setbits (state, SYSLOGD_STATE_FORWARD);
			break;

#endif
#ifdef SYSLOGD_INETAF

		case 'l':
			if (ourhosts != (char const **) (0)) 
			{
				error (0, EINVAL, "discarding '%s': only one host list allowed", optarg);
				break;
			}
			ourhosts = stov (optarg, ':');
			break;

#endif

		case 'm':
			timer = waitspec (optarg);
			break;
		case 'n':
			_clrbits (state, SYSLOGD_STATE_DAEMON);
			break;
		case 'o':
			mapfile = optarg;
			break;

#ifdef SYSLOGD_UNIXAF

		case 'p':
			strncpy (unixsock_addr.sun_path, optarg, sizeof (unixsock_addr.sun_path));
			break;

#endif
#ifdef SYSLOGD_INETAF

		case 'r':
			_setbits (state, SYSLOGD_STATE_RECEIVE);
			break;

#endif
#ifdef SYSLOGD_INETAF

		case 's':
			if (ourdomains != (char const **) (0)) 
			{
				error (0, 0, "ignoring '%s': only one -s argument allowed", optarg);
				break;
			}
			ourdomains = stov (optarg, ':');
			break;

#endif

		case 't':
			delay = uintspec (optarg, 0, 3600);
			break;
		case 'v':
			version ();
			exit (0);
		case 'w':
			delay = waitspec (optarg);
			break;
		case 'x':
			break;
		default:
			break;
		}
	}
	argc -= optind;
	argv += optind;
	if (getuid ()) 
	{
		error (1, EACCES, NOTROOT);
	}
	if (checkpf (pidfile)) 
	{
		error (1, 0, "service is already running");
	}

#ifdef SYSLOGD_INETAF

	if (_allset (state, (SYSLOGD_STATE_RECEIVE|SYSLOGD_STATE_FORWARD))) 
	{
		error (1, EPERM, "Can't receive and forward messages in same session");
	}

#endif

	memset (&sigquit, 0, sizeof (struct sigaction));
	sigquit.sa_handler = syslogd_sigquit;
	sigquit.sa_flags = SA_ONESHOT;
	sigemptyset (&sigquit.sa_mask);
	memset (&sigterm, 0, sizeof (struct sigaction));
	sigterm.sa_handler = syslogd_sigterm;
	sigterm.sa_flags = SA_ONESHOT;
	sigemptyset (&sigterm.sa_mask);
	memset (&sigchld, 0, sizeof (struct sigaction));
	sigchld.sa_handler = syslogd_sigchld;
	sigchld.sa_flags = 0;
	sigemptyset (&sigchld.sa_mask);
	memset (&sigalrm, 0, sizeof (struct sigaction));
	sigalrm.sa_handler = syslogd_sigalrm;
	sigalrm.sa_flags = 0;
	sigemptyset (&sigalrm.sa_mask);
	memset (&sigusr1, 0, sizeof (struct sigaction));
	sigusr1.sa_handler = syslogd_sigusr1;
	sigusr1.sa_flags = 0;
	sigemptyset (&sigusr1.sa_mask);
	memset (&sighup, 0, sizeof (struct sigaction));
	sighup.sa_handler = syslogd_sighup;
	sighup.sa_flags = 0;
	sigemptyset (&sighup.sa_mask);
	sigaction (SIGINT, &sigquit, (struct sigaction *) (0));
	sigaction (SIGTERM, &sigquit, (struct sigaction *) (0));
	sigaction (SIGQUIT, &sigquit, (struct sigaction *) (0));
	if (_allset (state, SYSLOGD_STATE_DAEMON)) 
	{
		if (fork ()) 
		{
			sleep (delay);
			error (1, 0, "daemon did not start");
		}
		setsid ();
		for (fd = getdtablesize (); fd-- > 0; close (fd));
		kill (getppid (), SIGTERM);
		sigquit.sa_handler = SIG_IGN;
	}
	sigaction (SIGTERM, &sigterm, (struct sigaction *) (0));
	sigaction (SIGCHLD, &sigchld, (struct sigaction *) (0));
	sigaction (SIGALRM, &sigalrm, (struct sigaction *) (0));
	sigaction (SIGHUP, &sighup, (struct sigaction *) (0));
	setlinebuf (stdout);
	if (!writepf (pidfile)) 
	{
		error (1, errno, "can't create pidfile %s", pidfile);
	}

#ifdef SYSLOGD_INETAF

/*--------------------------------------------------------------------*
 * the next two checks require some double-think; the forward and 
 * receive flags cannot occur together because that is eliminated
 * above; thus only one or the other or neither flag is set here;
 *
 * we disable receiving and forwarding at the same time to avoid 
 * accidental message loops; this means that each syslog host is
 * either a divinity (source) or a black hole (sink);
 *
 * when forwardng messages we do not add inet sockets to the socket 
 * list but we use the first inet socket (inetsock) as the template 
 * for host-type syslogs; consequently, we allocate the descriptor  
 * calling syslogd_parse() where it is used in * that way;
 *
 * when receiving messages then we add inet sockets to the socket 
 * list and let syslogd_open_sockets() allocate their descriptors
 *  since syslog_parse() does not use inetsock in receive mode; 
 *--------------------------------------------------------------------*/

	if (_anyset (state, SYSLOGD_STATE_RECEIVE)) 
	{
		socket = unixsock.next;
		unixsock.next = inetsock.next;
		inetsock.next = socket;
		socket = unixsock.prev;
		unixsock.prev = inetsock.prev;
		inetsock.prev = socket;
	}
	if (_anyset (state, SYSLOGD_STATE_FORWARD)) 
	{
		inetsock.desc = syslogd_inet_socket ((struct sockaddr_in *)(inetsock.sockaddr));
		if (inetsock.desc == -1) 
		{
			error (1, errno, "Can't start %s %s service", SYSLOGD_SERVICE_NAME, SYSLOGD_SERVICE_TYPE);
		}
	}

#endif

/*--------------------------------------------------------------------*
 * start mark message timer so that it activates on even multiples of
 * clock time relative to minute 0; timer must be an integral divisor
 * of 3600 and greater than 60 for this to work as intended; function
 * waitspec() filters input to ensure this;
 *--------------------------------------------------------------------*/

	if (timer) 
	{
		time_t clock = time (&clock);
		alarm (timer - clock%timer);
	}

/*--------------------------------------------------------------------*
 * read configuration, create syslogs and open them; write the syslog
 * map file, if enabled and requested; open sockets; read messages and
 * dispatch them until terminated; close sockets then close syslogs;
 *--------------------------------------------------------------------*/

	syslogd_start (&syslogs, state, cfgfile);

#ifdef SYSLOGD_REPORT

	syslogd_admin (&syslogs, state, mapfile);

#endif

	syslogd_open_sockets (&unixsock);
	while (loop) 
	{
		syslogd_read_sockets (&unixsock);
	}
	syslogd_close_sockets (&unixsock);
	syslogd_stop (&syslogs, state);
	removepf (pidfile);
	exit (0);
}