inbound.c

The major functionality added in this release includes: - Rootless mode in X11 - Widget Templt

		sess->end_of_names = FALSE;
		clear_user_list (sess);
	}

	while (1)
	{
		switch (*names)
		{
		case 0:
			name[pos] = 0;
			if (pos != 0)
				add_name (sess, name, 0);
			return;
		case ' ':
			name[pos] = 0;
			pos = 0;
			add_name (sess, name, 0);
			break;
		default:
			name[pos] = *names;
			if (pos < (NICKLEN-1))
				pos++;
		}
		names++;
	}
}

static void
topic (server *serv, char *buf)
{
	session *sess;
	char *po, *new_topic;

	po = strchr (buf, ' ');
	if (po)
	{
		po[0] = 0;
		sess = find_session_from_channel (buf, serv);
		if (sess)
		{
			new_topic = strip_color (po + 2);
			set_topic (sess, new_topic);
			free (new_topic);
			EMIT_SIGNAL (XP_TE_TOPIC, sess, buf, po + 2, NULL, NULL, 0);
		}
	}
}

static void
new_topic (server *serv, char *nick, char *chan, char *topic)
{
	struct session *sess = find_session_from_channel (chan, serv);
	if (sess)
	{
		set_topic (sess, topic);
		EMIT_SIGNAL (XP_TE_NEWTOPIC, sess, nick, topic, chan, NULL, 0);
	}
}

static void
user_joined (server *serv, char *chan, char *user, char *ip)
{
	struct session *sess = find_session_from_channel (chan, serv);

	if (EMIT_SIGNAL (XP_JOIN, serv, chan, user, ip, NULL, 0) == 1)
		return;

	if (sess)
	{
		if (!fe_is_confmode (sess))
			EMIT_SIGNAL (XP_TE_JOIN, sess, user, chan, ip, NULL, 0);
		add_name (sess, user, ip);
	}
}

static void
user_kicked (server *serv, char *chan, char *user, char *kicker, char *reason)
{
	struct session *sess = find_session_from_channel (chan, serv);
	if (sess)
	{
		EMIT_SIGNAL (XP_TE_KICK, sess, kicker, user, chan, reason, 0);
		sub_name (sess, user);
	}
}

static void
user_parted (struct server *serv, char *chan, char *user, char *ip,
				 char *reason)
{
	struct session *sess = find_session_from_channel (chan, serv);
	if (sess)
	{
		if (!fe_is_confmode (sess))
		{
			if (*reason)
				EMIT_SIGNAL (XP_TE_PARTREASON, sess, user, ip, chan, reason, 0);
			else
				EMIT_SIGNAL (XP_TE_PART, sess, user, ip, chan, NULL, 0);
		}
		sub_name (sess, user);
	}
}

static void
channel_date (session *sess, char *chan, char *timestr)
{
	long n = atol (timestr);
	char *tim = ctime (&n);
	tim[19] = 0;	/* get rid of the \n */
	EMIT_SIGNAL (XP_TE_CHANDATE, sess, chan, tim, NULL, NULL, 0);
}

static void
topic_nametime (server *serv, char *chan, char *nick, char *date)
{
	long n = atol (date);
	char *tim = ctime (&n);
	struct session *sess = find_session_from_channel (chan, serv);
	tim[19] = 0;	/* get rid of the \n */
	EMIT_SIGNAL (XP_TE_TOPICDATE, sess, chan, nick, tim, NULL, 0);
}

void
set_server_name (struct server *serv, char *name)
{
	GSList *list = sess_list;
	struct session *sess;

	if (name[0] == 0)
		name = serv->hostname;

	strcpy (serv->servername, name);
	while (list)
	{
		sess = (struct session *) list->data;
		if (sess->server == serv)
			fe_set_title (sess);
		list = list->next;
	}
	if (serv->front_session->type == SESS_SERVER)
	{
		safe_strcpy (serv->front_session->channel, name, CHANLEN);
		fe_set_channel (serv->front_session);
	}
}

