/*    /daemon/intermud.c
 *    from the Dead Souls LPC Library
 *    daemon handling the InterMUD-3 Protocol
 *    created by Descartes of Borg 950506
 *    Version: @(#) intermud.c 1.7@(#)
 *    Last modified: 96/12/14
 */

#ifndef __PACKAGE_SOCKETS__
#error You should not try and load /daemon/intermud.c with no sockets package.
#else

#include <lib.h>
#include <dirs.h>
#include <logs.h>
#include <privs.h>
#include <save.h>
#include <daemons.h>
#include <commands.h>
#include NETWORK_H
#include ROOMS_H
#include "include/intermud.h"

inherit LIB_CLIENT;

static private int Password;
private mapping MudList, ChannelList;
private mapping Banned;
private mixed *Nameservers;
private static int Tries;
private static int SocketStat = -1;
private static int Online = 0;
private static string my_ip;
static string SaveFile;

mapping ExtraInfo();
void ConvertLists();
int GetStatus(string mud);
static mixed SetStatus(string mud, int status);

static void create(){
    client::create();
    Password = SECRETS_D->GetSecret("I3_SERVER_PW");
    SaveFile = save_file(SAVE_INTERMUD);
    tn("INTERMUD_D: prev: "+identify(previous_object(-1)),"red");
    Tries = 0;
    Banned = ([]);
    MudList = ([]);
    ChannelList = ([]);
    MudList["ID"] = -1;
    MudList["List"] = ([]);
    ChannelList["ID"] = -1;
    ChannelList["List"] = ([]);
    if(file_exists(SaveFile)){
        RestoreObject(SaveFile, 1);
    }
    ConvertLists();
    Nameservers = ({ ({ "*dalet", "97.107.133.86 8787" }) });
    SetNoClean(1);
    tn("INTERMUD_D reloaded.");
    tn("Loading object stack: "+get_stack(),"red");
    tn("Loading object trail: "+identify(previous_object(-1)),"red");
    SetDestructOnClose(1);
    SetSocketType(MUD);
    if(DISABLE_INTERMUD == 1){
        call_out( (: eventDestruct :), 2);
    }
    else call_out( (: Setup :), 2);
}

void FirstPing(){
    PING_D->eventPing();
}

static void Setup(){
    string ip;
    int port;

    if( !Nameservers || !sizeof(Nameservers) ) return;
    sscanf(Nameservers[0][1], "%s %d", ip, port);
    SocketStat = eventCreateSocket(ip, port);
    if( SocketStat < 0 ) return;
    tn("INTERMUD_D: SocketStat: "+SocketStat);
    eventWrite( ({ "startup-req-3", 5, mud_name(), 0, Nameservers[0][0], 0,
                Password, MudList["ID"], ChannelList["ID"], query_host_port(),
                PORT_OOB, PORT_UDP, mudlib() + " " + mudlib_version(), 
                mudlib() + " " + mudlib_version(), version(), "LPMud",
                MUD_STATUS, ADMIN_EMAIL,
                SERVICES_D->GetServices(), ExtraInfo() }) );
    tn("INTERMUD_D setup: "+identify( ({
                    "startup-req-3", 5, mud_name(), 0, Nameservers[0][0], 0,
                    Password, MudList["ID"], ChannelList["ID"], query_host_port(),
                    PORT_OOB, PORT_UDP, mudlib() + " " + mudlib_version(),
                    mudlib() + " " + mudlib_version(), version(), "LPMud",
                    MUD_STATUS, ADMIN_EMAIL,
                    SERVICES_D->GetServices(), ([]) }) ), "red");;
    call_out( (: FirstPing :), 5);
    call_out( (: load_object :), 5, IMC2_D);
}

int GetConnectedStatus(){
    return Online;
}

void eventClearVars(){
    if( !(master()->valid_apply(({ PRIV_ASSIST, INTERMUD_D }))) )
        error("Illegal attempt to reset intermud: "+get_stack()+" "+identify(previous_object(-1)));
    Tries = 0;
    MudList = ([]);
    ChannelList = ([]);
    MudList["ID"] = -1;
    MudList["List"] = ([]);
    ChannelList["ID"] = -1;
    ChannelList["List"] = ([]);
    SaveObject(SaveFile);
}

