Example #1
0
server_t* parse_nameserver(const char *nameserver, const char *def_port)
{
	if (nameserver == NULL || def_port == NULL) {
		DBG_NULL;
		return NULL;
	}

	// OpenBSD notation: nameserver [address]:port
	if (nameserver[0] == '[') {
		char *addr, *port;

		char   *start = (char *)nameserver + 1;
		char   *end = index(nameserver, ']');
		size_t addr_len = end - start;

		// Missing closing bracket -> stop processing.
		if (end == NULL) {
			return NULL;
		}

		// Fill enclosed address.
		addr = strndup(start, addr_len);

		// Find possible port.
		start += addr_len + 1;
		if (strlen(start) > 0) {
			// Check for colon separation.
			if (*start != ':') {
				free(addr);
				return NULL;
			}

			size_t port_len = strlen(++start);

			// Check port string length.
			if (port_len == 0 || port_len >= sizeof(port)) {
				free(addr);
				return NULL;
			}

			// Fill port part.
			port = strdup(start);
		} else {
			port = strdup(def_port);
		}

		// Create server structure.
		server_t *server = server_create(addr, port);

		free(addr);
		free(port);

		return server;
	} else {
		return server_create(nameserver, def_port);
	}
}
Example #2
0
int main(int argc, char const* argv[]) {
  server_t* s;
  sigset_t mask;
  siginfo_t info;
  struct sigaction action;

  if(argc == 1) {
    if(!server_create(&s, "../calories.csv", NULL)) {
      if(!server_create(&s, "./calories.csv", NULL)) {
        printf("File '%s' fot found\n", "calories.csv");
        exit(1);
      }
    }
  } else if(argc == 2) {
    if(!server_create(&s, "../calories.csv", argv[1])) {
      if(!server_create(&s, "./calories.csv", argv[1])) {
        printf("File '%s' fot found\n", "calories.csv");
        exit(1);
      }
    }
  } else {
    printf("%s\n", SERVER_MAIN_HELP);
    exit(1);
  }

  printf("Press CTRL+C to shutdown the server\n");

  sigemptyset(&mask);
  sigaddset(&mask, SIGINT);
  sigprocmask(SIG_BLOCK, &mask, NULL);

  sigemptyset(&action.sa_mask);
  action.sa_flags = SA_SIGINFO;
  sigaction(SIGCHLD, &action, NULL);

  if(server_start(s)) {
    while(true) {
      // signal() is NOT thread safe!
      // And since the server doesn't block signal handling is "not" needed ...
      if(sigwaitinfo(&mask, &info) == -1) {
        perror("sigwaitinfo() failed");
        exit(1);
      }

      switch(info.si_signo) {
      case SIGINT:
        server_destroy(s);
        return 0;
      }
    }
  } else {
    server_destroy(s);
  }
}
Example #3
0
static struct connection *conn_create_server(struct context *ctx,
        struct address *addr, char *key, bool readonly)
{
    int fd = conn_create_fd();
    if (fd == -1) {
        LOG(ERROR, "conn_create_server: fail to create fd");
        return NULL;
    }
    struct connection *server = server_create(ctx, fd);
    struct conn_info *info = server->info;
    memcpy(&info->addr, addr, sizeof(info->addr));
    extern const size_t CMD_NUM;
    info->slow_cmd_counts = cv_calloc(CMD_NUM, sizeof(uint32_t));

    if (conn_connect(server) == CORVUS_ERR) {
        LOG(ERROR, "conn_create_server: fail to connect %s:%d",
                info->addr.ip, info->addr.port);
        conn_free(server);
        conn_buf_free(server);
        conn_recycle(ctx, server);
        return NULL;
    }

    if (readonly) {
        server->info->readonly = true;
    }