static void
user_quit (server *serv, char *nick, char *ip, char *reason)
{
	GSList *list = sess_list;
	struct session *sess;
	int was_on_front_session = FALSE;

	while (list)
	{
		sess = (struct session *) list->data;
		if (sess->server == serv)
		{
 			if (sess == menu_sess)
 				was_on_front_session = TRUE;
			if (sub_name (sess, nick))
			{
				if (!fe_is_confmode (sess))
					EMIT_SIGNAL (XP_TE_QUIT, sess, nick, reason, ip, NULL, 0);
			} else if (sess->type == SESS_DIALOG && !strcasecmp (sess->channel, nick))
			{
				EMIT_SIGNAL (XP_TE_QUIT, sess, nick, reason, ip, NULL, 0);
			}
		}
		list = list->next;
	}

	notify_set_offline (serv, nick, was_on_front_session);
}

static void
got_ping_reply (struct session *sess, char *outbuf,
					 char *timestring, char *from)
{
	unsigned long tim, nowtim, dif;
	int lag = 0;

	if (strncmp (timestring, "LAG", 3) == 0)
	{
		timestring += 3;
		lag = 1;
	}

	sscanf (timestring, "%lu", &tim);
	nowtim = make_ping_time ();
	dif = nowtim - tim;

	sess->server->ping_recv = time (0);

	if (lag)
	{
		sess->server->lag_sent = 0;
		sprintf (outbuf, "%ld.%ld", dif / 1000000, (dif / 100000) % 10);
		fe_set_lag (sess->server, (int)((float)atof (outbuf) * 10.0));
		return;
	}

	if (atol (timestring) == 0)
	{
		if (sess->server->lag_sent)
			sess->server->lag_sent = 0;
		else
			EMIT_SIGNAL (XP_TE_PINGREP, sess, from, "?", NULL, NULL, 0);
	} else
	{
		sprintf (outbuf, "%ld.%ld%ld", dif / 1000000, (dif / 100000) % 10, dif % 10);
		EMIT_SIGNAL (XP_TE_PINGREP, sess, from, outbuf, NULL, NULL, 0);
	}
}

static session *
find_session_from_type (int type, server *serv)
{
	session *sess;
	GSList *list = sess_list;
	while (list)
	{
		sess = list->data;
		if (sess->type == type && serv == sess->server)
			return sess;
		list = list->next;
	}
	return 0;
}

static void
notice (struct server *serv, char *outbuf, char *to, char *nick, char *msg,
		  char *ip)
{
	char *po,*ptr=to;
	struct session *sess = 0;

	if (is_channel (serv, ptr))
		sess = find_session_from_channel (ptr, serv);

	if (!sess && ptr[0] == '@')
	{
		ptr++;
		sess = find_session_from_channel (ptr, serv);
	}
	
	if (!sess)
	{
		ptr = 0;
		if (prefs.notices_tabs) {
			int stype = strcmp(nick, ip) ? SESS_NOTICES : SESS_SNOTICES;
			sess = find_session_from_type (stype, serv);
			if (!sess)
			{
				register unsigned int oldh = prefs.hideuserlist;
				prefs.hideuserlist = 1;
				if (stype == SESS_NOTICES)
					sess = new_ircwindow (serv, "(notices)", SESS_NOTICES);
				else
					sess = new_ircwindow (serv, "(snotices)", SESS_SNOTICES);
				prefs.hideuserlist = oldh;
				fe_set_channel (sess);
				fe_set_title (sess);
				fe_set_nonchannel (sess, FALSE);
				clear_user_list (sess);
				if (prefs.logging)
					setup_logging (sess);
			}
			/* Avoid redundancy with some Undernet notices */
			if (!strncmp (msg, "*** Notice -- ", 14))
				msg += 14;
		} else
		{
			sess = find_session_from_nick (nick, serv);
		}
		if (!sess)
			sess = serv->front_session;
	}

	if (msg[0] == 1)
	{
		msg++;
		if (!strncmp (msg, "PING", 4))
		{
			got_ping_reply (sess, outbuf, msg + 5, nick);
			return;
		}
	}
	po = strchr (msg, '\001');
	if (po)
		po[0] = 0;
	if (ptr)
		EMIT_SIGNAL (XP_TE_CHANNOTICE, sess, nick, to, msg, NULL, 0);
	else
		EMIT_SIGNAL (XP_TE_NOTICE, sess, nick, msg, NULL, NULL, 0);
}