static void eventRead(mixed *packet){
    mixed val;
    string cle;
    int mudpacket;
    Online = 1;

    if( !packet || sizeof(packet) < 6 ) return; /* should send error */
    if( Banned[packet[2]] ){

        eventWrite(({ "error", 5, mud_name(), 0, packet[2],
                    packet[3], "unk-user", 
                    "Your mud is not allowed to send to "+mud_name()+".",
                    packet }));

        return;
    }
    switch(packet[0]){
        case "startup-reply":
            LOG_D->LogSpecial(LOG_I3,timestamp()+" "+identify(packet)+"\n");
            tn("INTERMUD_D: "+identify(packet),"red");
            if( sizeof(packet) != 8 ){
                //tn("We don't like the mudlist packet size.","red");
                return;  
            }
            if( !sizeof(packet[6]) ){
                //tn("We don't like an absence of packet element 6.","red");
                return;
            }
            /* Start of Tricky's patch */
            if( packet[2] != Nameservers[0][0] ){
                tn("Illegal startup-reply from mud " + packet[2], "red");
                return;
            }
            /* End of Tricky's patch */ 
            if( packet[6][0][0] == Nameservers[0][0] ){
                Nameservers = packet[6];
                Password = packet[7];
                SECRETS_D->SetSecret("I3_SERVER_PW", Password);
                SaveObject(SaveFile);
            }
            else {
                Nameservers = packet[6];
                Setup();
            }
            return;
        case "mudlist":
            tn("INTERMUD_D mudlist received.","red");
            //log_file(LOG_I3,identify(packet),1);
            if( sizeof(packet) != 8 ){
                //tn("We don't like the mudlist packet size.","red");
                return;  
            }
            if( packet[6] == MudList["ID"] )  {
                //tn("We don't like packet element 6. It is: "+identify(packet[6]),"red");
                //tn("We will continue anyway.","red");
            }
            if( packet[2] != Nameservers[0][0] ){
                //tn("We don't like packet element 2. It is: "+identify(packet[2]),"red");
                return;
            }

            MudList["ID"] = packet[6];
            foreach(cle, val in packet[7]){
                string tmp = "";
                if(cle){
                    string lib = "unknown";
                    if(val && sizeof(val) > 5 && arrayp(val)){
                        if(!my_ip && cle == mud_name()) my_ip = val[1];
                        lib = val[5];
                    }
                    MUDINFO_D->ReceiveMudInfo(cle, val);
                    tmp += "%^BOLD%^CYAN%^Processing mud: "+identify(cle)+
                        ", lib: "+lib;
                    if(val){
                        if(!val[0]) tmp += " %^RED%^BOLD%^offline%^RESET%^";
                        else tmp += " %^GREEN%^BOLD%^ONLINE%^RESET%^";
                    }
                    else tmp += " removed from mudlist";
                    tn(tmp);
                    //tn(tmp,"cyan",ROOM_ARCH);
                    if(val && sizeof(val) > 5 && arrayp(val))
                        tmp = (val[0] ? "%^BLUE%^online" : "%^RED%^offline")+ 
                            "%^RESET%^, lib: "+lib+", driver: "+val[7];
                    else tmp = "removed from mudlist.";
                    CHAT_D->eventSendChannel(cle+"@i3","muds",tmp,0);
                }
                if( !val && MudList["List"][cle] != 0 ) 
                    map_delete(MudList["List"], cle);
                else if( val ) MudList["List"][cle] = val;
            }
            SaveObject(SaveFile);
            return;
        case "chanlist-reply":
            tn("chanlist reply: "+identify(packet), "blue");
            if( packet[2] != Nameservers[0][0] ) return;
            ChannelList["ID"] = packet[6];
            foreach(cle, val in packet[7]){
                if( !val && ChannelList["List"] != 0 ){
                    map_delete(ChannelList["List"], cle);
                    CHAT_D->RemoveRemoteChannel(cle);
                }
                else if( val ){
                    ChannelList["List"][cle] = val;
                    CHAT_D->AddRemoteChannel(cle);
                }
            }
            SaveObject(SaveFile);
            SERVICES_D->eventRegisterChannels(packet[7]);
            return;
        case "ping-req":
            mudpacket = 1;
            SERVICES_D->eventReceiveAuthRequest(packet);
            break;
        case "ping-reply":
            mudpacket = 1;
            SERVICES_D->eventReceiveAuthReply(packet);
            break;
        case "auth-mud-req":
            mudpacket = 1;
            SERVICES_D->eventReceiveAuthRequest(packet);
            break;
        case "auth-mud-reply":
            mudpacket = 1;
            SERVICES_D->eventReceiveAuthReply(packet);
            break;
        case "channel-t":
            mudpacket = 1;
            SERVICES_D->eventReceiveChannelTargettedEmote(packet);
            break;
        case "channel-e":
            mudpacket = 1;
            SERVICES_D->eventReceiveChannelEmote(packet);
            break;
        case "channel-m":
            mudpacket = 1;
            SERVICES_D->eventReceiveChannelMessage(packet);
            break;
        case "chan-who-reply":
            mudpacket = 1;
            SERVICES_D->eventReceiveChannelWhoReply(packet);
            break;
        case "chan-who-req":
            mudpacket = 1;
            SERVICES_D->eventReceiveChannelWhoRequest(packet);
            break;
        case "chan-user-req":
            mudpacket = 1;
            SERVICES_D->eventReceiveChannelUserRequest(packet);
            break;
        case "emoteto":
            mudpacket = 1;
            SERVICES_D->eventReceiveEmote(packet);
            break;
        case "finger-req":
            mudpacket = 1;
            SERVICES_D->eventReceiveFingerRequest(packet);
            break;
        case "finger-reply":
            mudpacket = 1;
            SERVICES_D->eventReceiveFingerReply(packet);
            break;
        case "locate-req":
            mudpacket = 1;
            SERVICES_D->eventReceiveLocateRequest(packet);
            break;
        case "locate-reply":
            mudpacket = 1;
            SERVICES_D->eventReceiveLocateReply(packet);
            break;
        case "tell":
            mudpacket = 1;
            SERVICES_D->eventReceiveTell(packet);
            break;
        case "chan-user-reply":
            mudpacket = 1;
            tn("INTERMUD_D: chan-user-reply received.","red");
        case "ucache-update":
            mudpacket = 1;
            SERVICES_D->eventReceiveUcacheUpdate(packet);
            break;
        case "who-req":
            mudpacket = 1;
            SERVICES_D->eventReceiveWhoRequest(packet);
            break;
        case "who-reply":
            mudpacket = 1;
            SERVICES_D->eventReceiveWhoReply(packet);
            break;
        case "news":
            mudpacket = 1;
            SERVICES_D->eventReceiveNews(packet);
            break;
        case "mail":
            mudpacket = 1;
            SERVICES_D->eventReceiveMail(packet);
            break;
        case "mail-ok":
            mudpacket = 1;
            SERVICES_D->eventReceiveMailOk(packet);
            break;
        case "file":
            mudpacket = 1;
            tn("INTERMUD_D: file packet received.","red");
            break;
        case "error":
            SERVICES_D->eventReceiveError(packet);
            break;
        default:
            break;
    }
    if(mudpacket){
        if(!GetStatus(packet[2])){
            tn("Setting status of "+packet[2]+" to online.");
            SetStatus(packet[2], -1);
        }
    }
}

