outbound.c

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

	free (file);

	if (i == 0)
		return TRUE;
	return FALSE;
}
#endif

int
cmd_me (struct session *sess, char *tbuf, char *word[], char *word_eol[])
{
	char *act = word_eol[2];

	if (!(*act))
		return FALSE;

	sprintf (tbuf, "\001ACTION %s\001\r", act);
	/* first try through DCC CHAT */
	if (dcc_write_chat (sess->channel, tbuf))
	{
		/* print it to screen */
		channel_action (sess, tbuf, sess->channel, sess->server->nick,
								act, TRUE);
	} else
	{
		/* DCC CHAT failed, try through server */
		if (sess->server->connected)
		{
			sprintf (tbuf, "PRIVMSG %s :\001ACTION %s\001\r\n", sess->channel,
						act);
			tcp_send (sess->server, tbuf);
			/* print it to screen */
			channel_action (sess, tbuf, sess->channel, sess->server->nick,
									act, TRUE);
		} else
		{
			notc_msg (sess);
		}
	}

	return TRUE;
}

int
cmd_msg (struct session *sess, char *tbuf, char *word[], char *word_eol[])
{
	char *nick = word[2];
	char *msg = word_eol[3];
	struct session *newsess;

	if (*nick)
	{
		if (*msg)
		{
			if (strcmp (nick, ".") == 0)
			{							  /* /msg the last nick /msg'ed */
				if (sess->lastnick[0])
					nick = sess->lastnick;
			} else
				strcpy (sess->lastnick, nick);	/* prime the last nick memory */

			if (*nick == '=')
			{
				nick++;
				if (!dcc_write_chat (nick, msg))
				{
					EMIT_SIGNAL (XP_TE_NODCC, sess, NULL, NULL, NULL, NULL, 0);
					return TRUE;
				}
			} else
			{
				if (!sess->server->connected)
				{
					notc_msg (sess);
					return TRUE;
				}
				sprintf (tbuf, "PRIVMSG %s :%s\r\n", nick, msg);
				tcp_send (sess->server, tbuf);
			}
			newsess = find_session_from_channel (nick, sess->server);
			if (newsess)
				channel_msg (newsess->server, tbuf, newsess->channel,
						newsess->server->nick, msg, TRUE);
			else
				EMIT_SIGNAL (XP_TE_MSGSEND, sess, nick, msg, NULL, NULL, 0);

			return TRUE;
		}
	}
	return FALSE;
}

int
cmd_names (struct session *sess, char *tbuf, char *word[], char *word_eol[])
{
	if (*word[2])
		sprintf (tbuf, "NAMES %s\r\n", word[2]);
	else
		sprintf (tbuf, "NAMES %s\r\n", sess->channel);
	tcp_send (sess->server, tbuf);
	return TRUE;
}

int
cmd_nctcp (struct session *sess, char *tbuf, char *word[], char *word_eol[])
{
	if (*word[2] && *word_eol[3])
	{
		sprintf (tbuf, "NOTICE %s :\001%s\001\r\n", word[2], word_eol[3]);
		tcp_send (sess->server, tbuf);
		return TRUE;
	}
	return FALSE;
}

int
cmd_newserver (struct session *sess, char *tbuf, char *word[],
					char *word_eol[])
{
	sess = new_ircwindow (NULL, NULL, SESS_SERVER);
	cmd_server (sess, tbuf, word, word_eol);
	return TRUE;
}

int
cmd_nick (struct session *sess, char *tbuf, char *word[], char *word_eol[])
{
	char *nick = word[2];
	if (*nick)
	{
		if (sess->server->connected)
		{
			sprintf (tbuf, "NICK %s\r\n", nick);
			tcp_send (sess->server, tbuf);
		} else
			user_new_nick (sess->server, sess->server->nick, nick, TRUE);
		return TRUE;
	}
	return FALSE;
}

int
cmd_notice (struct session *sess, char *tbuf, char *word[], char *word_eol[])
{
	if (*word[2] && *word_eol[3])
	{
		sprintf (tbuf, "NOTICE %s :%s\r\n", word[2], word_eol[3]);
		tcp_send (sess->server, tbuf);
		EMIT_SIGNAL (XP_TE_NOTICESEND, sess, word[2], word_eol[3], NULL, NULL,
						 0);
		return TRUE;
	}
	return FALSE;
}

int
cmd_notify (struct session *sess, char *tbuf, char *word[], char *word_eol[])
{
	int i = 1;

	if (*word[2])
	{
		while (1)
		{
			i++;
			if (!*word[i])
				break;
			if (notify_deluser (word[i]))
			{
				EMIT_SIGNAL (XP_TE_DELNOTIFY, sess, word[i], NULL, NULL, NULL, 0);
				return TRUE;
			}
			notify_adduser (word[i]);
			EMIT_SIGNAL (XP_TE_ADDNOTIFY, sess, word[i], NULL, NULL, NULL, 0);
		}
	} else
		notify_showlist (sess);
	return TRUE;
}

