static void
global_user_list_cb (USER * user, struct guldata *data)
{
ASSERT (validate_user (user));
ASSERT (data != 0);
if (data->flags)
{
/* selectively display users based on user level/muzzle/cloak */
if (!
(((data->flags & ON_GFLAG_ADMIN) && user->level == LEVEL_ADMIN)
|| ((data->flags & ON_GFLAG_ELITE) && user->level == LEVEL_ELITE)
|| ((data->flags & ON_GFLAG_MODERATOR)
&& user->level == LEVEL_MODERATOR)
|| ((data->flags & ON_GFLAG_USERS) && user->level == LEVEL_USER)
|| ((data->flags & ON_GFLAG_LEECH) && user->level == LEVEL_LEECH)
|| ((data->flags & ON_GFLAG_MUZZLED) && user->muzzled)
|| ((data->flags & ON_GFLAG_CLOAKED) && user->cloaked)
|| ((data->flags & ON_GFLAG_USERIP) && (user->ip & data->mask) == (data->ip & data->mask))))
return;
}
if (data->server && *data->server != '*' &&
strcasecmp (data->server, user->server) != 0)
return; /* no match */
send_cmd (data->con, MSG_SERVER_GLOBAL_USER_LIST, "%s %s", user->nick,
my_ntoa (BSWAP32 (user->ip)));
}
int connect_port_ip(const int socket,const int ip,const unsigned short port){
//return 0 if succeed
struct sockaddr_in addr;
bzero((char*)&addr,sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = ip;
addr.sin_port=htons(port);
if(connect(socket,(struct sockaddr*)&addr,sizeof(addr))){
perror("connect");
fprintf(stderr,"target:%s\n",my_ntoa(ip));
exit(1);
return 1;
}
return 0;
}
unsigned int lookup_ip(const char *host)
{
struct hostent *he;
unsigned int ip;
log_message_level(LOG_LEVEL_SERVER, "lookup_ip: resolving %s", host);
/* check for dot-quad notation. Win95's gethostbyname() doesn't seem
to return the ip address properly for this case like every other OS */
ip = inet_addr(host);
if(ip == INADDR_NONE)
{
he = gethostbyname(host);
if(!he)
{
log_message_level(LOG_LEVEL_ERROR, "lookup_ip: can't find ip for host %s", host);
return 0;
}
memcpy(&ip, he->h_addr_list[0], he->h_length);
}
log_message_level(LOG_LEVEL_SERVER, "lookup_ip: %s is %s", host, my_ntoa(ip));
return ip;
}
int connect_send_close(const int ip,const unsigned short port,const char* buff,const size_t bufflen){
// return how many bytes sent
int socket = create_tcpsocket();
set_linger(socket);
int success = connect_port_ip(socket,ip,port);
if(success) {
perror("connect");
fprintf(stderr,"target:%s\n",my_ntoa(ip));
exit(1);
return 1;
}
size_t postsend=0,tmpsend;
while(postsend != bufflen){
tmpsend = write(socket,buff,bufflen);
if(tmpsend>0){
postsend+=tmpsend;
}else{
return postsend;
}
}
close(socket);
return postsend;
}
/*
* Figure out what kind of data we've got and do something about it.
*/
void got_packet(struct tcp_stream *ts, void **data)
{
int todiscard=0;
struct http_param *param=NULL;
switch (ts->nids_state) {
case NIDS_JUST_EST:
ts->server.collect = 1;
ts->client.collect = 1;
param=calloc(sizeof(struct http_param), 1);
assert(param);
param->host=strdup(my_ntoa(ts->addr.saddr));
*data=param;
break;
case NIDS_DATA:
if(ts->server.count_new!=0) {
todiscard=process(ts, SERVER_STREAM, ts->server, data);
}
if(ts->client.count_new!=0) {
todiscard=process(ts, CLIENT_STREAM, ts->client, data);
}
break;
case NIDS_CLOSE:
case NIDS_RESET:
case NIDS_TIMED_OUT:
param=*data;
if(param) {
/* Log automatically frees all the internal state */
log_request(param);
free_param(param);
free(param);
}
break;
}
nids_discard(ts, todiscard);
}
void stat_server_read(void)
{
int n;
char *p;
int do_close = 0;
char *salt, *servername;
n = READ(global.stat_server_fd, Buf, sizeof(Buf));
if(n <= 0)
{
if(n == -1)
logerr("stat_server_read", "read");
log_message_level( LOG_LEVEL_ERROR, "stat_server_read: got hangup");
do_close = 1;
}
else
{
/* find end of line */
p = strpbrk(Buf, "\r\n");
if(*p)
*p = 0;
p = Buf;
n = atoi(Buf);
if(n == 220)
{
/* got connect
* first, save the salt */
next_arg(&p);
salt = next_arg(&p);
if(!salt)
{
log_message_level( LOG_LEVEL_ERROR, "stat_server_read:unable to get salt string");
strcpy(Buf, "QUIT\r\n");
WRITE(global.stat_server_fd, Buf, strlen(Buf));
}
else
{
if(stat_server_salt)
FREE(stat_server_salt);
stat_server_salt = STRDUP(salt);
snprintf(Buf, sizeof(Buf), "USER %s\r\n", global.stat_user);
WRITE(global.stat_server_fd, Buf, strlen(Buf));
}
}
else if(n == 221)
{
/* server hangup */
do_close = 1;
}
else if(n == 300)
{
struct md5_ctx md;
char hash[33];
md5_init_ctx(&md);
md5_process_bytes(stat_server_salt, strlen(stat_server_salt), &md);
md5_process_bytes(global.stat_pass, strlen(global.stat_pass), &md);
md5_finish_ctx(&md, hash);
expand_hex(hash, 16);
hash[32] = 0;
snprintf(Buf, sizeof(Buf), "PASS %s\r\n", hash);
WRITE(global.stat_server_fd, Buf, strlen(Buf));
}
else if(n == 201)
{
/* auth complete */
log_message_level( LOG_LEVEL_SERVER, "stat_server_read: logged in");
/* send updated ip:port in case we are a dynamic server */
snprintf(Buf, sizeof(Buf), "IPPORT %s %s %d\r\n",global.report_name, global.report_ip, global.report_port);
WRITE(global.stat_server_fd, Buf, strlen(Buf));
/* force immediate update */
stat_server_push();
}
/* The >= comparison made the comparison for == 400 some
lines below not to work any more. So dynamic server
addresses are not updated any more.
But this solution is cumbersome - to say the least.
Is there any better - and ofc any quicker detection
of an ip address change possible? Now it takes up
to stats_click seconds for a hub to recognize the
change.
*/
else if(n / 100 > 4)
{
/* something failed */
log_message_level( LOG_LEVEL_SERVER, "stat_server_read:%s", Buf);
strcpy(Buf, "QUIT\r\n");
WRITE(global.stat_server_fd, Buf, strlen(Buf));
}
/* this part is needed if a server owner wants to use an alias
usually server aliases are not resolvable - leodav
*/
else if(n == 400)
{
servername = lookup_hostname2();
log_message_level( LOG_LEVEL_SERVER, "stat_server_read:%s", Buf);
strcpy(Buf, "QUIT\r\n");
WRITE(global.stat_server_fd, Buf, strlen(Buf));
global.serverIP = lookup_ip(servername);
global.report_ip = STRDUP(my_ntoa(global.serverIP));
log_message_level( LOG_LEVEL_ERROR, "napigator.c:debug: %s", servername);
}
else if(n == 200)
{
/* stats updated successfully */
}
else
{
log_message_level( LOG_LEVEL_ERROR, "stat_server_read: unhandled:%s", Buf);
}
}
if(do_close)
{
log_message_level( LOG_LEVEL_SERVER, "stat_server_read: closing connection");
CLOSE(global.stat_server_fd);
#if HAVE_POLL
remove_fd(global.stat_server_fd);
#else
FD_CLR(global.stat_server_fd, &global.read_fds);
FD_CLR(global.stat_server_fd, &global.write_fds);
#endif
global.stat_server_fd = INVALID_SOCKET;
}
}