static void eventSocketClose(){
    Online = 0;
}

static void eventConnectionFailure(){
    Online = 0;
    tn("INTERMUD_D: CONNECTION FAILED","red");
    error("Failed to find a useful name server.\n");
}

int SetDestructOnClose(int x){ return 0; }

static void eventClose(mixed arg){
    SocketStat = -1;
    Online = 0;
    tn("INTERMUD_D: socket closing!");
    ::eventClose(arg);
}

int SetSocketType(int x){ return client::SetSocketType(MUD); }

string GetMudName(string mud){
    string *lc, *uc;
    mapping mudses = GetMudList();
    int x;

    if( MudList["List"][mud] ) return mud;
    lc = map(uc = keys(MudList["List"]), function(string str){
            if( !str ) return "";
            else return lower_case(str);
            });
    x = member_array(lower_case(mud), lc);
    if( x < 0 ){
        foreach(string name in GetMuds()){
            if(mudses[name][1] +" "+mudses[name][2] == mud) return name;
        }
        return 0;
    }
    else return uc[x];
}

static mixed SetStatus(string mud, int status){
    mapping mlist = copy(MudList["List"]);
    mixed array newmud = ({});
    if(!sizeof(newmud = mlist[mud])) return 0;
    tn("old: "+identify(newmud));
    newmud[0] = status;
    MudList["List"][mud] = newmud;
    tn("new: "+identify(MudList["List"][mud]),"blue");
} 

