Exemplo n.º 1
0
Arquivo: core.c Projeto: w00x/bombdog
static int event_handler(struct mg_event *event) {

  if (event->type == MG_REQUEST_BEGIN) {
    routes(event);
    return 1;
  }

  // We do not handle any other event
  return 0;
}
Exemplo n.º 2
0
unsigned long long int routes(unsigned int i, unsigned int j) 
{
	if(store[i][j] == -1)
	{
		if ((i == N - 1) && (j == N - 1))
			store[i][j] = 1;
		else
			if(i + 1 < N)
				if(j + 1 < N)
					store[i][j] = routes(i + 1, j) + routes(i, j + 1);
				else
					store[i][j] = routes(i + 1, j);
			else
				if(j + 1 < N)
					store[i][j] = routes(i, j + 1);
				else
					store[i][j] = 0;
	}
	return store[i][j];
}
Exemplo n.º 3
0
 std::string RouteContainer::getRoutes(bool styled) const {
     Json::Value routes(Json::arrayValue);
     for (auto const &r : m_routingDirectives) {
         routes.append(parseRoutingDirective(r));
     }
     if (styled) {
         return routes.toStyledString();
     } else {
         return toFastString(routes);
     }
 }
Exemplo n.º 4
0
int main()
{
	unsigned int i, j;

	for(i = 0; i < N; i++)
		for(j = 0; j < N; j++)
			store[i][j] = -1;	
	store[0][0] = routes(0, 0);
	
	printf("\nNo of routes available are : %llu", store[0][0]);

	return 0;
}
Exemplo n.º 5
0
/*
 * main loop - construct the event_base and start the loop
 */