int
cmd_op (struct session *sess, char *tbuf, char *word[], char *word_eol[])
{
	int i = 2;

	while (1)
	{
		if (!*word[i])
		{
			if (i == 2)
				return FALSE;
			send_channel_modes (sess, tbuf, word, 2, i, '+', 'o');
			return TRUE;
		}
		i++;
	}
}

int
cmd_part (struct session *sess, char *tbuf, char *word[], char *word_eol[])
{
	char *chan = word[2];
	char *reason = word_eol[3];
	if (!*chan)
		chan = sess->channel;
	if ((*chan) && is_channel (sess->server, chan))
	{
		server_sendpart (sess->server, chan, reason);
		return TRUE;
	}
	return FALSE;
}

int
cmd_ping (struct session *sess, char *tbuf, char *word[], char *word_eol[])
{
	unsigned long tim;
	char *to = word[2];

	tim = make_ping_time ();

	if (*to)
		sprintf (tbuf, "PRIVMSG %s :\001PING %lu\001\r\n", to, tim);
	else
		sprintf (tbuf, "PING %lu\r\n", tim);
		/*sprintf (tbuf, "PING %lu :%s\r\n", tim, sess->server->servername);*/
	tcp_send (sess->server, tbuf);

	return TRUE;
}

int
cmd_query (struct session *sess, char *tbuf, char *word[], char *word_eol[])
{
	char *nick = word[2];
	if (*nick)
	{
		if (!find_dialog (sess->server, nick))
			new_ircwindow (sess->server, nick, SESS_DIALOG);
		return TRUE;
	}
	return FALSE;
}

int
cmd_quote (struct session *sess, char *tbuf, char *word[], char *word_eol[])
{
	int len;
	char *raw = word_eol[2];
	if (*raw)
	{
		len = strlen (raw);
		if (len < 4094)
		{
			tcp_send_len (sess->server, tbuf, sprintf (tbuf, "%s\r\n", raw));
		} else
		{
			tcp_send_len (sess->server, raw, len);
			tcp_send_len (sess->server, "\r\n", 2);
		}
		return TRUE;
	}
	return FALSE;
}

int
cmd_reconnect (struct session *sess, char *tbuf, char *word[], char *word_eol[])
{
	int tmp = prefs.recon_delay;
	GSList *list;
	server *serv;

	prefs.recon_delay = 0;

	if (!strcasecmp (word[2], "ALL"))
	{
		list = serv_list;
		while (list)
		{
			serv = list->data;
			if (serv->connected)
				auto_reconnect (serv, TRUE, -1);
			list = list->next;
		}
	}	
	/* If it isn't "ALL" and there is something 
	there it *should* be a server they are trying to connect to*/
	else if (*word[2])
	{
		int offset = 0;
#ifdef USE_OPENSSL
		int use_ssl = FALSE;

		if (strcmp (word[2], "-ssl") == 0)
		{
			use_ssl = TRUE;
			offset++;	/* args move up by 1 word */
		}
		sess->server->use_ssl = use_ssl;
		sess->server->accept_invalid_cert = TRUE;
#endif

		if (*word[4+offset])
			safe_strcpy (sess->server->password, word[4+offset], sizeof (sess->server->password));
		if (*word[3+offset])
			sess->server->port = atoi (word[3+offset]);
		safe_strcpy (sess->server->hostname, word[2+offset], sizeof (sess->server->hostname));
		auto_reconnect (sess->server, TRUE, -1);
	}
	else
	{
		auto_reconnect (sess->server, TRUE, -1);
	}	
	prefs.recon_delay = tmp;

	return TRUE;
}

#ifdef USE_PLUGIN
int
cmd_rmdll (struct session *sess, char *tbuf, char *word[], char *word_eol[])
{
	char *dllname = word[2];

	if (module_unload (dllname, sess) == 0)
		return TRUE;
	return FALSE;
}
#endif

int
cmd_say (struct session *sess, char *tbuf, char *word[], char *word_eol[])
{
	char *speech = word_eol[2];
	if (*speech)
	{
		channel_msg (sess->server, tbuf, sess->channel, sess->server->nick,
						 speech, TRUE);
		sprintf (tbuf, "PRIVMSG %s :%s\r\n", sess->channel, speech);
		tcp_send (sess->server, tbuf);
		return TRUE;
	}
	return FALSE;
}

int
cmd_settab (struct session *sess, char *tbuf, char *word[], char *word_eol[])
{
	if (*word_eol[2])
	{
		strcpy (tbuf, sess->channel);
		safe_strcpy (sess->channel, word_eol[2], CHANLEN);
		fe_set_channel (sess);
		strcpy (sess->channel, tbuf);
	}

	return TRUE;
}