    strncpy(info->dsn, key, ADDRESS_LEN);
    dict_set(&ctx->server_table, info->dsn, (void*)server);
    TAILQ_INSERT_TAIL(&ctx->servers, server, next);
    return server;
}
Example #4
0
int nzb_fetch_add_server(nzb_fetch *fetcher, char *address, int port,
                         char *username, char *password, int threads,
                         int ssl, int priority)
{
    server_t *new_server, *server;
    int required_queues;
    int current_queues;
    
    if (priority < 0)
    {
        fprintf(stderr, "Error: priority should be > 0\n");
        return -1;
    }

#if !HAVE_LIBSSL
    if (ssl > 0)
    {
        fprintf(stderr, "Error: SSL Support is not compiled in\n");
        return -1;
    }
#endif

    new_server = server_create(address, port, username, password,
                               threads, ssl, priority);
    
    // Insert into server linked list
    server = fetcher->servers;
    
    if(server == NULL)
        fetcher->servers = new_server;
    else
    {
        // Append server at the end
        while(server->next != NULL)
            server = server->next;
        
        server->next = new_server;
        new_server->prev = server;
        
    }
    
    required_queues = server_calc_priorities(fetcher);
    
    if (required_queues > 1)
    {
        current_queues = sizeof(fetcher->priority_queues) /
                            sizeof(queue_list_t *);
        
        if (required_queues > current_queues)
        {
            fetcher->priority_queues = reallocf(fetcher->priority_queues,
                                                sizeof(queue_list_t *) *
                                                required_queues);
            
            fetcher->priority_queues[new_server->priority] = queue_list_create();
            fetcher->priority_queues[new_server->priority]->id = strdup("priority queue");
        }   
    }
    return 0;
}
Example #5
0
int main(int argc, const char *argv[])
{
	if (argc != 3)
	{
		print_usage();
		return 1;
	}

	setup_signal_handlers();

	server *s = server_create((uint16_t)atoi(argv[1]), argv[2]);
	server_listen(s);

	printf("Listening...\n");
	fflush(stdout);

	while (running)
	{
		server_wait(s);
	}

	printf("Shutting down...\n");
	fflush(stdout);

	server_close(s);
	server_destroy(s);

	return 0;
}
Example #6
0
static struct connection *conn_create_server(struct context *ctx, struct address *addr, char *key)
{
    int fd = conn_create_fd();
    if (fd == -1) {
        LOG(ERROR, "conn_create_server: fail to create fd");
        return NULL;
    }
    struct connection *server = server_create(ctx, fd);
    struct conn_info *info = server->info;
    memcpy(&info->addr, addr, sizeof(info->addr));

    if (conn_connect(server) == CORVUS_ERR) {
        LOG(ERROR, "conn_create_server: fail to connect %s:%d",
                info->addr.ip, info->addr.port);
        conn_free(server);
        conn_buf_free(server);
        conn_recycle(ctx, server);
        return NULL;
    }