static void
handle_away (server *serv, char *nick, char *msg)
{
	struct away_msg *away = find_away_message (serv, nick);
	struct session *sess = NULL;

	if (away && !strcmp (msg, away->message))	/* Seen the msg before? */
	{
		if (prefs.show_away_once && !serv->inside_whois)
			return;
	} else
	{
		save_away_message (serv, nick, msg);
	}

	if (!serv->inside_whois)
		sess = find_session_from_nick (nick, serv);
	if (!sess)
		sess = serv->front_session;

	EMIT_SIGNAL (XP_TE_WHOIS5, sess, nick, msg, NULL, NULL, 0);
}

static int
end_of_names (server *serv, char *chan)
{
	struct session *sess;
	GSList *list;

	if (!strcmp (chan, "*"))
	{
		list = sess_list;
		while (list)
		{
			sess = (struct session *) list->data;
			if (sess->server == serv)
			{
				sess->end_of_names = TRUE;
				sess->ignore_names = FALSE;
			}
			list = list->next;
		}
		return TRUE;
	}
	sess = find_session_from_channel (chan, serv);
	if (sess)
	{
		sess->end_of_names = TRUE;
		sess->ignore_names = FALSE;
		return TRUE;
	}
	return FALSE;
}

static void
check_willjoin_channels (struct server *serv, char *tbuf)
{
	char *po;
	struct session *sess;
	GSList *list = sess_list;
	while (list)
	{
		sess = (struct session *) list->data;
		if (sess->server == serv)
		{
			if (sess->willjoinchannel[0] != 0)
			{
				strcpy (sess->waitchannel, sess->willjoinchannel);
				sess->willjoinchannel[0] = 0;
				if (sess->channelkey[0] == '\0')
					sprintf (tbuf, "JOIN %s\r\n", sess->waitchannel);
				else
					sprintf (tbuf, "JOIN %s %s\r\n", sess->waitchannel,
								sess->channelkey);
				tcp_send (serv, tbuf);
				po = strchr (sess->waitchannel, ',');
				if (po)
					*po = 0;
			}
		}
		list = list->next;
	}
}

static void
next_nick (struct session *sess, char *outbuf, char *nick)
{
	sess->server->nickcount++;

	switch (sess->server->nickcount)
	{
	case 2:
		sprintf (outbuf, "NICK %s\r\n", prefs.nick2);
		tcp_send (sess->server, outbuf);
		EMIT_SIGNAL (XP_TE_NICKCLASH, sess, nick, prefs.nick2, NULL, NULL, 0);

		break;

	case 3:
		sprintf (outbuf, "NICK %s\r\n", prefs.nick3);
		tcp_send (sess->server, outbuf);
		EMIT_SIGNAL (XP_TE_NICKCLASH, sess, nick, prefs.nick3, NULL, NULL, 0);

		break;

	default:
		EMIT_SIGNAL (XP_TE_NICKFAIL, sess, NULL, NULL, NULL, NULL, 0);
	}
}

void
do_dns (struct session *sess, char *tbuf, char *nick, char *host)
{
	char *po;

	po = strrchr (host, '@');
	if (po)
		host = po + 1;
	EMIT_SIGNAL (XP_TE_RESOLVINGUSER, sess, nick, host, NULL, NULL, 0);
	sprintf (tbuf, "/exec %s %s", prefs.dnsprogram, host);
	handle_command (tbuf, sess, 0, 0);
}