int run_server(char* ip, short port, int timeout_s, int backlog) {
  struct event_base           *ev_base;
  struct event_config         *ev_cfg;
  struct evhttp               *ev_httpd;
  evutil_socket_t             socket_fd;
  int                         socket_opts_flag = 1;
  int                         worker_id, socket_opts_results;

  openlog("Backend", LOG_PID|LOG_NDELAY, LOG_LOCAL0);  

  ev_cfg = event_config_new();
  //event_config_set_flag(ev_cfg, EV_TIMEOUT|EV_PERSIST);
  ev_base = event_base_new_with_config(ev_cfg);
  
  if (!ev_base) {
    printf("ERROR: Failed to initialize HTTP event loop!\n");
    return -1;
  }
     
  // Set up httpd interface event
  ev_httpd = evhttp_new(ev_base);
  evhttp_set_timeout(ev_httpd, timeout_s);
  routes(ev_httpd, ev_base);

  socket_fd = create_socket(ip, port, timeout_s, backlog);
  socket_opts_results = setsockopt(socket_fd, IPPROTO_TCP, TCP_NODELAY,
                                  (char *) socket_opts_flag, sizeof(int));

  if ( socket_opts_results < 0 ) {
    syslog( LOG_INFO, "Nagle DISABLED");
  } else {
    syslog( LOG_INFO, "Nagle ENABLED");
  }

  evhttp_accept_socket(ev_httpd, socket_fd);
  
  for (worker_id = 0; worker_id < WORKERS; worker_id++) {
    if (fork() == 0) {
      printf("Starting worker_id %d ... ", worker_id);
      worker(ev_base);
      printf("done.\n");
      exit(0);
    }
  }

  closelog();
  return 0;
}
Exemplo n.º 6
0
void device_sound_interface::interface_validity_check(validity_checker &valid) const
{
	// loop over all the routes
	for (sound_route const &route : routes())
	{
		// find a device with the requested tag
		device_t const *const target = route.m_base.get().subdevice(route.m_target.c_str());
		if (!target)
			osd_printf_error("Attempting to route sound to non-existent device '%s'\n", route.m_base.get().subtag(route.m_target.c_str()).c_str());

		// if it's not a speaker or a sound device, error
		device_sound_interface const *sound;
		if (target && (target->type() != SPEAKER) && !target->interface(sound))
			osd_printf_error("Attempting to route sound to a non-sound device '%s' (%s)\n", target->tag(), target->name());
	}
}
Exemplo n.º 7
0
unsigned long int routes(int x, int y)
{
	return x==MAX && y==MAX ? 1 : /* one route */
	       (x<MAX ? routes(x+1, y) : 0)
	     + (y<MAX ? routes(x, y+1) : 0);
}
Exemplo n.º 8
0
int main()
{
	for ( MAX=1; MAX<=20; ++MAX )
		printf("%dx%d grid has %lu routes\n", MAX, MAX, routes(0, 0));
}
Exemplo n.º 9
0
std::vector<std::string> Router::find_routes() const {
    POMAGMA_INFO("Routing all obs");

    const size_t item_count = m_carrier.item_count();
    std::vector<float> best_probs(1 + item_count, 0);
    std::vector<Segment> best_segments(1 + item_count);

    bool changed = true;
    while (changed) {
        changed = false;

        POMAGMA_DEBUG("finding best local routes");

        //#pragma omp parallel for schedule(dynamic, 1)
        for (size_t i = 0; i < item_count; ++i) {
            Ob ob = 1 + i;

            float& best_prob = best_probs[ob];
            Segment& best_segment = best_segments[ob];
            bool best_changed = false;
            for (const Segment& segment : iter_val(ob)) {
                float prob = get_prob(segment, best_probs);
                if (unlikely(std::make_pair(-prob, segment) <
                             std::make_pair(-best_prob, best_segment))) {
                    best_prob = prob;        // relaxed memory order
                    best_segment = segment;  // relaxed memory order
                    best_changed = true;
                }
            }

            if (best_changed) {
                //#pragma omp atomic
                changed = true;
            }
        }
    }

    POMAGMA_DEBUG("scheduling route building");
    std::vector<Ob> schedule;
    schedule.reserve(item_count);
    for (auto iter = m_carrier.iter(); iter.ok(); iter.next()) {
        Ob ob = *iter;
        POMAGMA_ASSERT_LT(0, best_probs[ob]);
        schedule.push_back(ob);
    }
    std::sort(schedule.begin(), schedule.end(), [&](const Ob& x, const Ob& y) {
        return best_probs[x] > best_probs[y];
    });

    POMAGMA_DEBUG("building full routes");
    std::vector<std::string> routes(1 + item_count);
    for (Ob ob : schedule) {
        const Segment& segment = best_segments[ob];
        const SegmentType& type = m_types[segment.type];
        switch (type.arity) {
            case NULLARY: {
                routes[ob] = type.name;
            } break;

            case UNARY: {
                const auto& arg = routes[segment.arg1];
                POMAGMA_ASSERT(not arg.empty(), "unknown arg route");
                routes[ob] = type.name + " " + arg;
            } break;

            case BINARY: {
                const auto& lhs = routes[segment.arg1];
                const auto& rhs = routes[segment.arg2];
                POMAGMA_ASSERT(not lhs.empty(), "unknown lhs route");
                POMAGMA_ASSERT(not rhs.empty(), "unknown rhs route");
                routes[ob] = type.name + " " + lhs + " " + rhs;
            } break;
        }
    }

    return routes;
}
Exemplo n.º 10
0
/*@maynotreturn@*/ 
void routeParser(void)
{
	struct sRoute *		pRoute = NULL;
	unsigned short		nr = 0;
	unsigned short		i = 0;
	unsigned short		j = 0;
	enum eToken		tok = tokNone;
	char			name[NAMELEN];
	enum eRoutePartType	ePartType;
 
	parserExpectTokenNeu(tokLBracket);
	parserExpectTokenNeu(tokZuFas);
	nr = parserExpectNumber("Anzahl Zugfahrstrassen erwartet");
	routes(nr);		/* construct route structure */

	parserExpectTokenNeu(tokLBracket);
	while(NULL != (pRoute = routeGet(i)))
	{
		tok = parserGetWord(name);
		parserAssert(tokNone == tok, "Name der Zugfahrstrasse erwartet");
		routeSetName(pRoute, name);
		routeSingleParser(pRoute);
		i++;
	}

	tok = parserGetToken();
	parserAssert(tokRBracket == tok, "zu viele Zugfahrstrassen angegeben");
	/* I did not use parserExpectToken, because a better error 
	 * message can be given
	 */

	parserExpectTokenNeu(tokRBracket);

	/* now make the resolving of the route names given as illegal route
	 *  or conditional route. Note, these routes were probably not known
	 *  before the parsing of the last route
	 */
	i = 0;
	while(NULL != (pRoute = routeGet(i)))
	{
		for(j = 0; j < routeGetParts(pRoute); j++)
		{
			switch(routeGetPartType(pRoute, j))
			{
			case RoutePartIllegalRoute:
				/* now get the name of the illegal route, search for it
				 *  in the routes and store the pointer to the route found
				 */
				(void) routeGetIllegalRouteName(pRoute, name, j);
				routeSetIllegalRoute(pRoute, routeFind(name), j);
				break;
			
			case RoutePartCondRoute:
				(void) routeGetCondRouteName(pRoute, name, j);
				routeSetCondRoute(pRoute, routeFind(name), j);
				break;

			default:
				break;
			}
		}
	}
}
Exemplo n.º 11
0
int main()
{
    srand(time(NULL));

    int WIDTH(750), HEIGHT(750);
    sf::RenderWindow window(sf::VideoMode(WIDTH, HEIGHT), "RTest");
    window.setFramerateLimit(60);

    RegionMap world(100, 80);

    Region *region1(nullptr), *region2(nullptr);
    std::vector<Region*> path;

    double offsetX = 0;
    sf::Vector2i clicPos;

    sf::Transform slide, loopSlide;

    while (window.isOpen())
    {
        sf::Vector2i localPosition = sf::Mouse::getPosition(window);

        sf::Event event;
        while (window.pollEvent(event))
        {
            if (event.type == sf::Event::Closed)
            {
                window.close();
            }
            else if (event.type == sf::Event::MouseButtonPressed)
            {
                clicPos = localPosition;
            }
        }

        if (sf::Mouse::isButtonPressed(sf::Mouse::Left))
        {
            region1 = world.getRegionAt(localPosition.x, localPosition.y);

            int move = localPosition.x-clicPos.x;
            offsetX += move;
            slide.translate(sf::Vector2f(move, 0));

            if (offsetX > 0)
                loopSlide.translate(sf::Vector2f(move-WIDTH, 0));
            else
                loopSlide.translate(sf::Vector2f(move+WIDTH, 0));

            clicPos = localPosition;
        }

        Region* newRegion2 = world.getRegionAt(localPosition.x, localPosition.y);
        if (newRegion2 != region2 && newRegion2)
        {
            region2 = newRegion2;
            path = world.getRoute(region1, region2);
        }

        sf::VertexArray routes(sf::Lines, 0);
        if (path.size())
        {
            for (unsigned int i(0); i<path.size()-1; ++i)
            {
                unsigned int x = path[i]->capital()._x;
                unsigned int y = path[i]->capital()._y;

                sf::Vertex routePoint;
                routePoint.position = sf::Vector2f(x, y);
                routePoint.color    = sf::Color::Red;

                routes.append(routePoint);

                routePoint.position = sf::Vector2f(path[i+1]->capital()._x, path[i+1]->capital()._y);
                routePoint.color    = sf::Color::Red;

                routes.append(routePoint);
            }
        }


        window.clear(sf::Color::White);

        world.render(&window, slide);

        window.draw(routes, slide);
        window.draw(routes, loopSlide);

        window.display();
    }

    return 0;
}
Exemplo n.º 12
0
void ForwardRules::buildDefaultRules(const char* domain,
                                     const char* hostname,
                                     const char* ipAddress,
                                     const char* fqhn,
                                     int localPort,
                                     TiXmlDocument& xmlDoc)
{
    // Note: fqhn == fully qualified host name



    UtlString hostnamePort(hostname ? hostname : "localhost");
    UtlString domainPort(domain ? domain : "");
    UtlString ipAddressPort(ipAddress ? ipAddress : "127.0.0.1");
    UtlString fqhnPort(fqhn ? fqhn : "localhost");

    if(localPort == 5060) localPort = PORT_NONE;
    if(portIsValid(localPort))
    {
        char portString[40];
        sprintf(portString,":%d", localPort);
        hostnamePort.append(portString);
        domainPort.append(portString);
        ipAddressPort.append(portString);
        fqhnPort.append(portString);
    }

    UtlString sdsAddress(fqhn);
    sdsAddress.append(":5090");
    UtlString statusAddress(fqhn);
    statusAddress.append(":5110");
    UtlString regAddress(fqhn);
    regAddress.append(":5070");
    UtlString configAddress("sipuaconfig");
    UtlString configFqhnAddress(configAddress);
    configFqhnAddress.append(".");
    configFqhnAddress.append(domain);

    TiXmlElement routes("routes");
    TiXmlElement route("route");
    route.SetAttribute("mappingType", "local");

    TiXmlElement routeFromDomain("routeFrom");
    TiXmlText domainText(domainPort.data());

    TiXmlElement routeFromFqhn("routeFrom");
    TiXmlText fqhnText(fqhnPort.data());

    TiXmlElement routeFromHost("routeFrom");
    TiXmlText hostText(hostnamePort.data());

    TiXmlElement routeFromIp("routeFrom");
    TiXmlText ipText(ipAddressPort.data());

    TiXmlElement methodMatch("methodMatch");

    TiXmlElement methodPattern("methodPattern");
    TiXmlText subscribe("SUBSCRIBE");

    TiXmlElement fieldMatchConfig("fieldMatch");
    fieldMatchConfig.SetAttribute("fieldName", "Event");

    TiXmlElement fieldPatternConfig("fieldPattern");
    TiXmlText configEvent("sip-config");

    TiXmlElement routeToSds("routeTo");
    TiXmlText sdsText(sdsAddress.data());

    TiXmlElement fieldMatchStatus("fieldMatch");
    fieldMatchStatus.SetAttribute("fieldName", "Event");

    TiXmlElement fieldPatternStatus("fieldPattern");
    TiXmlText mwiEvent("message-summary*");

    TiXmlElement routeToStatus("routeTo");
    TiXmlText statusText(statusAddress.data());

    TiXmlElement routeToReg("routeTo");
    TiXmlText regText(regAddress.data());

    TiXmlElement routeConfig("route");

    TiXmlElement routeFromFqhnConfig("routeFrom");
    TiXmlText fqhnConfigText(configFqhnAddress.data());

    TiXmlElement routeFromConfig("routeFrom");
    TiXmlText configText(configAddress.data());

    // Link everything up in reverse order as it TinyXml 
    // makes copies
    routeFromDomain.InsertEndChild(domainText);
    route.InsertEndChild(routeFromDomain);
    routeFromHost.InsertEndChild(hostText);
    route.InsertEndChild(routeFromHost);
    routeFromFqhn.InsertEndChild(fqhnText);
    route.InsertEndChild(routeFromFqhn);
    routeFromIp.InsertEndChild(ipText);
    route.InsertEndChild(routeFromIp);

    methodPattern.InsertEndChild(subscribe);
    methodMatch.InsertEndChild(methodPattern);

    fieldPatternStatus.InsertEndChild(mwiEvent);
    fieldMatchStatus.InsertEndChild(fieldPatternStatus);
    routeToStatus.InsertEndChild(statusText);
    fieldMatchStatus.InsertEndChild(routeToStatus);
    methodMatch.InsertEndChild(fieldMatchStatus);

    fieldPatternConfig.InsertEndChild(configEvent);
    fieldMatchConfig.InsertEndChild(fieldPatternConfig);
    routeToSds.InsertEndChild(sdsText);
    fieldMatchConfig.InsertEndChild(routeToSds);
    methodMatch.InsertEndChild(fieldMatchConfig);

    routeToReg.InsertEndChild(regText);
    methodMatch.InsertEndChild(routeToReg);
    route.InsertEndChild(methodMatch);

    route.InsertEndChild(routeToReg);

    routeFromFqhnConfig.InsertEndChild(fqhnConfigText);
    routeConfig.InsertEndChild(routeFromFqhnConfig);

    routeFromConfig.InsertEndChild(configText);
    routeConfig.InsertEndChild(routeFromConfig);

    routeConfig.InsertEndChild(routeToReg);

    routes.InsertEndChild(route);
    routes.InsertEndChild(routeConfig);

    xmlDoc.InsertEndChild(routes);

}