int
cmd_server (struct session *sess, char *tbuf, char *word[], char *word_eol[])
{
	int offset = 0;
	char *server;
	char *port;
	char *pass;
	char *co;
#ifdef USE_OPENSSL
	int use_ssl = FALSE;

	if (strcmp (word[2], "-ssl") == 0)
	{
		use_ssl = TRUE;
		offset++;	/* args move up by 1 word */
	}
#endif

	server = word[2 + offset];
	port = word[3 + offset];
	pass = word[4 + offset];

	if (!(*server))
		return FALSE;

#ifdef USE_OPENSSL
	if (strncasecmp ("ircs://", server, 7) == 0)
	{
		use_ssl = TRUE;
		server += 7;
		goto urlserv;
	}
#endif

	/* dont clear it for /servchan */
	if (strncasecmp (word[1], "SERVCHAN ", 9))
		sess->willjoinchannel[0] = 0;

	if (strncasecmp ("irc://", server, 6) == 0)
	{
		server += 6;
#ifdef USE_OPENSSL
urlserv:
#endif
		/* check for port */
		co = strchr (server, ':');
		if (co)
		{
			port = co + 1;
			*co = 0;
			pass = word[3 + offset];
		} else
			co = server;
		/* check for channel - mirc style */
		co = strchr (co + 1, '/');
		if (co)
		{
			*co = 0;
			co++;
			if (*co == '#')
			{
				safe_strcpy (sess->willjoinchannel, co, CHANLEN);
			} else
			{
				sess->willjoinchannel[0] = '#';
				strncpy (sess->willjoinchannel + 1, co, CHANLEN);
				sess->willjoinchannel[CHANLEN-1] = 0;
			}
		}
	}

	if (*pass)
		strcpy (sess->server->password, pass);
#ifdef USE_OPENSSL
	sess->server->use_ssl = use_ssl;
	sess->server->accept_invalid_cert = TRUE;
#endif

	if (*port)
	{
		connect_server (sess, server, atoi (port), FALSE);
	} else {
#ifdef USE_OPENSSL
		if (use_ssl)
			connect_server (sess, server, 994, FALSE);
		else
#endif
			connect_server (sess, server, 6667, FALSE);
	}
	return TRUE;
}

int
cmd_servchan (struct session *sess, char *tbuf, char *word[],
				  char *word_eol[])
{
	int offset = 0;

#ifdef USE_OPENSSL
	if (strcmp (word[2], "-ssl") == 0)
		offset++;
#endif

	if (*word[4 + offset])
	{
		strcpy (sess->willjoinchannel, word[4 + offset]);
		return cmd_server (sess, tbuf, word, word_eol);
	}

	return FALSE;
}

struct timercommand
{
	session *sess;
	char *cmd;
};

static int
timer_timeout (struct timercommand *tr)
{
	if (is_session (tr->sess))
		handle_command (tr->cmd, tr->sess, 0, 0);
	free (tr->cmd);
	free (tr);
	return 0;
}

int
cmd_timer (struct session *sess, char *tbuf, char *word[], char *word_eol[])
{
	struct timercommand *tr;

	if (!*word_eol[3])
		return FALSE;

	tr = malloc (sizeof (struct timercommand));
	tr->sess = sess;
	tr->cmd = strdup (word_eol[3]);

	fe_timeout_add (atoi (word[2]) * 1000, timer_timeout, tr);

	return TRUE;
}

int
cmd_topic (struct session *sess, char *tbuf, char *word[], char *word_eol[])
{
	char *topic = word_eol[2];
	if (*topic)
		sprintf (tbuf, "TOPIC %s :%s\r\n", sess->channel, topic);
	else
		sprintf (tbuf, "TOPIC %s\r\n", sess->channel);
	tcp_send (sess->server, tbuf);
	return TRUE;
}

int
cmd_unignore (struct session *sess, char *tbuf, char *word[],
				  char *word_eol[])
{
	char *mask = word[2];
	char *arg = word[3];
	if (*mask)
	{
		if (ignore_del (mask, NULL))
		{
			if (strcasecmp (arg, "QUIET"))
				EMIT_SIGNAL (XP_TE_IGNOREREMOVE, sess, mask, NULL, NULL, NULL, 0);
		}
		return TRUE;
	}
	return FALSE;
}

int
cmd_userlist (struct session *sess, char *tbuf, char *word[],
				  char *word_eol[])
{
	struct User *user;
	GSList *list;
	int lt;

	list = sess->userlist;
	while (list)
	{
		user = list->data;
		lt = time (0) - user->lasttalk;
		if (!user->lasttalk)
			lt = 0;
		sprintf (tbuf,
					"\00306%s\t\00314[\00310%-38s\00314] \017ov\0033=\017%d%d lt\0033=\017%d\n",
					user->nick, user->hostname, user->op, user->voice, lt);
		PrintText (sess, tbuf);
		list = list->next;
	}

	return TRUE;
}

int
cmd_wallchop (struct session *sess, char *tbuf, char *word[],
				  char *word_eol[])
{
	int i = 0;
	struct User *user;
	GSList *list;

	if (*word_eol[2])
	{
		strcpy (tbuf, "NOTICE ");
		list = sess->userlist;
		while (list)
		{
			user = (struct User *) list->