int GetStatus(string mud){
    mixed array newmud = ({});
    if(!sizeof(newmud = MudList["List"][mud])) return 0;
    return (newmud[0] ? 1 : 0);
}

mapping GetMudList(){ 
    if(sizeof(MudList) && MudList["List"])
        return copy(MudList["List"]); 
    else return ([]);
}

string *GetMuds(){
    if(sizeof(MudList) && MudList["List"])
        return keys(MudList["List"]);
    else return ({});
}

string *GetLCMuds(){
    string *orig_arr, *new_arr;
    orig_arr = GetMuds();
    new_arr = ({});
    foreach(string namen in orig_arr){
        new_arr += ({ lower_case(namen) });
    }
    return new_arr;
}

mapping GetChannelList(){ return copy(ChannelList["List"]); }

string *GetChannels(){ return keys(ChannelList["List"]); }

string *GetMatch(string mud){
    string *uc, *lc;

    mud = lower_case(mud);
    lc = map(uc = keys(MudList["List"]), (: lower_case :));
    return map(filter(regexp(lc, "^"+mud, 1), (: intp :)), (: $(uc)[$1] :));
}

string GetNameserver(){ return Nameservers[0][0]; }

mixed *GetNameservers(){ return copy(Nameservers); }

int AddBanned(string mud, string reason){
    if( !master()->valid_apply(({})) ){
        return 0;
    }
    if( !(mud = GetMudName(mud)) ){
        return 0;
    }
    Banned[mud] = reason;
    SaveObject(SaveFile);
    return 1;
}

mapping GetBanned(){ return copy(Banned); }

int RawSend(string *packet){
    if(!this_player() || !archp(this_player())) return 0;
    eventWrite(packet);
    return 1;
}

string nextboot(){
    string str;
    int x, offset;

    if(DISABLE_REBOOTS){
        return "never";
    }

    offset = TIME_D->GetOffset(local_time()[9]);
    offset += EXTRA_TIME_OFFSET;

    x = EVENTS_D->GetRebootInterval() * 3600;
    x = (time() - uptime()) + x;
    if(!LOCAL_TIME) 
        x += offset * 3600;
    str = query_tz()+ " " + ctime(x);
    return str;
}

//This new packet element data added to be able
//to handle liveupgrade stuff more sensibly.
mapping ExtraInfo(){
    return ([
            "native version" : native_version(),
            "os build" : query_os_type(),
            "architecture" : architecture(),
            "upsince" : ctime(time() - uptime()),
            "next boot" : nextboot(),
            "ip" : HOST_IP,
            "oob port" : PORT_OOB,
            ]);
}

void ConvertLists(){
    if(classp(MudList)){
        mapping TmpMap = ([]);
        MudList = TmpMap;
        MudList["ID"] = -1;
        MudList["List"] = ([]);
        SaveObject(SaveFile);
    }
    if(classp(ChannelList)){
        mapping TmpMap = ([]);
        ChannelList = TmpMap;
        ChannelList["ID"] = -1;
        ChannelList["List"] = ([]);
        SaveObject(SaveFile);
    }
}

int GetEnabled(){
    return !(DISABLE_INTERMUD);
}

string GetMyIp(){
    string ret = "127.0.0.1";
    if(my_ip) ret = my_ip;
    return ret;
}

void eventWrite(mixed val){
    object prev = previous_object();
    if(!prev || prev == this_object() 
            || prev == find_object(PING_D)
            || prev == find_object(SERVICES_D) 
            || prev == find_object(CMD_CHANBAN)
            || prev == find_object(CMD_CHANCREATE) 
            || prev == find_object(CMD_CHANREMOVE) 
            || prev == find_object(CMD_CHANUNBAN)){
        ::eventWrite(val);
    }
}

static void eventSocketError(string str, int x) {
    //debug_message(timestamp()+" i3 "+socket_error(x) + "\n");
    if(query_os_type() == "windows" && grepp(socket_error(x), "Problem with connect")){
        load_object("/secure/cmds/admins/mudconfig")->cmd("intermud disable");
    }
}
#endif /* __PACKAGE_SOCKETS__ */