int main(int argc, char **argv) {
int bind_port = -1;
int flag = 1;
if (argc < 3) {
printf("Error! controller <port to bind to> <server's port>\n");
exit(1);
}
sscanf(*(argv + 1), "%d", &bind_port);
sscanf(*(argv + 2), "%d", &server_port);
// get list of backend servers from user
printf("Enter backend server or enter . to stop\n");
while(flag) {
char server[1024];
scanf("%s", server);
if (server[0] == '.')
flag = 0;
else
add_server(server);
}
printf("OK controller ready\n");
/* Call the listener/forker */
bind_accept_fork(bind_port, do_chld);
/* Never reached */
return(0);
}
static isc_result_t
resconf_parsenameserver(irs_resconf_t *conf, FILE *fp) {
char word[RESCONFMAXLINELEN];
int cp;
isc_result_t result;
if (conf->numns == RESCONFMAXNAMESERVERS)
return (ISC_R_SUCCESS);
cp = getword(fp, word, sizeof(word));
if (strlen(word) == 0U)
return (ISC_R_UNEXPECTEDEND); /* Nothing on line. */
else if (cp == ' ' || cp == '\t')
cp = eatwhite(fp);
if (cp != EOF && cp != '\n')
return (ISC_R_UNEXPECTEDTOKEN); /* Extra junk on line. */
result = add_server(conf->mctx, word, &conf->nameservers);
if (result != ISC_R_SUCCESS)
return (result);
conf->numns++;
return (ISC_R_SUCCESS);
}
static int set_listen_address(requiem_option_t *opt, const char *arg, requiem_string_t *err, void *context)
{
int ret;
char *ptr;
server_generic_t *server;
unsigned int port = DEFAULT_MANAGER_PORT;
if ( strncmp(arg, "unix", 4) != 0 ) {
ptr = strrchr(arg, ':');
if ( ptr ) {
*ptr = '\0';
port = atoi(ptr + 1);
}
}
server = add_server();
if ( ! server )
return -1;
ret = server_generic_bind(server, arg, port);
if ( ret < 0 )
requiem_perror(ret, "error initializing server on %s:%u", arg, port);
return ret;
}
/* verify our option */
int verify_options(mod_gm_opt_t *opt) {
/* no server specified? then default to localhost */
if(opt->server_num == 0) {
add_server(&opt->server_num, opt->server_list, "localhost");
}
/* host is mandatory */
if(opt->host == NULL) {
printf("got no hostname, please use --host=...\n" );
return(GM_ERROR);
}
/* encryption without key? */
if(opt->encryption == GM_ENABLED) {
if(opt->crypt_key == NULL && opt->keyfile == NULL) {
printf("no encryption key provided, please use --key=... or keyfile=... or disable encryption\n");
return(GM_ERROR);
}
}
if ( mod_gm_opt->result_queue == NULL )
mod_gm_opt->result_queue = GM_DEFAULT_RESULT_QUEUE;
return(GM_OK);
}
int command_silc_connect(void *data, struct t_gui_buffer *buffer, int argc, char **argv, char **argv_eol) {
char *servername;
struct t_gui_buffer *server_buffer;
SilcPluginServerList server;
if (argc < 3) {
weechat_printf(buffer, "you need to specify a servername to connect to");
return WEECHAT_RC_ERROR;
}
servername = argv[2];
// create a new buffer for this connection but merge it into the main window
server_buffer = weechat_buffer_new(servername, NULL, NULL, NULL, NULL);
weechat_printf(server_buffer, "SILC: trying to connect to %s", servername);
weechat_buffer_merge(server_buffer, weechat_buffer_search_main());
if (!silc_client_connect_to_server(silc_plugin->client, NULL, silc_plugin->public_key, silc_plugin->private_key,
servername, 706, silc_plugin_connected, server_buffer)) {
weechat_printf(server_buffer, "%sSILC: connection to server failed", weechat_prefix("error"));
weechat_buffer_close(server_buffer);
}
server = add_server(servername, NULL, NULL, server_buffer);
return WEECHAT_RC_OK;
}
void hSERVER(struct entity *from, char *name, int *hops, time_t *boot, time_t *link, char *protocol, char *numeric, char *flags, char *descr) {
struct server *s;
char *maxuserstr = numeric+2;
s = add_server(numeric, maxuserstr, name, *hops, *boot, *link, protocol, descr);
server_apply_mode(from, (struct entity *)s, flags, NULL, 0);
}
void SFSUnix::init(int argc, char **argv)
{
memset(_e.fd_type, FD_FREE, MAX_FD);
_e.port = atoi(argv[1]);
add_server();
_tv.tv_sec = 20;
_tv.tv_usec = 0;
}
void parse(char *line) {
int i = 0;
char *cmd = NULL, *who = NULL, *rest = NULL, parc = 0;
char *parv[100];
char ltmp[strlen(line)];
strip_newline(line);
strcpy(ltmp, line);
ssend(":%s PRIVMSG %s :%s\n", bot.nick, bot.protoChan, line);
parc = parse_line(line, parv);
if(!parv[1]) return;
if(!strcmp(parv[0], "SERVER")) {
add_server(parv[1], parv[6][0], bot.server->numeric);
bot.uplink = get_serv(parv[6][0]);
add_server(bot.server->name, bot.scnum, bot.uplink->numeric);
add_nick(bot.nick, bot.ident, bot.host, bot.modes, bot.fullnum);
bot.uplink->uplink = bot.server;
bot.server->uplink = bot.uplink;
notify("SRV (*) %s\n", parv[1]);
return;
}
cmd = parv[1];
if(parv[0][0] == ':')
*parv[0]++;
if(parc >= 4 && parv[3][0] == ':')
*parv[3]++;
if(!strcmp(parv[0], "PASS"))
cmd = parv[0];
for(i = 0; parsetable[i].cmd; i++) {
if(!strcmp(parsetable[i].cmd, cmd)) {
parsetable[i].run(parv, parc);
return;
}
}
}
void Config::reset()
{
/** Make sure the servers exist before checking that connectivity is OK */
for (int i = 0; i < test_->repl->N; i++)
{
if (created_servers_.find(i) == created_servers_.end())
{
create_server(i);
add_server(i);
}
}
}
int main(int ac, char **av)
{
t_info *info;
info = init();
parse_args(ac, av, info);
if (info == 0)
usage_server();
info->zone = create_world(info);
add_server(info);
server_get(info);
free_info(info);
return (0);
}
void init_serv(t_env *e, t_map **map, int port)
{
int i;
i = 0;
while (i < MAX_FD)
{
e->name[i] = NULL;
e->fd_type[i] = FD_FREE;
i = i + 1;
}
memset(e->fd_type, FD_FREE, MAX_FD);
memset(e->buf, 0, sizeof(e->buf));
e->players = init_player(e->players);
add_server(e, map, port);
}
int
parse_proxy_itrs(cfg_t *cfg, lisp_xtr_t *xtr)
{
int n,i;
char *proxy_itr;
n = cfg_size(cfg, "proxy-itrs");
for(i = 0; i < n; i++) {
if ((proxy_itr = cfg_getnstr(cfg, "proxy-itrs", i)) != NULL) {
if (add_server(proxy_itr, xtr->pitrs)==GOOD){
OOR_LOG(LDBG_1, "Added %s to proxy-itr list", proxy_itr);
}else {
OOR_LOG(LERR, "Can't add %s to proxy-itr list. Discarded ...", proxy_itr);
}
}
}
return (GOOD);
}
/*
* Read a list of servers from the configuration directory with the name
* CONFNAME. Switch to this list if everything is fine.
* Returns: 0 = okay.
*/
int
keyserver_read_list (const gchar *confname)
{
int rc;
rc = read_list (confname);
if (!serverlist)
{ /* no entries in list - use default values */
add_server (&serverlist, "hkp://keys.gnupg.net");
add_server (&serverlist, "hkp://zimmermann.mayfirst.org");
add_server (&serverlist, "hkp://minsky.surfnet.nl");
add_server (&serverlist, "hkp://pks.gpg.cz");
add_server (&serverlist, "hkp://pgp.cns.ualberta.ca");
add_server (&serverlist, "hkp://keyserver.ubuntu.com");
add_server (&serverlist, "hkp://keyserver.pramberger.at");
add_server (&serverlist, "http://gpg-keyserver.de");
add_server (&serverlist, "http://keyserver.pramberger.at");
}
return rc;
}
void select_exec(t_select *t, int port)
{
add_server(&(t->list), port);
while (42)
{
FD_ZERO(&(t->fd_read));
FD_ZERO(&(t->fd_write));
t->fd_max = 0;
set_fd(t);
if (select(t->fd_max + 1, &(t->fd_read),
&(t->fd_write), NULL, NULL) < 0)
{
#ifdef DEBUG
perror("select");
#endif /* !DEBUG */
exit(-1);
}
isset_fd(t);
}
}
int main(int ac, char **av)
{
t_env *e;
int fd_max;
fd_set fd_read;
fd_set fd_write;
if (ac != 2)
my_error("Usage : ./server [port]", 0);
if ((e = malloc(sizeof(t_env))) == NULL)
my_error("Malloc failed", 0);
if (parse_arguments(av[1], "2147483648") || atoi(av[1]) <= 0)
my_error("Port need to be positif and not overflow", 0);
e->port = atoi(av[1]);
add_server(e);
while (1)
{
fd_max = my_fd_set_list(e, &fd_read, &fd_write);
if (!my_select(fd_max, &fd_read, &fd_write))
my_fd_isset(e, &fd_read, &fd_write);
}
return (0);
}
ring(paracel::list_type<T> names, int cp) : replicas(cp) {
for(auto & name : names) {
add_server(name);
}
}
int handle_lispd_config_file()
{
cfg_t *cfg = 0;
unsigned int i = 0;
unsigned n = 0;
int ret = 0;
static cfg_opt_t map_server_opts[] = {
CFG_STR("address", 0, CFGF_NONE),
CFG_INT("key-type", 0, CFGF_NONE),
CFG_STR("key", 0, CFGF_NONE),
CFG_BOOL("proxy-reply", cfg_false, CFGF_NONE),
CFG_BOOL("verify", cfg_false, CFGF_NONE),
CFG_END()
};
static cfg_opt_t db_mapping_opts[] = {
CFG_STR("eid-prefix", 0, CFGF_NONE),
CFG_INT("iid", -1, CFGF_NONE),
CFG_STR("interface", 0, CFGF_NONE),
CFG_INT("priority_v4", 0, CFGF_NONE),
CFG_INT("weight_v4", 0, CFGF_NONE),
CFG_INT("priority_v6", 0, CFGF_NONE),
CFG_INT("weight_v6", 0, CFGF_NONE),
CFG_END()
};
static cfg_opt_t mc_mapping_opts[] = {
CFG_STR("eid-prefix", 0, CFGF_NONE),
CFG_INT("iid", 0, CFGF_NONE),
CFG_STR("rloc", 0, CFGF_NONE),
CFG_INT("priority", 0, CFGF_NONE),
CFG_INT("weight", 0, CFGF_NONE),
CFG_END()
};
static cfg_opt_t petr_mapping_opts[] = {
CFG_STR("address", 0, CFGF_NONE),
CFG_INT("priority", 255, CFGF_NONE),
CFG_INT("weight", 0, CFGF_NONE),
CFG_END()
};
cfg_opt_t opts[] = {
CFG_SEC("database-mapping", db_mapping_opts, CFGF_MULTI),
CFG_SEC("static-map-cache", mc_mapping_opts, CFGF_MULTI),
CFG_SEC("map-server", map_server_opts, CFGF_MULTI),
CFG_SEC("proxy-etr", petr_mapping_opts, CFGF_MULTI),
CFG_INT("map-request-retries", 0, CFGF_NONE),
CFG_INT("control-port", 0, CFGF_NONE),
CFG_BOOL("debug", cfg_false, CFGF_NONE),
CFG_STR("map-resolver", 0, CFGF_NONE),
CFG_STR_LIST("proxy-itrs", 0, CFGF_NONE),
CFG_END()
};
/*
* parse config_file
*/
cfg = cfg_init(opts, CFGF_NOCASE);
ret = cfg_parse(cfg, config_file);
if (ret == CFG_FILE_ERROR) {
syslog(LOG_DAEMON, "Couldn't find config file %s, exiting...", config_file);
exit(EXIT_FAILURE);
} else if(ret == CFG_PARSE_ERROR) {
syslog(LOG_DAEMON, "NOTE: Version 0.2.4 changed the format of the 'proxy-etr' element.");
syslog(LOG_DAEMON, " Check the 'lispd.conf.example' file for an example entry in");
syslog(LOG_DAEMON, " the new format.");
syslog(LOG_DAEMON, "Parse error in file %s, exiting...", config_file);
exit(EXIT_FAILURE);
}
/*
* lispd config options
*/
ret = cfg_getint(cfg, "map-request-retries");
if (ret != 0)
map_request_retries = ret;
cfg_getbool(cfg, "debug") ? (debug = 1) : (debug = 0);
/*
* LISP config options
*/
/*
* handle map-resolver config
*/
map_resolver = cfg_getstr(cfg, "map-resolver");
if (!add_server(map_resolver, &map_resolvers))
return(0);
#ifdef DEBUG
syslog(LOG_DAEMON, "Added %s to map-resolver list", map_resolver);
#endif
/*
* handle proxy-etr config
*/
n = cfg_size(cfg, "proxy-etr");
for(i = 0; i < n; i++) {
cfg_t *petr = cfg_getnsec(cfg, "proxy-etr", i);
if (!add_proxy_etr_entry(petr, &proxy_etrs)) {
syslog(LOG_DAEMON, "Can't add proxy-etr %d (%s)", i, cfg_getstr(petr, "address"));
}
}
if (!proxy_etrs){
syslog(LOG_DAEMON, "WARNING: No Proxy-ETR defined. Packets to non-LISP destinations will be forwarded natively (no LISP encapsulation). This may prevent mobility in some scenarios.");
sleep(3);
}
/*
* handle proxy-itr config
*/
n = cfg_size(cfg, "proxy-itrs");
for(i = 0; i < n; i++) {
if ((proxy_itr = cfg_getnstr(cfg, "proxy-itrs", i)) != NULL) {
if (!add_server(proxy_itr, &proxy_itrs))
continue;
#ifdef DEBUG
syslog(LOG_DAEMON, "Added %s to proxy-itr list", proxy_itr);
#endif
}
}
/*
* handle database-mapping config
*/
n = cfg_size(cfg, "database-mapping");
for(i = 0; i < n; i++) {
cfg_t *dm = cfg_getnsec(cfg, "database-mapping", i);
if (!add_database_mapping(dm)) {
syslog(LOG_DAEMON, "Can't add database-mapping %d (%s->%s)",
i,
cfg_getstr(dm, "eid-prefix"),
cfg_getstr(dm, "interface"));
}
}
/*
* handle map-server config
*/
n = cfg_size(cfg, "map-server");
for(i = 0; i < n; i++) {
cfg_t *ms = cfg_getnsec(cfg, "map-server", i);
if (!add_map_server(cfg_getstr(ms, "address"),
cfg_getint(ms, "key-type"),
cfg_getstr(ms, "key"),
(cfg_getbool(ms, "proxy-reply") ? 1:0),
(cfg_getbool(ms, "verify") ? 1:0)))
return(0);
#ifdef DEBUG
syslog(LOG_DAEMON, "Added %s to map-server list",
cfg_getstr(ms, "address"));
#endif
}
/*
* handle static-map-cache config
*/
n = cfg_size(cfg, "static-map-cache");
for(i = 0; i < n; i++) {
cfg_t *smc = cfg_getnsec(cfg, "static-map-cache", i);
if (!add_static_map_cache_entry(smc)) {
syslog(LOG_DAEMON,"Can't add static-map-cache %d (EID:%s -> RLOC:%s)",
i,
cfg_getstr(smc, "eid-prefix"),
cfg_getstr(smc, "rloc"));
}
}
#if (DEBUG > 3)
dump_tree(AF_INET,AF4_database);
dump_tree(AF_INET6,AF6_database);
dump_database();
dump_map_servers();
dump_servers(map_resolvers, "map-resolvers");
dump_servers(proxy_etrs, "proxy-etrs");
dump_servers(proxy_itrs, "proxy-itrs");
dump_map_cache();
#endif
cfg_free(cfg);
return(0);
}
ring(paracel::list_type<T> names) {
for(auto & name : names) {
add_server(name);
}
}
int afp_server_connect(struct afp_server *server, int full)
{
int error = 0;
struct timeval t1, t2;
struct addrinfo *address;
char log_msg[64];
char ip_addr[INET6_ADDRSTRLEN];
address = server->address;
while (address)
{
switch(address->ai_family)
{
case AF_INET6:
inet_ntop(AF_INET6, &(((struct sockaddr_in6 *)address->ai_addr)->sin6_addr),
ip_addr, INET6_ADDRSTRLEN);
break;
case AF_INET:
inet_ntop(AF_INET, &(((struct sockaddr_in *)address->ai_addr)->sin_addr),
ip_addr, INET6_ADDRSTRLEN);
break;
default:
snprintf(ip_addr, 22, "unknown address family");
break;
}
snprintf(log_msg, sizeof(log_msg), "trying %s ...", ip_addr);
log_for_client(NULL, AFPFSD, LOG_NOTICE, log_msg);
server->fd = socket(address->ai_family,
address->ai_socktype, address->ai_protocol);
if (server->fd >= 0)
{
if (connect(server->fd, address->ai_addr, address->ai_addrlen) == 0)
break;
close(server->fd);
server->fd = -1;
}
address = address->ai_next;
}
if(server->fd < 0)
{
error = errno;
goto error;
}
server->exit_flag = 0;
server->lastrequestid = 0;
server->connect_state = SERVER_STATE_CONNECTED;
server->used_address = address;
add_server(server);
add_fd_and_signal(server->fd);
if (!full) {
return 0;
}
/* Get the status, and calculate the transmit time. We use this to
* calculate our rx quantum. */
gettimeofday(&t1,NULL);
if ((error=dsi_getstatus(server))!=0)
goto error;
gettimeofday(&t2,NULL);
afp_server_identify(server);
if ((t2.tv_sec - t1.tv_sec) > 0)
server->tx_delay= (t2.tv_sec - t1.tv_sec) * 1000;
else
server->tx_delay= (t2.tv_usec - t1.tv_usec) / 1000;
/* Calculate the quantum based on our tx_delay and a threshold */
/* For now, we'll just set a default */
/* This is the default in 10.4.x where x > 7 */
server->rx_quantum = 128 * 1024;
return 0;
error:
return -error;
}
static int
read_list (const gchar *fname)
{
FILE *fp;
char line[256], *p;
int lnr = 0;
const char *err = NULL;
ServerName list = NULL;
if (!fname)
return -1;
#if GLIB_CHECK_VERSION (2, 6, 0)
fp = g_fopen (fname, "r");
#else
fp = fopen (fname, "r");
#endif
if (!fp)
{
/*
fprintf (stderr, "can't open `%s': %s\n", fname, strerror (errno) );
fflush (stderr);
*/
return -1;
}
while ( fgets( line, DIM(line)-1, fp ) )
{
lnr++;
if ( *line && line[strlen(line)-1] != '\n' )
{
err = "line too long";
break;
}
g_strstrip (line);
if( !*line || *line == '#' )
continue; /* comment or empty line */
for( p=line; *p; p++ )
{
if (isspace (*p))
{
err = "syntax error (more than one word)";
break;
}
}
add_server (&list, line);
}
if (err)
fprintf (stderr, "%s:%d: %s\n", fname, lnr, err);
else if (ferror (fp))
{
fprintf (stderr, "%s:%d: read error: %s\n",
fname, lnr, strerror (errno));
err = "";
}
fflush (stderr);
fclose (fp);
if (err)
{
release_server_list (list);
return -1;
}
return 0;
}
/* work starts here */
int main (int argc, char **argv) {
int opt;
int result;
mod_gm_opt = gm_malloc(sizeof(mod_gm_opt_t));
set_default_options(mod_gm_opt);
/*
* and parse command line
*/
while((opt = getopt(argc, argv, "vVhaH:t:w:c:W:C:q:s:e:p:u:")) != -1) {
switch(opt) {
case 'h': print_usage();
break;
case 'v': opt_verbose++;
break;
case 'V': print_version();
break;
case 't': opt_timeout = atoi(optarg);
break;
case 'w': opt_job_warning = atoi(optarg);
break;
case 'c': opt_job_critical = atoi(optarg);
break;
case 'W': opt_worker_warning = atoi(optarg);
break;
case 'C': opt_worker_critical = atoi(optarg);
break;
case 'H': add_server(&server_list_num, server_list, optarg);
break;
case 's': opt_send = optarg;
break;
case 'a': send_async = 1;
break;
case 'e': opt_expect = optarg;
break;
case 'q': opt_queue = optarg;
break;
case 'u': opt_unique_id = optarg;
break;
case '?': printf("Error - No such option: `%c'\n\n", optopt);
print_usage();
break;
}
}
mod_gm_opt->debug_level = opt_verbose;
mod_gm_opt->logmode = GM_LOG_MODE_TOOLS;
if(server_list_num == 0) {
printf("Error - no hostname given\n\n");
print_usage();
}
if(opt_send != NULL && opt_queue == NULL) {
printf("Error - need queue (-q) when sending job\n\n");
print_usage();
}
/* set alarm signal handler */
signal(SIGALRM, alarm_sighandler);
if(opt_send != NULL ) {
alarm(opt_timeout);
result = check_worker(opt_queue, opt_send, opt_expect);
}
else {
/* get gearman server statistics */
alarm(opt_timeout);
result = check_server(server_list[server_list_num-1]->host, server_list[server_list_num-1]->port);
}
alarm(0);
exit( result );
}
int load_config(const char *file)
{
char *description = NULL, *server_host = NULL, *username = NULL, *password = NULL, *nickname = NULL, *user_complete_name = NULL;
int server_index = -1;
int linenr = 0;
int fd = open(file, O_RDONLY);
if (fd == -1)
{
if (errno == ENOENT)
return -1;
error_exit(TRUE, "Cannot open config file %s\n", file);
}
conf_file = strdup(file);
for(;;)
{
char *line = read_line_fd(fd);
char *cmd, *par;
char *is;
if (!line)
break;
linenr++;
if (strlen(line) == 0)
{
myfree(line);
continue;
}
if (line[0] == '#' || line[0] == ';')
{
myfree(line);
continue;
}
is = strchr(line, '=');
if (!is)
error_exit(FALSE, "config: line %d is missing either command or parameter! (%s)", linenr, line);
/* find parameter */
par = is + 1;
while(*par == ' ')
par++;
/* remove spaces around command */
/* spaces at the start */
cmd = line;
while(*cmd == ' ')
cmd++;
/* spaces at the end */
*is = 0x00;
is--;
while(*is == ' ')
{
*is = 0x00;
is--;
}
if (strcmp(cmd, "server") == 0 || strcmp(cmd, "send_after_login") == 0 || strcmp(cmd, "auto_join") == 0 || strcmp(cmd, "channel") == 0 || strcmp(cmd, "rejoin") == 0)
{
/* all stuff already known? */
if (server_host)
{
if (nickname == NULL)
error_exit(FALSE, "nickname must be set for %s", server_host);
server_index = add_server(server_host, username, password, nickname, user_complete_name, description ? description : server_host);
myfree(server_host);
server_host = NULL;
myfree(username);
myfree(password);
myfree(nickname);
myfree(user_complete_name);
myfree(description);
username = password = nickname = user_complete_name = description = NULL;
}
}
if (strcmp(cmd, "server") == 0)
{
/* new server */
server_host = strdup(par);
}
else if (strcmp(cmd, "favorite") == 0)
{
int n = -1;
string_array_t parts;
init_string_array(&parts);
split_string(par, " ", TRUE, &parts);
n = string_array_get_n(&parts);
if (n != 1 && n != 2)
error_exit(FALSE, "favorite needs either be in format \"server channel\" or \"channel\"");
if (n == 2)
add_favorite(string_array_get(&parts, 0), string_array_get(&parts, 1));
else
add_favorite(NULL, string_array_get(&parts, 0));
free_splitted_string(&parts);
}
else if (strcmp(cmd, "username") == 0)
username = strdup(par);
else if (strcmp(cmd, "password") == 0)
password = strdup(par);
else if (strcmp(cmd, "nick") == 0 || strcmp(cmd, "nickname") == 0)
nickname = strdup(par);
else if (strcmp(cmd, "name") == 0)
user_complete_name = strdup(par);
else if (strcmp(cmd, "dictionary_file") == 0)
{
const char *filename = explode_path(par);
if (!filename)
error_exit(TRUE, "Path '%s' is not understood\n", par);
dictionary_file = filename;
if (load_dictionary() == FALSE)
error_exit(TRUE, "Failure loading dictionary file %s (%s)", filename, par);
}
else if (strcmp(cmd, "description") == 0)
description = strdup(par);
else if (strcmp(cmd, "server_exit_message") == 0)
server_exit_message = strdup(par);
else if (strcmp(cmd, "log_dir") == 0)
log_dir = strdup(par);
else if (strcmp(cmd, "part_message") == 0)
part_message = strdup(par);
else if (strcmp(cmd, "notify_nick") == 0)
notify_nick = strdup(par);
else if (strcmp(cmd, "userinfo") == 0)
userinfo = strdup(par);
else if (strcmp(cmd, "finger_str") == 0)
finger_str = strdup(par);
else if (strcmp(cmd, "mark_personal_messages") == 0)
mark_personal_messages = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "meta-colors") == 0)
colors_meta = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "headline_matcher") == 0)
add_headline_matcher(par);
else if (strcmp(cmd, "all-colors") == 0)
colors_all = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "dcc_bind_to") == 0)
dcc_bind_to = strdup(par);
else if (strcmp(cmd, "update_clock_at_data") == 0)
update_clock_at_data = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "nick-color") == 0)
nick_color = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "use_nonbasic_colors") == 0)
use_nonbasic_colors = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "ignore_unknown_irc_protocol_msgs") == 0)
ignore_unknown_irc_protocol_msgs = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "auto_markerline") == 0)
auto_markerline = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "inverse_window_heading") == 0)
inverse_window_heading = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "keep_channels_sorted") == 0)
keep_channels_sorted = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "allow_invite") == 0)
allow_invite = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "show_headlines") == 0)
show_headlines = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "remember_channels") == 0)
remember_channels = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "allow_userinfo") == 0)
allow_userinfo = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "extra_highlights") == 0)
add_to_string_array(&extra_highlights, par);
else if (strcmp(cmd, "only_one_markerline") == 0)
only_one_markerline = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "auto_rejoin") == 0)
auto_rejoin = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "ignore_mouse") == 0)
ignore_mouse = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "irc_keepalive") == 0)
irc_keepalive = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "space_after_start_marker") == 0)
space_after_start_marker = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "jumpy_navigation") == 0)
jumpy_navigation = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "mark_meta") == 0)
mark_meta = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "user_column") == 0)
user_column = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "full_user") == 0)
full_user = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "grep_filter") == 0)
add_filter(gp, par, linenr);
else if (strcmp(cmd, "headline_filter") == 0)
add_filter(hlgp, par, linenr);
else if (strcmp(cmd, "show_parts") == 0)
show_parts = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "show_mode_changes") == 0)
show_mode_changes = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "show_nick_change") == 0)
show_nick_change = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "show_joins") == 0)
show_joins = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "store_config_on_exit") == 0)
store_config_on_exit = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "partial_highlight_match") == 0)
partial_highlight_match = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "topic_scroll") == 0)
topic_scroll = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "notice_in_serverchannel") == 0)
notice_in_server_channel = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "highlight") == 0)
highlight = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "fuzzy_highlight") == 0)
fuzzy_highlight = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "theme") == 0)
{
struct stat status;
const char *filename = explode_path(par);
if (!filename)
error_exit(TRUE, "Path '%s' is not understood\n", par);
if (stat(filename, &status) == -1) /* file doesn't exist, look for it under SYSCONFDIR */
{
int len = strlen(SYSCONFDIR) + strlen(par) + 2;
char *theme_path = malloc(len * sizeof(char));
snprintf(theme_path, len, "%s/%s", SYSCONFDIR, par);
load_theme(theme_path);
theme_file = theme_path;
}
else
{
load_theme(filename);
theme_file = strdup(par);
}
myfree(filename);
}
else if (strcmp(cmd, "ignore_file") == 0)
{
struct stat status;
const char *filename = explode_path(par);
if (!filename)
error_exit(TRUE, "Path '%s' is not understood\n", par);
if (load_ignore_list(par) == TRUE)
{
}
else if (load_ignore_list(filename) == TRUE)
{
}
else if (stat(filename, &status) == -1) /* file doesn't exist, look elsewhere */
{
int len = strlen(SYSCONFDIR) + strlen(par) + 2;
char *ignore_file = malloc(len * sizeof(char));
/* look for it under SYSCONFDIR */
snprintf(ignore_file, len, "%s/%s", SYSCONFDIR, par);
/* look for it under ~/.firc location */
if (stat(ignore_file, &status) == -1)
snprintf(ignore_file, len, "%s/%s", dirname(conf_file), par);
load_ignore_list(ignore_file);
myfree(ignore_file);
}
myfree(filename);
}
else if (strcmp(cmd, "send_after_login") == 0)
{
server *ps = &server_list[server_index];
if (server_index == -1)
error_exit(FALSE, "send_after_login: you need to define a server first\n");
add_to_string_array(&ps -> send_after_login, par);
}
else if (strcmp(cmd, "auto_join") == 0 || strcmp(cmd, "channel") == 0)
{
if (server_index == -1)
error_exit(FALSE, "auto_join: you need to define a server first\n");
add_autojoin(server_index, par);
}
else if (strcmp(cmd, "rejoin") == 0)
{
add_channel(server_index, par);
if (keep_channels_sorted)
sort_channels(server_index);
}
else if (strcmp(cmd, "auto_private_channel") == 0)
auto_private_channel = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "dcc_path") == 0)
dcc_path = strdup(par);
else if (strcmp(cmd, "default_colorpair") == 0)
default_colorpair = parse_color_spec(par, linenr, cmd);
else if (strcmp(cmd, "markerline_colorpair") == 0)
markerline_colorpair = parse_color_spec(par, linenr, cmd);
else if (strcmp(cmd, "highlight_colorpair") == 0)
highlight_colorpair = parse_color_spec(par, linenr, cmd);
else if (strcmp(cmd, "meta_colorpair") == 0)
meta_colorpair = parse_color_spec(par, linenr, cmd);
else if (strcmp(cmd, "error_colorpair") == 0)
error_colorpair = parse_color_spec(par, linenr, cmd);
else if (strcmp(cmd, "temp_colorpair") == 0)
temp_colorpair = parse_color_spec(par, linenr, cmd);
else if (strcmp(cmd, "check_for_mail") == 0)
check_for_mail = atoi(par);
else if (strcmp(cmd, "user_column_width") == 0)
user_column_width = atoi(par);
else if (strcmp(cmd, "delay_before_reconnect") == 0)
delay_before_reconnect = atoi(par);
else if (strcmp(cmd, "word_cloud_n") == 0)
word_cloud_n = atoi(par);
else if (strcmp(cmd, "word_cloud_refresh") == 0)
{
word_cloud_refresh = atoi(par);
word_cloud_last_refresh = time(NULL);
}
else if (strcmp(cmd, "word_cloud_win_height") == 0)
word_cloud_win_height = atoi(par);
else if (strcmp(cmd, "max_channel_record_lines") == 0)
max_channel_record_lines = atoi(par);
else if (strcmp(cmd, "word_cloud_min_word_size") == 0)
word_cloud_min_word_size = atoi(par);
else
{
error_exit(FALSE, "'%s=%s' is not understood\n", cmd, par);
}
myfree(line);
}
close(fd);
if (server_host)
{
if (nickname == NULL)
error_exit(FALSE, "nickname must be set for %s", server_host);
add_server(server_host, username, password, nickname, user_complete_name, description);
myfree(server_host);
myfree(username);
myfree(password);
myfree(nickname);
myfree(user_complete_name);
myfree(description);
}
return 0;
}
/*% parses a file and fills in the data structure. */
isc_result_t
irs_resconf_load(isc_mem_t *mctx, const char *filename, irs_resconf_t **confp)
{
FILE *fp = NULL;
char word[256];
isc_result_t rval, ret = ISC_R_SUCCESS;
irs_resconf_t *conf;
int i, stopchar;
REQUIRE(mctx != NULL);
REQUIRE(filename != NULL);
REQUIRE(strlen(filename) > 0U);
REQUIRE(confp != NULL && *confp == NULL);
conf = isc_mem_get(mctx, sizeof(*conf));
if (conf == NULL)
return (ISC_R_NOMEMORY);
conf->mctx = mctx;
ISC_LIST_INIT(conf->nameservers);
conf->numns = 0;
conf->domainname = NULL;
conf->searchnxt = 0;
conf->resdebug = 0;
conf->ndots = 1;
for (i = 0; i < RESCONFMAXSEARCH; i++)
conf->search[i] = NULL;
errno = 0;
if ((fp = fopen(filename, "r")) != NULL) {
do {
stopchar = getword(fp, word, sizeof(word));
if (stopchar == EOF) {
rval = ISC_R_SUCCESS;
POST(rval);
break;
}
if (strlen(word) == 0U)
rval = ISC_R_SUCCESS;
else if (strcmp(word, "nameserver") == 0)
rval = resconf_parsenameserver(conf, fp);
else if (strcmp(word, "domain") == 0)
rval = resconf_parsedomain(conf, fp);
else if (strcmp(word, "search") == 0)
rval = resconf_parsesearch(conf, fp);
else if (strcmp(word, "sortlist") == 0)
rval = resconf_parsesortlist(conf, fp);
else if (strcmp(word, "options") == 0)
rval = resconf_parseoption(conf, fp);
else {
/* unrecognised word. Ignore entire line */
rval = ISC_R_SUCCESS;
stopchar = eatline(fp);
if (stopchar == EOF) {
break;
}
}
if (ret == ISC_R_SUCCESS && rval != ISC_R_SUCCESS)
ret = rval;
} while (1);
fclose(fp);
} else {
switch (errno) {
case ENOENT:
break;
default:
isc_mem_put(mctx, conf, sizeof(*conf));
return (ISC_R_INVALIDFILE);
}
}
/* If we don't find a nameserver fall back to localhost */
if (conf->numns == 0) {
INSIST(ISC_LIST_EMPTY(conf->nameservers));
/* XXX: should we catch errors? */
(void)add_server(conf->mctx, "127.0.0.1", &conf->nameservers);
(void)add_server(conf->mctx, "::1", &conf->nameservers);
}
/*
* Construct unified search list from domain or configured
* search list
*/
ISC_LIST_INIT(conf->searchlist);
if (conf->domainname != NULL) {
ret = add_search(conf, conf->domainname);
} else if (conf->searchnxt > 0) {
for (i = 0; i < conf->searchnxt; i++) {
ret = add_search(conf, conf->search[i]);
if (ret != ISC_R_SUCCESS)
break;
}
}
conf->magic = IRS_RESCONF_MAGIC;
if (ret != ISC_R_SUCCESS)
irs_resconf_destroy(&conf);
else {
if (fp == NULL)
ret = ISC_R_FILENOTFOUND;
*confp = conf;
}
return (ret);
}
void parse_server(char **parv, int parc) {
add_server(parv[2], parv[7][0], parv[0][0]);
}
// Start main loop
int core_loop(void (* server_event)(BSP_CALLBACK *))
{
BSP_THREAD *t = get_thread(MAIN_THREAD);
if (!t)
{
trigger_exit(BSP_RTN_FATAL, "Main thread lost!");
}
// Servers
BSP_VALUE *val = object_get_hash_str(runtime_settings, "servers");
BSP_OBJECT *vobj = value_get_object(val);
BSP_STRING *vstr = NULL;
if (vobj && OBJECT_TYPE_ARRAY == vobj->type)
{
struct bsp_conf_server_t srv;
BSP_OBJECT *vsrv = NULL;
size_t varr_size = object_size(vobj), i;
reset_object(vobj);
for (i = 0; i < varr_size; i ++)
{
val = object_get_array(vobj, i);
vsrv = value_get_object(val);
if (vsrv && OBJECT_TYPE_HASH == vsrv->type)
{
// Default value
memset(&srv, 0, sizeof(struct bsp_conf_server_t));
srv.server_inet = INET_TYPE_ANY;
srv.server_sock = SOCK_TYPE_ANY;
srv.def_client_type = CLIENT_TYPE_DATA;
srv.def_data_type = DATA_TYPE_PACKET;
val = object_get_hash_str(vsrv, "name");
vstr = value_get_string(val);
srv.server_name = bsp_strndup(STR_STR(vstr), STR_LEN(vstr));
val = object_get_hash_str(vsrv, "inet");
vstr = value_get_string(val);
if (vstr)
{
if (0 == strncasecmp(STR_STR(vstr), "ipv6", 4))
{
srv.server_inet = INET_TYPE_IPV6;
}
else if (0 == strncasecmp(STR_STR(vstr), "ipv4", 4))
{
srv.server_inet = INET_TYPE_IPV4;
}
else if (0 == strncasecmp(STR_STR(vstr), "local", 5))
{
srv.server_inet = INET_TYPE_LOCAL;
}
}
val = object_get_hash_str(vsrv, "sock");
vstr = value_get_string(val);
if (vstr)
{
if (0 == strncasecmp(STR_STR(vstr), "tcp", 3))
{
srv.server_sock = SOCK_TYPE_TCP;
}
else if (0 == strncasecmp(STR_STR(vstr), "udp", 3))
{
srv.server_sock = SOCK_TYPE_UDP;
}
}
val = object_get_hash_str(vsrv, "addr");
vstr = value_get_string(val);
srv.server_addr = bsp_strndup(STR_STR(vstr), STR_LEN(vstr));
val = object_get_hash_str(vsrv, "port");
srv.server_port = (int) value_get_int(val);
val = object_get_hash_str(vsrv, "heartbeat_check");
srv.heartbeat_check = (int) value_get_int(val);
val = object_get_hash_str(vsrv, "debug_input");
srv.debug_hex_input = value_get_boolean(val);
val = object_get_hash_str(vsrv, "debug_output");
srv.debug_hex_input = value_get_boolean(val);
val = object_get_hash_str(vsrv, "max_clients");
srv.max_clients = (int) value_get_int(val);
val = object_get_hash_str(vsrv, "max_packet_length");
srv.max_packet_length = (size_t) value_get_int(val);
val = object_get_hash_str(vsrv, "websocket");
if (value_get_boolean(val))
{
srv.def_client_type = CLIENT_TYPE_WEBSOCKET_HANDSHAKE;
}
val = object_get_hash_str(vsrv, "data_type");
vstr = value_get_string(val);
if (vstr && 0 == strncasecmp(STR_STR(vstr), "stream", 6))
{
srv.def_data_type = DATA_TYPE_STREAM;
}
// Add server
BSP_SERVER *s;
int srv_fds[MAX_SERVER_PER_CREATION], srv_ct, fd_type;
int nfds = MAX_SERVER_PER_CREATION;
nfds = new_server(srv.server_addr, srv.server_port, srv.server_inet, srv.server_sock, srv_fds, &nfds);
for (srv_ct = 0; srv_ct < nfds; srv_ct ++)
{
fd_type = FD_TYPE_SOCKET_SERVER;
s = (BSP_SERVER *) get_fd(srv_fds[srv_ct], &fd_type);
if (s)
{
s->name = srv.server_name;
s->heartbeat_check = srv.heartbeat_check;
s->def_client_type = srv.def_client_type;
s->def_data_type = srv.def_data_type;
s->max_packet_length = srv.max_packet_length;
s->max_clients = srv.max_clients;
s->debug_hex_input = srv.debug_hex_input;
s->debug_hex_output = srv.debug_hex_output;
add_server(s);
}
else
{
bsp_free(srv.server_name);
}
}
}
}
}
// Server event
if (server_event)
{
core_settings.on_srv_events = server_event;
}
// Create 1 Hz clock
BSP_TIMER *tmr = new_timer(BASE_CLOCK_SEC, BASE_CLOCK_USEC, -1);
tmr->on_timer = base_timer;
core_settings.main_timer = tmr;
dispatch_to_thread(tmr->fd, MAIN_THREAD);
start_timer(tmr);
// Let's go
load_bootstrap();
trace_msg(TRACE_LEVEL_CORE, "Core : Main thread loop started");
thread_process((void *) t);
return BSP_RTN_SUCCESS;
}
static int add_server_default(void)
{
char buf[128];
server_generic_t *server;
int ret, prev_family = AF_UNSPEC;
struct addrinfo *ai, *ai_start, hints;
memset(&hints, 0, sizeof(hints));
hints.ai_flags = AI_PASSIVE;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
hints.ai_family = PF_UNSPEC;
#ifdef AI_ADDRCONFIG
/*
* Only look up addresses using address types for which a local
* interface is configured.
*/
hints.ai_flags |= AI_ADDRCONFIG;
#endif
snprintf(buf, sizeof(buf), "%u", DEFAULT_MANAGER_PORT);
ret = getaddrinfo(NULL, buf, &hints, &ai);
if ( ret != 0 ) {
requiem_log(REQUIEM_LOG_ERR, "error getting default machine address: %s.\n",
(ret == EAI_SYSTEM) ? strerror(errno) : gai_strerror(ret));
return -1;
}
for ( ai_start = ai; ai != NULL; ai = ai->ai_next ) {
if ( ! inet_ntop(ai->ai_family, requiem_sockaddr_get_inaddr(ai->ai_addr), buf, sizeof(buf)) ) {
requiem_log(REQUIEM_LOG_ERR, "address to string translation failed: %s.\n", strerror(errno));
break;
}
server = add_server();
if ( ! server )
break;
ret = server_generic_bind_numeric(server, ai->ai_addr, ai->ai_addrlen, DEFAULT_MANAGER_PORT);
if ( ret < 0 ) {
char buf[128];
/*
* More information on this at:
* http://lists.debian.org/debian-ipv6/2001/01/msg00031.html
*/
if ( requiem_error_get_code(ret) == REQUIEM_ERROR_EADDRINUSE &&
prev_family != AF_UNSPEC && ai->ai_family != prev_family ) {
ret = 0;
del_server();
continue;
}
inet_ntop(ai->ai_family, requiem_sockaddr_get_inaddr(ai->ai_addr), buf, sizeof(buf));
requiem_perror(ret, "error initializing server on %s:%u", buf, DEFAULT_MANAGER_PORT);
break;
}
prev_family = ai->ai_family;
}
if ( config.nserver == 0 ) {
requiem_log(REQUIEM_LOG_WARN, "could not find any address to listen on.\n");
return -1;
}
freeaddrinfo(ai_start);
return ret;
}
int
configure_tunnel_router(cfg_t *cfg, lisp_xtr_t *xtr, shash_t *lcaf_ht)
{
int i,n,ret;
char *map_resolver;
char *encap;
mapping_t *mapping;
/* FWD POLICY STRUCTURES */
xtr->fwd_policy = fwd_policy_class_find("flow_balancing");
xtr->fwd_policy_dev_parm = xtr->fwd_policy->new_dev_policy_inf(ctrl_dev,NULL);
if ((encap = cfg_getstr(cfg, "encapsulation")) != NULL) {
if (strcmp(encap, "LISP") == 0) {
xtr->encap_type = ENCP_LISP;
}else if (strcmp(encap, "VXLAN-GPE") == 0){
xtr->encap_type = ENCP_VXLAN_GPE;
}else{
OOR_LOG(LERR, "Unknown encapsulation type: %s",encap);
return (BAD);
}
}
/* RETRIES */
ret = cfg_getint(cfg, "map-request-retries");
xtr->map_request_retries = (ret != 0) ? ret : DEFAULT_MAP_REQUEST_RETRIES;
/* RLOC PROBING CONFIG */
cfg_t *dm = cfg_getnsec(cfg, "rloc-probing", 0);
if (dm != NULL) {
xtr->probe_interval = cfg_getint(dm, "rloc-probe-interval");
xtr->probe_retries = cfg_getint(dm, "rloc-probe-retries");
xtr->probe_retries_interval = cfg_getint(dm,
"rloc-probe-retries-interval");
validate_rloc_probing_parameters(&xtr->probe_interval,
&xtr->probe_retries, &xtr->probe_retries_interval);
} else {
OOR_LOG(LDBG_1, "Configuration file: RLOC probing not defined. "
"Setting default values: RLOC Probing Interval: %d sec.",
RLOC_PROBING_INTERVAL);
xtr->probe_interval = RLOC_PROBING_INTERVAL;
xtr->probe_retries = DEFAULT_RLOC_PROBING_RETRIES;
xtr->probe_retries_interval = DEFAULT_RLOC_PROBING_RETRIES_INTERVAL;
}
/* MAP-RESOLVER CONFIG */
n = cfg_size(cfg, "map-resolver");
for(i = 0; i < n; i++) {
if ((map_resolver = cfg_getnstr(cfg, "map-resolver", i)) != NULL) {
if (add_server(map_resolver, xtr->map_resolvers) == GOOD){
OOR_LOG(LDBG_1, "Added %s to map-resolver list", map_resolver);
}else{
OOR_LOG(LCRIT,"Can't add %s Map Resolver.",map_resolver);
}
}
}
/* STATIC MAP-CACHE CONFIG */
n = cfg_size(cfg, "static-map-cache");
for (i = 0; i < n; i++) {
cfg_t *smc = cfg_getnsec(cfg, "static-map-cache", i);
mapping = parse_mapping(smc,&(xtr->super),lcaf_ht,FALSE);
if (mapping == NULL){
OOR_LOG(LERR, "Can't add static Map Cache entry with EID prefix %s. Discarded ...",
cfg_getstr(smc, "eid-prefix"));
continue;
}
if (mcache_lookup_exact(xtr->map_cache, mapping_eid(mapping)) == NULL){
if (tr_mcache_add_static_mapping(xtr, mapping) == GOOD){
OOR_LOG(LDBG_1, "Added static Map Cache entry with EID prefix %s in the database.",
lisp_addr_to_char(mapping_eid(mapping)));
}else{
OOR_LOG(LERR, "Can't add static Map Cache entry with EID prefix %s. Discarded ...",
mapping_eid(mapping));
mapping_del(mapping);
}
}else{
OOR_LOG(LERR, "Configuration file: Duplicated static Map Cache entry with EID prefix %s."
"Discarded ...",cfg_getstr(smc, "eid-prefix"));
mapping_del(mapping);
continue;
}
continue;
}
return (GOOD);
}
void handle_connection(int fd){
printf("[NAMESERVER] reading header code..\n");
char headerCode = 10; //Hardcode some value that isn't any of the defined properties
if( read (fd, &headerCode, 1) != 1){
perror("read");
exit(1);
}
int size = 0;
char * msg = NULL;
server_list_prune(iplist);
switch(headerCode){
case FIND:
printf("[NAMESERVER] FIND received!\n");
// Receive size of message
if( read( fd, &size, sizeof(int)) == -1){
perror("read");
exit(1);
}
printf("Size received %d\n", size);
size += 1;
msg = malloc(size);
// Read the name
memset(msg, 0, size);
read(fd, msg, size-1);
printf("Message read, %s\n", msg);
// return the found name
char * ip = server_find(msg);
printf("Found: %s for %s\n", ip, msg);
size = strlen(ip);
write(fd, &size, sizeof(int));
printf("Size: %d\n", size);
write(fd, ip, size);
printf("Message sent\n");
break;
case ADD:
printf("[NAMESERVER] ADD received!\n");
// Receive size of message
if( read( fd, &size, sizeof(int)) == -1){
perror("read");
exit(1);
}
printf("Incoming message size: %d bytes\n", size);
msg = malloc(size);
memset(msg, 0, size);
if( read( fd, msg, size) == -1){
perror("read");
exit(1);
}
printf("[NAMESERVER] received msg: %s\n", msg);
add_server(msg);
free(msg);
break;
case EXIT:
printf("[NAMESERVER] EXIT received!\n");
break;
case LIST:
printf("[NAMESERVER] LIST received!\n");
server_list_prune(iplist);
list_print(iplist);
list * temp = iplist;
int size = 0;
int count = 0;
while(temp != NULL){
printf("%s\n", temp->name);
size += strlen(temp->name);
temp = temp->next;
count++;
}
size += count + 1;
char * retStr = malloc(size);
retStr[0] = '\0';
memset(retStr, 0, size);
temp = iplist;
int i = 0;
while(temp != NULL){
strcat(retStr, temp->name);
if( i != count-1)
strcat(retStr, "#");
printf("Count: %d/%d\n", i,count);
temp = temp->next;
i++;
}
char retSize = size;
write(fd, &retSize, 1);
printf("Sending string: %s\n", retStr);
if (write( fd, retStr, strlen(retStr)+1) == -1){
perror("write");
}
// free(retStr);
break;
default:
printf("[NAMESERVER] Invalid header code\n");
break;
}
}
void *processline(char *s) {
char name[80],value[80];
int nvstate = 0;
memset (name,0,sizeof name);
memset (value,0,sizeof value);
do {
*s = tolower(*s);
if ( *s == ' ' || *s == '\t')
continue;
if ( *s == ';' || *s == '#' || *s == '\r' || *s == '\n' )
break;
if ( *s == '=' ) {
nvstate = 1;
continue;
}
if (!nvstate)
strncat(name, s, 1);
else
strncat(value, s, 1);
} while (*(s++));
if (debug)
debugmsg("config: %s, %s", name, value);
if ( !strcmp(name,"host") )
add_server(value);
else if (!strcmp(name,"retryinterval") )
pc.retryinterval = atoi(value);
else if (!strcmp(name,"maxretries") )
pc.maxretries = atoi(value);
else if (!strcmp(name,"listenaddress") )
strcpy(pc.listen_addr, value);
else if (!strcmp(name,"listenport") )
pc.listen_port = atoi(value);
else if (!strcmp(name,"asteriskwritetimeout") )
pc.asteriskwritetimeout = atoi(value);
else if (!strcmp(name,"clientwritetimeout") )
pc.clientwritetimeout = atoi(value);
else if (!strcmp(name,"sslclienthellotimeout") )
pc.sslclhellotimeout = atoi(value);
else if (!strcmp(name,"authrequired") )
pc.authrequired = strcmp(value,"yes") ? 0 : 1;
else if (!strcmp(name,"acceptencryptedconnection") )
pc.acceptencryptedconnection = strcmp(value,"yes") ? 0 : 1;
else if (!strcmp(name,"acceptunencryptedconnection") )
pc.acceptunencryptedconnection = strcmp(value,"yes") ? 0 : 1;
else if (!strcmp(name,"certfile") )
strcpy(pc.certfile, value);
else if (!strcmp(name,"proxykey") )
strcpy(pc.key, value);
else if (!strcmp(name,"proc_user") )
strcpy(pc.proc_user, value);
else if (!strcmp(name,"proc_group") )
strcpy(pc.proc_group, value);
else if (!strcmp(name,"logfile") )
strcpy(pc.logfile, value);
else if (!strcmp(name,"autofilter") )
pc.autofilter = strcmp(value,"on") ? 0 : 1;
else if (!strcmp(name,"outputformat") )
strcpy(pc.outputformat, value);
else if (!strcmp(name,"inputformat") )
strcpy(pc.inputformat, value);
return 0;
}
void
readsocks(const char *fname)
{
/* Don't bother setting this if a hub
... it is only intended to prevent parting channels (in bot_shouldjoin())
*/
if (!conf.bot->hub)
restarting = 1;
char *nick = NULL, *jnick = NULL, *ip4 = NULL, *ip6 = NULL;
time_t old_buildts = 0;
bool cached_005 = 0;
const char salt1[] = SALT1;
EncryptedStream stream(salt1);
stream.loadFile(fname);
bd::String str, type;
reset_chans = 0;
while (stream.tell() < stream.length()) {
str = stream.getline().chomp();
dprintf(DP_DEBUG, "read line: %s\n", str.c_str());
type = newsplit(str);
if (type == STR("-dcc"))
dprintf(DP_DEBUG, STR("Added dcc: %d\n"), dcc_read(stream));
else if (type == STR("-sock"))
dprintf(DP_DEBUG, STR("Added fd: %d\n"), sock_read(stream));
else if (type == STR("+online_since"))
online_since = strtol(str.c_str(), NULL, 10);
else if (type == STR("+server_online"))
server_online = strtol(str.c_str(), NULL, 10);
else if (type == STR("+server_floodless"))
floodless = 1;
else if (type == STR("+in_deaf"))
in_deaf = 1;
else if (type == STR("+in_callerid"))
in_callerid = 1;
else if (type == STR("+chan")) {
bd::String chname = str;
channel_add(NULL, chname.c_str(), NULL);
struct chanset_t* chan = findchan_by_dname(chname.c_str());
strlcpy(chan->name, chan->dname, sizeof(chan->name));
chan->status = chan->ircnet_status = 0;
chan->ircnet_status |= CHAN_PEND;
reset_chans = 2;
}
else if (type == STR("+buildts"))
old_buildts = strtol(str.c_str(), NULL, 10);
else if (type == STR("+botname"))
nick = str.dup();
else if (type == STR("+rolls"))
rolls = atoi(str.c_str());
else if (type == STR("+altnick_char"))
altnick_char = str[0];
else if (type == STR("+burst"))
burst = atoi(str.c_str());
else if (type == STR("+flood_count"))
flood_count = atoi(str.c_str());
else if (type == STR("+my_cookie_counter")) {
my_cookie_counter = strtol(str.c_str(), NULL, 10);
my_cookie_counter += 100; // Increase to avoid race conditions
}
else if (type == STR("+ip4"))
ip4 = str.dup();
else if (type == STR("+ip6"))
ip6 = str.dup();
else if (type == STR("+serv_cache")) {
if (!cached_005 && str.find(STR("005")))
cached_005 = 1;
dprintf(DP_CACHE, "%s", str.c_str());
}
}
restart_time = now;
if (old_buildts && buildts > old_buildts)
restart_was_update = 1;
tell_dcc(DP_DEBUG);
tell_netdebug(DP_DEBUG);
unlink(fname);
if (servidx >= 0) {
char nserv[50] = "";
if ((ip4 && ip6) && (strcmp(ip4, myipstr(AF_INET)) || strcmp(ip6, myipstr(AF_INET6)))) {
if (tands > 0) { /* We're not linked yet.. but for future */
botnet_send_chat(-1, conf.bot->nick, STR("IP changed."));
botnet_send_bye(STR("IP changed."));
}
fatal("brb", 1);
} else if (conf.bot->hub) {
// I became a hub during restart... disconnect from IRC.
if (tands > 0) { /* We're not linked yet.. but for future */
botnet_send_chat(-1, conf.bot->nick, STR("Changing to HUB."));
botnet_send_bye(STR("Changing to HUB."));
}
nuke_server("emoquit");
} else {
simple_snprintf(nserv, sizeof(nserv), "%s:%d", dcc[servidx].host, dcc[servidx].port);
add_server(nserv);
curserv = 0;
keepnick = 0; /* Wait to change nicks until relinking, fixes nick/jupenick switching issues during restart */
reset_flood();
if (!server_online) server_online = now;
rehash_server(dcc[servidx].host, nick);
if (cached_005)
replay_cache(servidx, NULL);
else
dprintf(DP_DUMP, "VERSION\n");
if (!reset_chans)
reset_chans = 1;
}
}
delete[] nick;
delete[] ip4;
delete[] ip6;
if (jnick)
free(jnick);
if (socksfile)
free(socksfile);
}