    strncpy(info->dsn, key, DSN_LEN);
    dict_set(&ctx->server_table, info->dsn, (void*)server);
    TAILQ_INSERT_TAIL(&ctx->servers, server, next);
    return server;
}
Example #7
0
int main()
{
	//init win32 socket
#ifdef __WIN32__
	static WSADATA wsa_data; 
	int result = WSAStartup((WORD)(1<<8|1), &wsa_data); //初始化WinSocket动态连接库
	if( result != 0 ) // 初始化失败
		return -1;
#endif
#ifndef __WIN32__
	signal( SIGPIPE, SIG_IGN );	//ignore send,recv SIGPIPE error
#endif
	NEW( websrv, sizeof(webserver) );
	memset( websrv, 0, sizeof(webserver) );
	server_create( websrv, "config.xml" );
	server_start( websrv );
	do_console();
	server_stop( websrv );
	server_end( websrv );
	DEL( websrv );

#ifdef __WIN32__
	WSACleanup();
#endif
	memory_end();
	return 0;
}
Example #8
0
void client_init(int taskid, int num_tasks)
{
    ASSERT(max_ep > 0);

    /* Create data structure to track all clients */
    MALLOC_ALIGN(client_table, sizeof(client_t) * max_ep, CACHELINE_SIZE);

    PMPI_Barrier(MPI_COMM_WORLD);

    /* Initialize command queues */
    cqueue_init(max_ep);

    /* Spawn server */
    server_create();

    /* Create client data-structure */
    for (int clientid = 0; clientid < max_ep; clientid++)
    {
        client_t* myclient = &client_table[clientid];
        myclient->clientid = clientid;
        myclient->taskid = taskid;
        /* Attach client to a command queue */
        myclient->cqueue = cqueue_attach(clientid);
        memory_set_cqueue(clientid, myclient->cqueue);
    }
    PMPI_Barrier(MPI_COMM_WORLD);

    if (use_mem_hooks) set_mem_hooks = 1;
}
Example #9
0
int main(int argc, char **argv)
{
	const uint16_t acceptor_port = (uint16_t)((argc >= 2) ? atoi(argv[1]) : 8080);
	char const * const settings_file_name = ((argc >= 3) ? argv[2] : "settings.txt");
	settings_t settings;
	server_t server;
	log_t log;

	log_create(&log, stderr);

	if (!load_settings(&settings, settings_file_name, &log))
	{
		return 1;
	}

	if (!server_create(&server, &log, &settings, acceptor_port))
	{
		settings_destroy(&settings);
		return 1;
	}

	settings_destroy(&settings);

	server_run(&server);
	server_destroy(&server);

	log_destroy(&log);
	return 0;
}
Example #10
0
static void *
lua_server(void * arg) {

	pthread_detach( pthread_self() );

	server_create((luaServer_t *)arg);

	return NULL;
}
int main() {
	struct Server *s = malloc(sizeof(struct Server));
	server_create(s, "/tmp/accounts.txt", "/tmp/requests");
	//server_createAccount(s, 1231, "vascoFG", "bino", 0);
	/*server_createAccount(s, 1234, "vascoFG", "bino", 0);
	 server_createAccount(s, 4321, "vascoFG", "bino", 0);*/
	server_run(s);
	return 0;
}
Example #12
0
int
main(int argc, char *argv[])
{
	server_type_t server_type;
	short int port;
	int accept_fd;

	if (argc != 3) {
		printf("Proper usage of http server is:\n%s <port> <#>\n"
		       "port is the port to serve on, # is either\n"
		       "0: serve only a single request\n"
		       "1: use only a single thread for multiple requests\n"
		       "2: use fork to create a process for each request\n"
		       "3: Extra Credit: use fork and exec when the path is an executable to run the program dynamically.  This is how web servers handle dynamic (program generated) content.\n"
		       "4: create a thread for each request\n"
		       "5: use atomic instructions to implement a task queue\n"
		       "6: use a thread pool\n"
		       "7: to be defined\n"
		       "8: to be defined\n"
		       "9: to be defined\n",
		       argv[0]);
		return -1;
	}

	port = atoi(argv[1]);
	accept_fd = server_create(port);
	if (accept_fd < 0) return -1;
	
	server_type = atoi(argv[2]);

	switch(server_type) {
	case SERVER_TYPE_ONE:
		server_single_request(accept_fd);
		break;
	case SERVER_TYPE_SINGLET:
		server_multiple_requests(accept_fd);
		break;
	case SERVER_TYPE_PROCESS:
		server_processes(accept_fd);
		break;
	case SERVER_TYPE_FORK_EXEC:
		server_dynamic(accept_fd);
		break;
	case SERVER_TYPE_SPAWN_THREAD:
		server_thread_per(accept_fd);
		break;
	case SERVER_TYPE_TASK_QUEUE:
		server_task_queue(accept_fd);
		break;
	case SERVER_TYPE_THREAD_POOL:
		server_thread_pool(accept_fd);
		break;
	}
	close(accept_fd);

	return 0;
}
Example #13
0
int nfs41_server_find_or_create(
    IN const char *server_owner_major_id,
    IN const char *server_scope,
    IN const netaddr4 *addr,
    OUT nfs41_server **server_out)
{
    struct server_info info;
    struct list_entry *entry;
    nfs41_server *server;
    int status;

    info.owner = server_owner_major_id;
    info.scope = server_scope;

    dprintf(SRVLVL, "--> nfs41_server_find_or_create(%s)\n", info.owner);

    EnterCriticalSection(&g_server_list.lock);

    /* search for an existing server */
    entry = list_search(&g_server_list.head, &info, server_compare);
    if (entry == NULL) {
        /* create a new server */
        status = server_create(&info, &server);
        if (status == NO_ERROR) {
            /* add it to the list */
            list_add_tail(&g_server_list.head, &server->entry);
            *server_out = server;

            dprintf(SRVLVL, "<-- nfs41_server_find_or_create() "
                "returning new server %p\n", server);
        } else {
            dprintf(SRVLVL, "<-- nfs41_server_find_or_create() "
                "returning %d\n", status);
        }
    } else {
        server = server_entry(entry);
        status = NO_ERROR;

        dprintf(SRVLVL, "<-- nfs41_server_find_or_create() "
            "returning existing server %p\n", server);
    }

    if (server) {
        /* register the address used to connect */
        server_addrs_add(&server->addrs, addr);

        server_ref_locked(server);
    }

    *server_out = server;
    LeaveCriticalSection(&g_server_list.lock);
    return status;
}
Example #14
0
int get_nameservers(list *servers, const char *def_port)
{
	if (servers == NULL || def_port == NULL) {
		DBG_NULL;
		return KNOT_EINVAL;
	}

	// Initialize list of servers.
	init_list(servers);

	// Read nameservers from resolv file.
	int ret = get_resolv_nameservers(servers, def_port);

	// If found nameservers or error.
	if (ret != 0) {
		return ret;
	// If no nameservers.
	} else {
		server_t *server;

		// Add default ipv6 nameservers.
		server = server_create(DEFAULT_IPV6_NAME, def_port);

		if (server != NULL) {
			add_tail(servers, (node *)server);
		}

		// Add default ipv4 nameservers.
		server = server_create(DEFAULT_IPV4_NAME, def_port);

		if (server != NULL) {
			add_tail(servers, (node *)server);
		}

		return list_size(servers);
	}
}
Example #15
0
File: test.c Project: xqyphp/kevent
void test_server()
{
	socket_t serverfd = server_create("127.0.0.1", SERVER_PORT);
	setnonblocking(serverfd);

	server_listen(serverfd);

	event_manager_t event_manager;

	event_manager_init(&event_manager, serverfd, my_event_callback);

	event_dispatch(&event_manager);

	event_magager_destroy(&event_manager);
}
Example #16
0
File: main.c Project: brd6/myftp
static int	run(char *default_user_path, int port)
{
  if (signal(SIGCHLD, SIG_IGN) == SIG_ERR)
    return (dprintf(2, ERR_SET_SIGNAL), 0);
  g_config.port = port;
  g_config.sock_fd = -1;
  g_config.client_sock_fd = -1;
  g_config.parent_pid = getpid();
  if ((g_config.sock_fd = server_create(INADDR_ANY, port, 1)) == -1)
    return (dprintf(2, ERR_SERVER_CREATE, g_config.port), 0);
  if (user_change_home("anonymous", default_user_path) == 0)
    return (dprintf(2, ERR_USER_CHANGE_DIR), 0);
  server_run();
  close(g_config.sock_fd);
  return (1);
}
Example #17
0
int main(int argc, char** argv)
{
	server_t* server = server_create("config.xml");
	if(server == NULL) return 0; 

	char buf[512] = {0};

	for(;;) 
	{
		//sleep(1);
		fgets(buf, 512, stdin);
		if(strncmp(buf, "quit", strlen("quit")) == 0) break;

	}

	server_destroy(server);

	return 0;
}
Example #18
0
int
main(int argc, char *argv[])
{
    server_type_t server_type;
    short int port;
    int accept_fd;

    if (argc != 3) {
        printf("Proper usage of http server is:\n%s <port> <#>\n"
               "port is the port to serve on, # is either\n"
               "0: server only a single request\n"
               "1: use a thread pool and a _bounded_ buffer with "
               "mutexes + condition variables\n"
               "2: use a thread pool and compare and swap to "
               "implement a lock-free stack of requests\n",
               argv[0]);
        return -1;
    }

    port = atoi(argv[1]);
    accept_fd = server_create(port);

    if (accept_fd < 0) return -1;

    server_type = atoi(argv[2]);

    switch(server_type) {
    case SERVER_TYPE_ONE:
        server_single_request(accept_fd);
        break;
    case SERVER_TYPE_THREAD_POOL_BOUND:
        server_thread_pool_bounded(accept_fd);
        break;
    case SERVER_TYPE_THREAD_POOL_ATOMIC:
        server_thread_pool_lock_free(accept_fd);
        break;
    }
    close(accept_fd);

    return 0;
}
void interprocess::listen()
{
    server_create(); 

    char* buff;
    int size;
    while (true) {
       bool connected = ConnectNamedPipe(pipe_handle, NULL);
        if (!connected) {
            int error = GetLastError();
            if (error != ERROR_PIPE_CONNECTED) {
                cout<<error<<endl;
                throw ipc::fifo_open_error();
            }
            
        }
        DWORD num_bytes_read;
        ReadFile(pipe_handle,(char*)(&size), sizeof(size), &num_bytes_read,NULL);
        if (num_bytes_read == sizeof(size)) {
            buff = new char[size+1];
            ReadFile(pipe_handle, buff, size, &num_bytes_read, NULL);

            if (num_bytes_read != size) {
                delete[] buff;
                throw ipc::wrong_msg_size();
            }
            buff[size] = '\0';
            last_msg = std::string(buff);
            cout<<"received: "<<last_msg<<endl;
            delete[] buff;

            th = std::thread(&interprocess::on_msg_receive, this, std::ref(last_msg));
            th.detach();
            if(last_msg == "quit")
                break;
        }
    }

}
Example #20
0
int main(int argc, char *argv[])
{
  int c;
  opterr = 0;
  while((c = getopt(argc, argv, "p:t:")) != -1)
  {
    switch(c)
    {
    case 'p':
      port_num = atoi(optarg);
      break;
    case't':
      num_threads = atoi(optarg);
      break;
    case '?':
      if(optopt == 'p' || optopt == 't')
	printf("Option -%c requires an argument\n", optopt);
      else
	printf("Unknown option -%c\n", optopt);
    default:
      printf("Usage: %s [-p port_num] [-t num_threads]\n", argv[0]);
      return 0;
    }
  }
  if(port_num < 1)
  {
    printf("Invalid port number\n");
    return 0;
  }
  if(num_threads < 1)
  {
    printf("Invalid number of threads\n");
    return 0;
  }
  
  server_create();
  return 0;
}
Example #21
0
	void run(void)
	{
		server_t *server;
		char line[4096];
		int n_wait = 0;

		server = server_create(m_port);

		while (m_semaphore.wait(n_wait) != 0) {
			if (server_readline(server, line, sizeof(line)) == 0) {
				int len;

				len = strcspn(line, "\n\r");
				if (len == 0)
					continue;
				line[len] = 0;
				addImage(m_gui, line, false);
				n_wait = 0;
			} else {
				n_wait = 10;
			}
		}
		server_destroy(server);
	}
Example #22
0
int
main(int argc, char *argv[])
{
	server_type_t server_type;
	short int port;
    int accept_fd;

	if (argc != 3) {
		printf("Proper usage of http server is:\n%s <port> <#>\n"
		       "port is the port to serve on, # is either\n"
		       "0: serve only a single request\n"
		       "1: serve each request with kthds\n",
		       argv[0]);
		return -1;
	}

	port = atoi(argv[1]);
	accept_fd = server_create(port);
	if (accept_fd < 0) return -1;
	
	server_type = atoi(argv[2]);

	switch(server_type) {
	case SERVER_TYPE_ONE:
		server_single_request(accept_fd);
		break;
	case SERVER_TYPE_TWO:
		process_kthd_server(accept_fd);
		break;
	default:
		perror("Unknown server type provided.\n");
	}
	close(accept_fd);

	return 0;
}
Example #23
0
/** Create a http site object.
 *
 * The function nth_site_create() allocates and initializes a web site
 * object. A web site object can be either
 * - a primary http server (@a parent is NULL),
 * - a virtual http server (@a address contains hostpart), or
 * - a site within a server
 *   (@a address does not have hostpart, only path part).
 *
 * @param parent pointer to parent site
 *               (NULL when creating a primary server object)
 * @param callback pointer to callback function called when
 *                 a request is received
 * @param magic    application context included in callback parameters
 * @param address  absolute or relative URI specifying the address of
 *                 site
 * @param tag, value, ... list of tagged parameters
 *
 * @TAGS
 * If the @a parent is NULL, the list of tagged parameters must contain
 * NTHTAG_ROOT() used to create the server engine. Tags supported when @a
 * parent is NULL are NTHTAG_ROOT(), NTHTAG_MCLASS(), TPTAG_REUSE(),
 * HTTPTAG_SERVER(), and HTTPTAG_SERVER_STR(). All the tags are passed to
 * tport_tcreate() and tport_tbind(), too.
 *
 * @since Support for multiple sites was added to @VERSION_1_12_4
 */