static void
set_default_modes (server * serv, char *outbuf)
{
	int mode = FALSE;

	if (prefs.wallops)
	{
		sprintf (outbuf, "MODE %s +w", serv->nick);
		mode = TRUE;
	}
	if (prefs.servernotice)
	{
		if (mode)
			strcat (outbuf, "s");
		else
		{
			sprintf (outbuf, "MODE %s +s", serv->nick);
			mode = TRUE;
		}
	}
	if (prefs.invisible)
	{
		if (mode)
			strcat (outbuf, "i");
		else
		{
			sprintf (outbuf, "MODE %s +i", serv->nick);
			mode = TRUE;
		}
	}
	if (mode)
	{
		strcat (outbuf, "\r\n");
		tcp_send (serv, outbuf);
	}
}

static void
process_numeric (server * serv, session * sess, char *outbuf, int n,
					  char *word[], char *word_eol[], char *text)
{
	session *realsess;

	switch (n)
	{
	case 1:
		user_new_nick (serv, serv->nick, word[3], TRUE);
		set_server_name (serv, word_eol[1]);
		if (sess->type == SESS_SERVER && prefs.logging)
			setup_logging (sess);
		/* reset our away status */
		if (serv->reconnect_away)
		{
			handle_command ("/away", serv->front_session, FALSE, FALSE);
			serv->reconnect_away = FALSE;
		}
		goto def;
	case 4:	/* check the ircd type */
		serv->is_newtype = FALSE;
		serv->six_modes = FALSE;
		if (strncmp (word[5], "bahamut", 7) == 0)				/* DALNet */
		{
			serv->is_newtype = TRUE;		/* use the /list args */
		} else if (strncmp (word[5], "u2.10.", 6) == 0)		/* Undernet */
		{
			serv->is_newtype = TRUE;		/* use the /list args */
			serv->six_modes = TRUE;			/* allow 6 modes per line */
		}
		goto def;
	case 5:
		handle_005 (serv, word);
		goto def;
	case 301:
		handle_away (serv, word[4],
				(word_eol[5][0] == ':') ? word_eol[5] + 1 : word_eol[5]);
		break;
	case 303:
		word[4]++;
		notify_markonline (serv, word);
		break;
	case 305:
		serv->is_away = FALSE;
		serv->reconnect_away = FALSE;
		fe_set_away (serv);
		goto def;
	case 306:
		serv->is_away = TRUE;
		serv->away_time = time (NULL);
		fe_set_away (serv);
		goto def;
	case 312:
		EMIT_SIGNAL (XP_TE_WHOIS3, sess, word[4], word_eol[5], NULL, NULL, 0);
		break;
	case 311:
		serv->inside_whois = 1;
		/* FALL THROUGH */
	case 314:
		EMIT_SIGNAL (XP_TE_WHOIS1, sess,
						 word[4], word[5],
						 word[6], word_eol[8] + 1, 0);
		break;
	case 317:
		{
			long n = atol (word[6]);
			long idle = atol (word[5]);
			char *tim;
			sprintf (outbuf, "%02ld:%02ld:%02ld", idle / 3600, (idle / 60) % 60,
						idle % 60);
			if (n == 0)
				EMIT_SIGNAL (XP_TE_WHOIS4, serv->front_session,
								 word[4], outbuf, NULL, NULL, 0);
			else
			{
				tim = ctime (&n);
				tim[19] = 0; 	/* get rid of the \n */
				EMIT_SIGNAL (XP_TE_WHOIS4T, serv->front_session,
								 word[4], outbuf, tim, NULL, 0);
			}
		}
		break;
	case 318:
		serv->inside_whois = 0;
		EMIT_SIGNAL (XP_TE_WHOIS6, serv->front_session, word[4], NULL,
						 NULL, NULL, 0);
		break;
	case 313: