home *** CD-ROM | disk | FTP | other *** search
/ Dream 52 / Amiga_Dream_52.iso / Linux / Divers / yagirc-0.51.tar.gz / yagirc-0.51.tar / yagirc-0.51 / commands.c < prev    next >
C/C++ Source or Header  |  1998-05-11  |  18KB  |  707 lines
  1. /*
  2.  
  3.  commands.c : Functions to all IRC /commands you can use
  4.  
  5.     Copyright (C) 1998 Timo Sirainen
  6.  
  7.     This program is free software; you can redistribute it and/or modify
  8.     it under the terms of the GNU General Public License as published by
  9.     the Free Software Foundation; either version 2 of the License, or
  10.     (at your option) any later version.
  11.  
  12.     This program is distributed in the hope that it will be useful,
  13.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.     GNU General Public License for more details.
  16.  
  17.     You should have received a copy of the GNU General Public License
  18.     along with this program; if not, write to the Free Software
  19.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20. */
  21.  
  22. #include <stdio.h>
  23. #include <string.h>
  24. #include <ctype.h>
  25.  
  26. #include <glib.h>
  27.  
  28. #include "os.h"
  29. #include "irc.h"
  30. #include "dcc.h"
  31. #include "network.h"
  32. #include "txt.h"
  33. #include "gui.h"
  34. #include "script.h"
  35. #include "params.h"
  36. #include "commands.h"
  37.  
  38. typedef int (*CALL_FUNC)(char *);
  39.  
  40. struct CMD_STRUCT
  41. {
  42.     char *name;
  43.     CALL_FUNC func;
  44. } CMD_STRUCT;
  45.  
  46. static struct CMD_STRUCT dcc_cmds[] =
  47. {
  48.     { "CHAT", (CALL_FUNC) dcc_chat },
  49.     { "SEND", (CALL_FUNC) dcc_send },
  50.     { "GET", (CALL_FUNC) dcc_get },
  51.     { "CHAT", (CALL_FUNC) dcc_chat },
  52.     { "LIST", (CALL_FUNC) dcc_list },
  53.     { "CLOSE", (CALL_FUNC) dcc_close },
  54.     { NULL, NULL }
  55. };
  56.  
  57. static char tmp[600];
  58.  
  59. static char *get_param(char **data)
  60. {
  61.     char *pos;
  62.  
  63.     g_return_val_if_fail(data != NULL, NULL);
  64.     g_return_val_if_fail(*data != NULL, NULL);
  65.  
  66.     pos = *data;
  67.     while (**data != '\0' && **data != ' ') (*data)++;
  68.     if (**data == ' ') *(*data)++ = '\0';
  69.  
  70.     return pos;
  71. }
  72.  
  73. int irccmd_server(char *data)
  74. {
  75.     SERVER_REC *serv, *oldserv;
  76.     char *ptr;
  77.     int port;
  78.     GList *tmp;
  79.  
  80.     g_return_val_if_fail(data != NULL, RET_ERR_PARAM);
  81.  
  82.     ptr = strchr(data, ':');
  83.     if (ptr == NULL)
  84.         port = 6667;
  85.     else
  86.     {
  87.         *ptr = '\0';
  88.         if (sscanf(ptr+1, "%d", &port) != 1) port = 6667;
  89.     }
  90.  
  91.     if (curwin->defserv == NULL)
  92.         oldserv = NULL;
  93.     else
  94.     {
  95.         /* disconnect from old irc server */
  96.         oldserv = curwin->defserv;
  97.         irc_server_disconnect(curwin->defserv);
  98.     }
  99.  
  100.     serv = irc_server_connect(data, port);
  101.     if (serv == NULL) return RET_ERROR;
  102.  
  103.     serv->defwin = curwin;
  104.     curwin->defserv = serv;
  105.  
  106.     /* put this to default server for all windows with no default servers yet */
  107.     for (tmp = g_list_first(winlist); tmp != NULL; tmp = tmp->next)
  108.     {
  109.         WINDOW_REC *win;
  110.  
  111.         win = (WINDOW_REC *) tmp->data;
  112.         if (win->defserv == NULL || win->defserv == oldserv)
  113.             win->defserv = curwin->defserv;
  114.     }
  115.  
  116.     irc_window_focus(curwin);
  117.  
  118.     return RET_OK;
  119. }
  120.  
  121. int irccmd_servers(char *data)
  122. {
  123.     GList *tmp;
  124.     g_return_val_if_fail(data != NULL, RET_ERR_PARAM);
  125.  
  126.     for (tmp = g_list_first(servlist); tmp != NULL; tmp = tmp->next)
  127.     {
  128.         SERVER_REC *serv;
  129.  
  130.         serv = (SERVER_REC *) tmp->data;
  131.         drawtext(curwin, TXT_TYPE_NOTICE, "server %d: %s\n", serv->handle, serv->name);
  132.     }
  133.  
  134.     return RET_OK;
  135. }
  136.  
  137. int irccmd_disconnect(char *data)
  138. {
  139.     g_return_val_if_fail(data != NULL, RET_ERR_PARAM);
  140.  
  141.     if (cserver == NULL)
  142.     {
  143.         /* we're not in any server yet.. */
  144.         return RET_NOT_CONNECTED;
  145.     }
  146.  
  147.     strcpy(tmp, "QUIT");
  148.     if (*data != '\0') sprintf(tmp+4, " :%s", data);
  149.     irc_send_cmd(cserver, tmp);
  150.     drawtext(curwin, TXT_TYPE_NOTICE, IRCTXT_DISCONNECTED, cserver->name, data);
  151.     irc_server_disconnect(cserver);
  152.     return RET_OK;
  153. }
  154.  
  155. int irccmd_quit(char *data)
  156. {
  157.     SERVER_REC *old;
  158.  
  159.     g_return_val_if_fail(data != NULL, RET_ERR_PARAM);
  160.  
  161.     /* disconnect from every server */
  162.     old = cserver;
  163.     while (servlist != NULL)
  164.     {
  165.         cserver = (SERVER_REC *) servlist->data;
  166.         irccmd_disconnect(*data != '\0' ? data : "leaving");
  167.     }
  168.     cserver = old;
  169.     gui_exit();
  170.  
  171.     return RET_OK;
  172. }
  173.  
  174. int irccmd_quote(char *data)
  175. {
  176.     g_return_val_if_fail(data != NULL, RET_ERR_PARAM);
  177.  
  178.     irc_send_cmd(cserver, data);
  179.     return RET_OK;
  180. }
  181.  
  182. int irccmd_join(char *data)
  183. {
  184.     SERVER_REC *server;
  185.     CHAN_REC *chan;
  186.     char *ptr, *next, *key;
  187.  
  188.     g_return_val_if_fail(data != NULL, RET_ERR_PARAM);
  189.  
  190.     if (*data == '\0')
  191.     {
  192. #ifdef USE_GUI
  193.         if (cserver != NULL)
  194.             gui_join_dialog(cserver);
  195. #else
  196.         return RET_NOT_ENOUGH_PARAMS;
  197. #endif
  198.     }
  199.     if (cserver == NULL || !cserver->connected) return RET_NOT_CONNECTED;
  200.  
  201.     for (next = data; next != NULL; data = next)
  202.     {
  203.         server = cserver;
  204.         next = strchr(data, ',');
  205.         if (next != NULL) *next++ = '\0';
  206.  
  207.         while (*data == ' ') data++;
  208.         if (*data == '\0') break;
  209.  
  210.         if (isdigit(*data))
  211.         {
  212.             /* server id */
  213.             char *digit = data;
  214.  
  215.             while (isdigit(*data)) data++;
  216.             if (*data != ' ')
  217.             {
  218.                 /* hm.. I think it was channel anyway.. */
  219.                 data = digit;
  220.             }
  221.             else
  222.             {
  223.                 int tag;
  224.  
  225.                 *data++ = '\0';
  226.                 if (sscanf(digit, "%d", &tag) == 1)
  227.                 {
  228.                     server = irc_get_server(tag);
  229.                     if (server == NULL)
  230.                     {
  231.                         /* no server has such id.. */
  232.                         continue;
  233.                     }
  234.                 }
  235.             }
  236.         }
  237.  
  238.         key = strchr(data, ' ');
  239.         if (key != NULL)
  240.         {
  241.             /* channel key */
  242.             *key++ = '\0';
  243.         }
  244.  
  245.         if (*data != '&' && *data != '#')
  246.         {
  247.             /* No # or & at start of channel so add # there.. */
  248.             ptr = (char *) g_malloc(strlen(data)+2);
  249.             sprintf(ptr, "#%s", data);
  250.             data = ptr;
  251.         }
  252.         else
  253.             ptr = NULL;
  254.  
  255.         chan = channel_joined(server, data);
  256.         if (chan != NULL)
  257.         {
  258.             /* already joined this channel, set it active.. */
  259.             if (curwin->curchan != chan)
  260.             {
  261.                 /* this channel wasn't previously selected in this window */
  262.                 drawtext(curwin, TXT_TYPE_NOTICE, IRCTXT_TALKING_IN, chan->name);
  263.             }
  264.             curwin->curchan = chan;
  265.             gui_select_channel(curwin, chan);
  266.             irc_window_focus(curwin);
  267.             if (ptr != NULL) g_free(ptr);
  268.             continue;
  269.         }
  270.  
  271.         /* Send JOIN command to server */
  272.         if (key != NULL)
  273.             sprintf(tmp, "JOIN %s %s", data, key);
  274.         else
  275.             sprintf(tmp, "JOIN %s", data);
  276.         irc_send_cmd(server, tmp);
  277.  
  278.         curwin->curchan = (CHAN_REC *) g_malloc(sizeof(CHAN_REC));
  279.         memset(curwin->curchan, 0, sizeof(CHAN_REC));
  280.         curwin->curchan->name = g_strdup(data);
  281.         curwin->curchan->topic = NULL;
  282.         curwin->curchan->nicks = NULL;
  283.         curwin->curchan->window = curwin;
  284.         curwin->curchan->server = server;
  285.         curwin->chanlist = g_list_append(curwin->chanlist, curwin->curchan);
  286.         gui_channel_join(curwin->curchan, NULL);
  287.  
  288.         if (ptr != NULL) g_free(ptr);
  289.     }
  290.  
  291.     return RET_OK;
  292. }
  293.  
  294. int irccmd_query(char *data)
  295. {
  296.     SERVER_REC *server;
  297.     CHAN_REC *chan;
  298.  
  299.     g_return_val_if_fail(data != NULL, RET_ERR_PARAM);
  300.  
  301.     if (*data == '\0') irccmd_unquery(""); /* remove current query */
  302.  
  303.     server = cserver;
  304.     if (isdigit(*data))
  305.     {
  306.         /* server id */
  307.         char *digit = data;
  308.  
  309.         while (isdigit(*data)) data++;
  310.         if (*data != ' ')
  311.         {
  312.             /* hm.. I think it was channel anyway.. */
  313.             data = digit;
  314.         }
  315.         else
  316.         {
  317.             int tag;
  318.  
  319.             *data++ = '\0';
  320.             if (sscanf(digit, "%d", &tag) == 1)
  321.             {
  322.                 server = irc_get_server(tag);
  323.                 if (server == NULL)
  324.                 {
  325.                     /* no server has such id.. */
  326.                     return RET_ERROR;
  327.                 }
  328.             }
  329.         }
  330.     }
  331.  
  332.     chan = channel_joined(server, data);
  333.     if (chan != NULL)
  334.     {
  335.         /* query already existed - change to query window */
  336.         if (curwin->curchan != chan)
  337.         {
  338.             /* this query wasn't previously selected in this window */
  339.             drawtext(curwin, TXT_TYPE_NOTICE, IRCTXT_QUERYING, chan->name);
  340.         }
  341.         curwin->curchan = chan;
  342.         irc_window_focus(curwin);
  343.         gui_select_channel(curwin, chan);
  344.         return RET_OK;
  345.     }
  346.  
  347.     curwin->curchan = (CHAN_REC *) g_malloc(sizeof(CHAN_REC));
  348.     memset(curwin->curchan, 0, sizeof(CHAN_REC));
  349.     curwin->curchan->name = g_strdup(data);
  350.     curwin->curchan->nicks = NULL;
  351.     curwin->curchan->topic = NULL;
  352.     curwin->curchan->window = curwin;
  353.     curwin->curchan->server = cserver;
  354.     curwin->chanlist = g_list_append(curwin->chanlist, curwin->curchan);
  355.     gui_channel_join(curwin->curchan, NULL);
  356.     return RET_OK;
  357. }
  358.  
  359. int irccmd_unquery(char *data)
  360. {
  361.     CHAN_REC *chan;
  362.  
  363.     g_return_val_if_fail(data != NULL, RET_ERR_PARAM);
  364.  
  365.     if (*data == '\0')
  366.         chan = curwin->curchan; /* remove current query */
  367.     else
  368.     {
  369.         chan = channel_joined(cserver, data);
  370.         if (chan == NULL)
  371.         {
  372.             drawtext(curwin, TXT_TYPE_NOTICE, IRCTXT_NO_QUERY, data);
  373.             return RET_ERROR;
  374.         }
  375.     }
  376.  
  377.     /* remove query */
  378.     if (chan == NULL || *chan->name == '#' || *chan->name == '&')
  379.         return RET_ERROR;
  380.  
  381.     irc_select_new_channel(curwin);
  382.     gui_channel_part(chan, NULL);
  383.     return RET_OK;
  384. }
  385.  
  386. int irccmd_whois(char *data)
  387. {
  388.     g_return_val_if_fail(data != NULL, RET_ERR_PARAM);
  389.  
  390.     if (*data == '\0') return RET_NOT_ENOUGH_PARAMS;
  391.  
  392.     sprintf(tmp, "WHOIS %s", data);
  393.     irc_send_cmd(cserver, tmp);
  394.  
  395.     return RET_OK;
  396. }
  397.  
  398. int irccmd_part(char *data)
  399. {
  400.     char *channame;
  401.     CHAN_REC *chan;
  402.  
  403.     g_return_val_if_fail(data != NULL, RET_ERR_PARAM);
  404.  
  405.     channame = get_param(&data);
  406.     if ((*channame == '\0' || strcmp(channame, "*") == 0) && curwin->curchan != NULL)
  407.         channame = curwin->curchan->name;
  408.  
  409.     if (*channame == '\0') return RET_NOT_ENOUGH_PARAMS;
  410.  
  411.     chan = channel_joined(cserver, channame);
  412.     if (chan == NULL) return RET_ERROR;
  413.  
  414.     sprintf(tmp, "PART %s", channame);
  415.  
  416.     if (data != NULL && *data != '\0')
  417.         sprintf(tmp+strlen(tmp), " :%s", data);
  418.  
  419.     irc_send_cmd(cserver, tmp);
  420.     return RET_OK;
  421. }
  422.  
  423. int irccmd_mode(char *data)
  424. {
  425.     char *channame;
  426.     CHAN_REC *chan;
  427.  
  428.     g_return_val_if_fail(data != NULL, RET_ERR_PARAM);
  429.  
  430.     channame = get_param(&data);
  431.     if (strcmp(channame, "*") == 0 && curwin->curchan != NULL)
  432.         channame = curwin->curchan->name;
  433.  
  434.     chan = channel_joined(cserver, channame);
  435.     if (*data == '\0') return RET_NOT_ENOUGH_PARAMS;
  436.  
  437.     sprintf(tmp, "MODE %s %s", channame, data);
  438.     irc_send_cmd(cserver, tmp);
  439.  
  440.     return RET_OK;
  441. }
  442.  
  443. int irccmd_msg(char *data)
  444. {
  445.     CHAN_REC *chan;
  446.     char *target;
  447.  
  448.     g_return_val_if_fail(data != NULL, RET_ERR_PARAM);
  449.  
  450.     target = get_param(&data);
  451.     if (*target == '\0' || *data == '\0') return RET_NOT_ENOUGH_PARAMS;
  452.  
  453.     chan = channel_joined(cserver, target);
  454.  
  455.     if (*target == '=')
  456.     {
  457.         /* dcc msg */
  458.         DCC_REC *dcc;
  459.  
  460.         dcc = dcc_find_item(DCC_TYPE_CHAT, ++target, NULL);
  461.         if (dcc == NULL)
  462.         {
  463.             drawtext(curwin, TXT_TYPE_DCC, IRCTXT_DCC_CHAT_NOT_FOUND, target);
  464.             return RET_ERROR;
  465.         }
  466.         drawtext(curwin, TXT_TYPE_DEFAULT, "[%5dcc%n(%6%s%n)] %s\n", target, data);
  467.         dcc_chat_write(dcc, data);
  468.         return RET_OK;
  469.     }
  470.  
  471.     if (cserver == NULL) return RET_NOT_CONNECTED;
  472.  
  473.     if (*target == '#' || *target == '&')
  474.     {
  475.         /* msg to channel */
  476.         if (chan != NULL && chan->window->curchan != NULL &&
  477.             strcasecmp(chan->window->curchan->name, target) == 0)
  478.             drawtext(chan->window, TXT_TYPE_DEFAULT, "<%0%s%n> %s\n", cserver->nick, data);
  479.         else
  480.             drawtext(curwin, TXT_TYPE_DEFAULT, "<%0%s%n:%2%s%n> %s\n", cserver->nick, target, data);
  481.     }
  482.     else
  483.     {
  484.         /* private message */
  485.         drawtext(chan == NULL ? curwin : chan->window, TXT_TYPE_DEFAULT,
  486.                  "[%5msg%n(%6%s%n)]%n %s\n", target, data);
  487.     }
  488.  
  489.     sprintf(tmp, "PRIVMSG %s :%s", target, data);
  490.     irc_send_cmd(cserver, tmp);
  491.  
  492.     return RET_OK;
  493. }
  494.  
  495. int irccmd_notice(char *data)
  496. {
  497.     CHAN_REC *chan;
  498.     char *target;
  499.  
  500.     g_return_val_if_fail(data != NULL, RET_ERR_PARAM);
  501.  
  502.     target = get_param(&data);
  503.     if (*target == '\0' || *data == '\0') return RET_NOT_ENOUGH_PARAMS;
  504.  
  505.     chan = channel_joined(cserver, target);
  506.  
  507.     if (cserver == NULL) return RET_NOT_CONNECTED;
  508.  
  509.     drawtext(chan != NULL ? chan->window : curwin, TXT_TYPE_DEFAULT,
  510.              "-%4notice%n(%3%s%n)-%n %s\n", target, data);
  511.  
  512.     sprintf(tmp, "NOTICE %s :%s", target, data);
  513.     irc_send_cmd(cserver, tmp);
  514.  
  515.     return RET_OK;
  516. }
  517.  
  518. int irccmd_me(char *data)
  519. {
  520.     g_return_val_if_fail(data != NULL, RET_ERR_PARAM);
  521.  
  522.     if (curwin->curchan == NULL) return RET_NOT_JOINED;
  523.  
  524.     drawtext(curwin->curchan->window, TXT_TYPE_DEFAULT, "%7 * %s %8%s\n",
  525.              cserver->nick, data);
  526.  
  527.     sprintf(tmp, "PRIVMSG %s :\001ACTION %s\001", curwin->curchan->name, data);
  528.     irc_send_cmd(cserver, tmp);
  529.  
  530.     return RET_OK;
  531. }
  532.  
  533. int irccmd_ctcp(char *data)
  534. {
  535.     CHAN_REC *chan;
  536.     char *ptr, *target;
  537.  
  538.     g_return_val_if_fail(data != NULL, RET_ERR_PARAM);
  539.  
  540.     target = get_param(&data);
  541.     if (*target == '\0' || *target == '\0') return RET_NOT_ENOUGH_PARAMS;
  542.  
  543.     chan = channel_joined(cserver, target);
  544.  
  545.     for (ptr = data; *ptr != '\0' && *ptr != ' '; ptr++)
  546.         *ptr = toupper(*ptr);
  547.  
  548.     drawtext(chan == NULL ? curwin : chan->window, TXT_TYPE_DEFAULT,
  549.              "[%5ctcp%n(%6%s%n)]%n %s\n", target, data);
  550.  
  551.     sprintf(tmp, "PRIVMSG %s :\001%s\001", target, data);
  552.     irc_send_cmd(cserver, tmp);
  553.  
  554.     return RET_OK;
  555. }
  556.  
  557. int irccmd_dcc(char *data)
  558. {
  559.     char *cmd;
  560.     int n;
  561.  
  562.     g_return_val_if_fail(data != NULL, RET_ERR_PARAM);
  563.  
  564.     cmd = get_param(&data);
  565.     if (*cmd == '\0') return RET_NOT_ENOUGH_PARAMS;
  566.  
  567.     for (n = 0; dcc_cmds[n].name != NULL; n++)
  568.     {
  569.         if (strcasecmp(dcc_cmds[n].name, cmd) == 0)
  570.             return dcc_cmds[n].func(data);
  571.     }
  572.  
  573.     drawtext(curwin, TXT_TYPE_DCC, IRCTXT_DCC_UNKNOWN_COMMAND, cmd);
  574.     return RET_OK;
  575. }
  576.  
  577. int irccmd_window(char *data)
  578. {
  579.     WINDOW_REC *win;
  580.     char *cmd;
  581.  
  582.     g_return_val_if_fail(data != NULL, RET_ERR_PARAM);
  583.  
  584.     cmd = get_param(&data);
  585.     if (*cmd == '\0') return RET_NOT_ENOUGH_PARAMS;
  586.  
  587.     while (*data == ' ') data++;
  588.     if (strcasecmp(cmd, "NEW") == 0)
  589.     {
  590.         char *spec;
  591.  
  592.         spec = get_param(&data);
  593.         if (*spec == '\0')
  594.             win = irc_window_new(cserver, NULL);
  595.         else if (strcasecmp(spec, "HIDE") == 0)
  596.             win = irc_window_new(cserver, curwin);
  597.     }
  598.     else if (strcasecmp(cmd, "CLOSE") == 0)
  599.     {
  600.         irc_window_close(curwin);
  601.     }
  602.     else if (strcasecmp(cmd, "GOTO") == 0)
  603.     {
  604.         int num;
  605.  
  606.         if (sscanf(get_param(&data), "%d", &num) == 1 && num > 0)
  607.         {
  608.             GList *tmp;
  609.  
  610.             tmp = g_list_nth(winlist, num-1);
  611.             if (tmp != NULL) gui_window_select((WINDOW_REC *) tmp->data);
  612.         }
  613.     }
  614.     else if (strcasecmp(cmd, "SERVER") == 0)
  615.     {
  616.         SERVER_REC *serv;
  617.         char *ptr;
  618.         int port;
  619.  
  620.         if (*data == '\0') return RET_NOT_ENOUGH_PARAMS;
  621.  
  622.         ptr = data;
  623.         while (*ptr >= '0' && *ptr <= '9') ptr++;
  624.         if (*ptr == '\0' && sscanf(data, "%d", &port) == 1)
  625.         {
  626.             /* try to change to already connected server */
  627.             serv = irc_get_server(port);
  628.             if (serv == NULL)
  629.             {
  630.                 /* server not found.. */
  631.                 drawtext(curwin, TXT_TYPE_NOTICE, IRCTXT_SERVER_NOT_FOUND, port);
  632.             }
  633.             else
  634.             {
  635.                 /* server selected */
  636.                 drawtext(curwin, TXT_TYPE_NOTICE, IRCTXT_SERVER_SELECTED,
  637.                          serv->handle, serv->name);
  638.             }
  639.         }
  640.         else
  641.         {
  642.             /* connect to server */
  643.             ptr = strchr(data, ':');
  644.             if (ptr == NULL)
  645.                 port = 6667;
  646.             else
  647.             {
  648.                 *ptr = '\0';
  649.                 if (sscanf(ptr+1, "%d", &port) != 1) port = 6667;
  650.             }
  651.             serv = irc_server_connect(data, port);
  652.         }
  653.         if (serv == NULL) return RET_ERROR;
  654.         irc_select_new_server_window(curwin);
  655.         serv->defwin = curwin;
  656.         curwin->defserv = serv;
  657.         irc_window_focus(curwin);
  658.         gui_update_statusbar(curwin);
  659.     }
  660.     else
  661.     {
  662.         drawtext(curwin, TXT_TYPE_ERROR, IRCTXT_WINDOW_UNKNOWN_CMD, cmd);
  663.         return RET_ERROR;
  664.     }
  665.  
  666.     return RET_OK;
  667. }
  668.  
  669. int irccmd_ison(char *data)
  670. {
  671.     g_return_val_if_fail(data != NULL, RET_ERR_PARAM);
  672.     if (*data == '\0') return RET_NOT_ENOUGH_PARAMS;
  673.  
  674.     if (cserver->ison_reqs > 0)
  675.         /* hm.. there's already /ISON going because of notify list check,
  676.            sending any /ISON's now would mess up notify list checks.. So,
  677.            I don't think it's so bad to ignore it right now? :) maybe message
  678.            to user, maybe change and make notify list differently, dunno,
  679.            works enough well now .. */
  680.         ;
  681.     else
  682.     {
  683.         sprintf(tmp, "ISON :%s", data);
  684.         irc_send_cmd(cserver, tmp);
  685.     }
  686.  
  687.     return RET_OK;
  688. }
  689.  
  690. int irccmd_load(char *data)
  691. {
  692. #ifdef USE_SCRIPT
  693.     return script_load(data);
  694. #else
  695.     return RET_OK;
  696. #endif
  697. }
  698.  
  699. int irccmd_unload(char *data)
  700. {
  701. #ifdef USE_SCRIPT
  702.     script_deinit();
  703. #endif
  704.     return RET_OK;
  705. }
  706.  
  707.