nth_site_t *nth_site_create(nth_site_t *parent,
			    nth_request_f *callback,
			    nth_site_magic_t *magic,
			    url_string_t const *address,
			    tag_type_t tag, tag_value_t value,
			    ...)
{
  nth_site_t *site = NULL, **prev = NULL;
  su_home_t home[SU_HOME_AUTO_SIZE(256)];
  url_t *url, url0[1];
  server_t *srv = NULL;
  ta_list ta;
  char *path = NULL;
  size_t usize;
  int is_host, is_path, wildcard = 0;

  su_home_auto(home, sizeof home);

  if (parent && url_is_string(address)) {
    char const *s = (char const *)address;
    size_t sep = strcspn(s, "/:");

    if (parent->site_path) {
      /* subpath */
      url_init(url0, (enum url_type_e)parent->site_url->url_type);
      url0->url_path = s;
      address = (url_string_t*)url0;
    }
    else if (s[sep] == ':')
      /* absolute URL with scheme */;
    else if (s[sep] == '\0' && strchr(s, '.') && host_is_valid(s)) {
      /* looks like a domain name */;
      url_init(url0, (enum url_type_e)parent->site_url->url_type);
      url0->url_host = s;
      address = (url_string_t*)url0;
    }
    else {
      /* looks like a path */
      url_init(url0, (enum url_type_e)parent->site_url->url_type);
      url0->url_path = s;
      address = (url_string_t*)url0;
    }
  }

  url = url_hdup(home, address->us_url);

  if (!url || !callback)
    return NULL;

  is_host = url->url_host != NULL;
  is_path = url->url_path != NULL;

  if (is_host && is_path) {
    SU_DEBUG_3(("nth_site_create(): virtual host and path simultanously\n"));
    errno = EINVAL;
    goto error;
  }

  if (!parent && !is_host) {
    SU_DEBUG_3(("nth_site_create(): host is required\n"));
    errno = EINVAL;
    goto error;
  }

  if (parent) {
    if (!parent->site_isdir) {
      SU_DEBUG_3(("nth_site_create(): invalid parent resource \n"));
      errno = EINVAL;
      goto error;
    }

    srv = parent->site_server; assert(srv);
    if (is_host) {
      prev = site_get_host(&srv->srv_sites, url->url_host, url->url_port);

      if (prev == NULL) {
	SU_DEBUG_3(("nth_site_create(): host %s:%s already exists\n",
		    url->url_host, url->url_port ? url->url_port : ""));
	errno = EEXIST;
	goto error;
      }
    }
    else {
      size_t i, j;

      path = (char *)url->url_path;
      while (path[0] == '/')
	path++;

      /* Remove duplicate // */
      for (i = j = 0; path[i];) {
	while (path[i] == '/' && path[i + 1] == '/')
	  i++;
	path[j++] = path[i++];
      }
      path[j] = path[i];

      url = url0, *url = *parent->site_url;

      if (url->url_path) {
	url->url_path = su_strcat(home, url->url_path, path);
	if (!url->url_path)
	  goto error;
	path = (char *)url->url_path + strlen(parent->site_url->url_path);
      }
      else
	url->url_path = path;

      prev = site_get_rslot(parent, path, &path);

      if (!prev || path[0] == '\0') {
	SU_DEBUG_3(("nth_site_create(): directory \"%s\" already exists\n",
		    url->url_path));
	errno = EEXIST;
	goto error;
      }
    }
  }

  if (!parent) {
    if (strcmp(url->url_host, "*") == 0 ||
	host_cmp(url->url_host, "0.0.0.0") == 0 ||
	host_cmp(url->url_host, "::") == 0)
      wildcard = 1, url->url_host = "*";
  }

  usize = sizeof(*url) + url_xtra(url);

  ta_start(ta, tag, value);

  if (!parent) {
    srv = server_create(url, ta_tags(ta));
    prev = &srv->srv_sites;
  }

  if (srv && (site = su_zalloc(srv->srv_home, (sizeof *site) + usize))) {
    site->site_url = (url_t *)(site + 1);
    url_dup((void *)(site->site_url + 1), usize - sizeof(*url),
	    site->site_url, url);

    assert(prev);
    if ((site->site_next = *prev))
      site->site_next->site_prev = &site->site_next;
    *prev = site, site->site_prev = prev;
    site->site_server = srv;

    if (path) {
      size_t path_len;

      site->site_path = site->site_url->url_path + (path - url->url_path);
      path_len = strlen(site->site_path); assert(path_len > 0);
      if (path_len > 0 && site->site_path[path_len - 1] == '/')
	path_len--, site->site_isdir = 1;
      site->site_path_len = path_len;
    }
    else {
      site->site_isdir = is_host;
      site->site_path = "";
      site->site_path_len = 0;
    }

    site->site_wildcard = wildcard;
    site->site_callback = callback;
    site->site_magic = magic;

    if (parent)
      site->site_auth = parent->site_auth;

    nth_site_set_params(site, ta_tags(ta));
  }

  ta_end(ta);

 error:
  su_home_deinit(home);
  return site;
}
Example #24
0
int main(int argc, char **args)
{
    pthread_t stats_thrd;
    uint8_t addrs_len;
    ipv4_t *addrs;
    uint32_t total = 0;
    struct telnet_info info;

#ifdef DEBUG
    addrs_len = 1;
    addrs = calloc(4, sizeof (ipv4_t));
    addrs[0] = inet_addr("0.0.0.0");
#else
    addrs_len = 2;
    addrs = calloc(addrs_len, sizeof (ipv4_t));

    addrs[0] = inet_addr("192.168.0.1"); // Address to bind to
    addrs[1] = inet_addr("192.168.1.1"); // Address to bind to
#endif

    if (argc == 2)
    {
        id_tag = args[1];
    }

    if (!binary_init())
    {
        printf("Failed to load bins/dlr.* as dropper\n");
        return 1;
    }

    /*                                                                                   wget address           tftp address */
    if ((srv = server_create(sysconf(_SC_NPROCESSORS_ONLN), addrs_len, addrs, 1024 * 64, "100.200.100.100", 80, "100.200.100.100")) == NULL)
    {
        printf("Failed to initialize server. Aborting\n");
        return 1;
    }

    pthread_create(&stats_thrd, NULL, stats_thread, NULL);

    // Read from stdin
    while (TRUE)
    {
        char strbuf[1024];

        if (fgets(strbuf, sizeof (strbuf), stdin) == NULL)
            break;

        util_trim(strbuf);

        if (strlen(strbuf) == 0)
        {
            usleep(10000);
            continue;
        }

        memset(&info, 0, sizeof(struct telnet_info));
        if (telnet_info_parse(strbuf, &info) == NULL)
            printf("Failed to parse telnet info: \"%s\" Format -> ip:port user:pass arch\n", strbuf);
        else
        {
            if (srv == NULL)
                printf("srv == NULL 2\n");

            server_queue_telnet(srv, &info);
            if (total++ % 1000 == 0)
                sleep(1);
        }

        ATOMIC_INC(&srv->total_input);
    }

    printf("Hit end of input.\n");

    while(ATOMIC_GET(&srv->curr_open) > 0)
        sleep(1);

    return 0;
}
Example #25
0
int main(int argc, char **argv) {
//    for (int i=1; i<NSIG; i++) {
//        //if (signal(SIGINT, sig_handler) == SIG_ERR) printf("\ncan't catch SIGINT\n");
//        if (signal(i, sig_handler) == SIG_ERR) printf("\ncan't catch %s\n", strsignal(i));
//    }
    signal(SIGPIPE, SIG_IGN);

    apr_initialize();

    apr_pool_create(&mp_rpc_, NULL);
    apr_thread_cond_create(&cd_rpc_, mp_rpc_);
    apr_thread_mutex_create(&mx_rpc_, APR_THREAD_MUTEX_UNNESTED, mp_rpc_);
    rpc_init();

    arg_parse(argc, argv);
    ADD = is_fast_ ? FAST_ADD : SLOW_ADD;
    bool exit = false;

    exit |=  !(is_server_ || is_client_);
    exit |= (addr_ == NULL);
    exit |= (port_ == 0);

    if (exit) {
	fprintf(stderr, "wrong arguments.\n");
	usage(argv[0]);
	return 0;
    }

    if (is_server_) {
        server_t *server = NULL;
	poll_mgr_t *mgr_server = NULL;
	poll_mgr_create(&mgr_server, n_server_thread_);
        server_create(&server, mgr_server);    
        strcpy(server->comm->ip, addr_);
        server->comm->port = port_;
        server_reg(server, ADD, add); 
        server_start(server);
        LOG_INFO("server started start on %s, port %d.", addr_, port_);
    } 
    
    if (is_client_) {
	LOG_INFO("client to %s:%d, test for %d rpc in total, outstanding rpc: %d",
		 addr_, port_, max_rpc_, max_outst_);

	mgrs_ = (poll_mgr_t **) malloc(n_client_ * sizeof(poll_mgr_t*));
	clis_ = (client_t **) malloc(n_client_ * sizeof(client_t *));
	n_issues_ = (uint64_t*) malloc(n_client_ * sizeof(uint64_t));	
	n_callbacks_ = (uint64_t*) malloc(n_client_ * sizeof(uint64_t));
	n_active_cli_ = n_client_;
       
        apr_thread_mutex_lock(mx_rpc_);
        for (int i = 0; i < n_client_; i++) {
            apr_thread_t *th;
            apr_thread_create(&th, NULL, client_thread, (intptr_t) i, mp_rpc_);
        }
	
	
	if (max_rpc_ < 0) {
	    LOG_INFO("infinite rpc on %d threads (clients)", n_client_);
	} else {
	    LOG_INFO("%d threads (clients), each client run for %d rpc.", 
		     n_client_, max_rpc_ * n_client_);
	}

        apr_thread_cond_wait(cd_rpc_, mx_rpc_);
        apr_thread_mutex_unlock(mx_rpc_);

        int period = (tm_end_ - tm_begin_); //micro seconds
        LOG_INFO("finish %d rpc in %d ms.", max_rpc_ * n_client_, period/1000);
        float rate = (float) max_rpc_ * n_client_ / period;
        LOG_INFO("rpc rate %f million per sec.", rate);
	
	for (int i = 0; i < n_client_; i++) {
	    client_destroy(clis_[i]);
	    poll_mgr_destroy(mgrs_[i]);
	}
	free (clis_);
	free (n_issues_);
    }

    fflush(stdout);
    fflush(stderr);

    while(is_server_) {
	apr_sleep(1000000);
    }

    rpc_destroy();
    atexit(apr_terminate);
}
Example #26
0
int main(int argc, char **argv) {
//    for (int i=1; i<NSIG; i++) {
//        //if (signal(SIGINT, sig_handler) == SIG_ERR) printf("\ncan't catch SIGINT\n");
//        if (signal(i, sig_handler) == SIG_ERR) printf("\ncan't catch %s\n", strsignal(i));
//    }
    signal(SIGPIPE, SIG_IGN);

    apr_initialize();
    apr_pool_create(&mp_rpc_, NULL);
    apr_thread_cond_create(&cd_rpc_, mp_rpc_);
    apr_thread_mutex_create(&mx_rpc_, APR_THREAD_MUTEX_UNNESTED, mp_rpc_);
    rpc_init();

    arg_parse(argc, argv);

    bool exit = false;

    exit |=  !(is_server_ || is_client_);
    exit |= (addr_ == NULL);
    exit |= (port_ == 0);

    if (exit) {
	fprintf(stderr, "wrong arguments.\n");
	usage(argv[0]);
	return 0;
    }

    if (is_server_) {
        server_t *server = NULL;
        server_create(&server, NULL);    
        strcpy(server->comm->ip, addr_);
        server->comm->port = port_;
        server_reg(server, ADD, add); 
        server_start(server);
        LOG_INFO("server started start on %s, port %d.", addr_, port_);
    } 
    
    if (is_client_) {
	LOG_INFO("client to %s:%d, test for %d rpc in total, outstanding rpc: %d", addr_, port_, max_rpc_, max_outst_);
       
        apr_thread_mutex_lock(mx_rpc_);
        for (int i = 0; i < n_client_; i++) {
            apr_thread_t *th;
            apr_thread_create(&th, NULL, client_thread, NULL, mp_rpc_);
        }
        LOG_INFO("rpc triggered for %d adds on %d threads.", max_rpc_ * n_client_, n_client_);
        apr_thread_cond_wait(cd_rpc_, mx_rpc_);
        apr_thread_mutex_unlock(mx_rpc_);

        int period = (tm_end_ - tm_begin_); //micro seconds
        LOG_INFO("finish %d rpc in %d ms.", max_rpc_ * n_client_, period/1000);
        float rate = (float) max_rpc_ * n_client_ / period;
        LOG_INFO("rpc rate %f million per sec.", rate);
    }

    fflush(stdout);
    fflush(stderr);

    while(is_server_) {
	apr_sleep(1000000);
    }

    rpc_destroy();
    atexit(apr_terminate);
}
Example #27
0
int main(int argc, char **argv) {
    int conf_err = 0;
    int option;
    int dflag = 0;
    conf_ruleset_s rset;

    // Set the default logger to syslog
    log_syslog(&logger);

    // Initialize the config and its rulesets
    conf_init(&conf);
    conf_rset_init(&rset);

    // Set the real path
    conf_set_realpath(&conf, argv[0]);

    conf_rset_add(&rset, conf_rule_create("root = %s", &conf.document_root));
    conf_rset_add(&rset, conf_rule_create("handler = %s", &conf.method));
    conf_rset_add(&rset, conf_rule_create("port = %hu", &conf.port));
    conf_rset_add(&rset, conf_rule_create("backlog = %d", &conf.backlog));
    conf_rset_add(&rset, conf_rule_create("mime = %s", &conf.mime));
    conf_rset_add(&rset, conf_rule_create("logfile = %s", &conf.logfile));

    if (conf_read(conf.real_path, ".lab3-config", rset) == -1)
        exit_fatal("The configuration file could not be read");

    while((option = getopt(argc, argv, "hp:dl:s:")) != -1) {
        switch(option) {
            case 'p': conf_set_port(&conf, optarg); break;
            case 'd': dflag = 1; break;
            case 'l':
                conf_set_logfile(&conf, optarg);

                if (strncmp(optarg, "stdout", 6) == 0)
                    log_stdout(&logger);
                else
                    log_file(&logger);
                break;
            case 's': conf_set_method(&conf, optarg); break;
            case 'h': default: usage(argv[0]); exit(EXIT_SUCCESS);
        }
    }

    // Register signal handler for SIGINT
    signal(SIGINT, sigint_handler);

    if ((conf_err = conf_validate(conf)) < 0)
        conf_print_err(conf_err);

    // Daemonize the process if the dflag is set
    if (dflag) {
        log_syslog(&logger);
        daemonize();
    } else {
        jail_proc(dflag);
    }

    server_create();

    return 0;
}
Example #28
0
int main(int argc, char *argv[])
{
	int opt;
	bdaddr_t src_addr;
	int dev_id = -1;
	int fd;
	int sec = BT_SECURITY_LOW;
	uint8_t src_type = BDADDR_LE_PUBLIC;
	uint16_t mtu = 0;
	sigset_t mask;
	bool hr_visible = false;
	struct server *server;

	while ((opt = getopt_long(argc, argv, "+hvrs:t:m:i:",
						main_options, NULL)) != -1) {
		switch (opt) {
		case 'h':
			usage();
			return EXIT_SUCCESS;
		case 'v':
			verbose = true;
			break;
		case 'r':
			hr_visible = true;
			break;
		case 's':
			if (strcmp(optarg, "low") == 0)
				sec = BT_SECURITY_LOW;
			else if (strcmp(optarg, "medium") == 0)
				sec = BT_SECURITY_MEDIUM;
			else if (strcmp(optarg, "high") == 0)
				sec = BT_SECURITY_HIGH;
			else {
				fprintf(stderr, "Invalid security level\n");
				return EXIT_FAILURE;
			}
			break;
		case 't':
			if (strcmp(optarg, "random") == 0)
				src_type = BDADDR_LE_RANDOM;
			else if (strcmp(optarg, "public") == 0)
				src_type = BDADDR_LE_PUBLIC;
			else {
				fprintf(stderr,
					"Allowed types: random, public\n");
				return EXIT_FAILURE;
			}
			break;
		case 'm': {
			int arg;

			arg = atoi(optarg);
			if (arg <= 0) {
				fprintf(stderr, "Invalid MTU: %d\n", arg);
				return EXIT_FAILURE;
			}

			if (arg > UINT16_MAX) {
				fprintf(stderr, "MTU too large: %d\n", arg);
				return EXIT_FAILURE;
			}

			mtu = (uint16_t) arg;
			break;
		}
		case 'i':
			dev_id = hci_devid(optarg);
			if (dev_id < 0) {
				perror("Invalid adapter");
				return EXIT_FAILURE;
			}

			break;
		default:
			fprintf(stderr, "Invalid option: %c\n", opt);
			return EXIT_FAILURE;
		}
	}

	argc -= optind;
	argv -= optind;
	optind = 0;

	if (argc) {
		usage();
		return EXIT_SUCCESS;
	}

	if (dev_id == -1)
		bacpy(&src_addr, BDADDR_ANY);
	else if (hci_devba(dev_id, &src_addr) < 0) {
		perror("Adapter not available");
		return EXIT_FAILURE;
	}

	fd = l2cap_le_att_listen_and_accept(&src_addr, sec, src_type);
	if (fd < 0) {
		fprintf(stderr, "Failed to accept L2CAP ATT connection\n");
		return EXIT_FAILURE;
	}

	mainloop_init();

	server = server_create(fd, mtu, hr_visible);
	if (!server) {
		close(fd);
		return EXIT_FAILURE;
	}

	if (mainloop_add_fd(fileno(stdin),
				EPOLLIN | EPOLLRDHUP | EPOLLHUP | EPOLLERR,
				prompt_read_cb, server, NULL) < 0) {
		fprintf(stderr, "Failed to initialize console\n");
		server_destroy(server);

		return EXIT_FAILURE;
	}

	printf("Running GATT server\n");

	sigemptyset(&mask);
	sigaddset(&mask, SIGINT);
	sigaddset(&mask, SIGTERM);

	mainloop_set_signal(&mask, signal_cb, NULL, NULL);

	print_prompt();

	mainloop_run();

	printf("\n\nShutting down...\n");

	server_destroy(server);

	return EXIT_SUCCESS;
}