/* **** HBBS Door Code****************************************************** */

/*
  DoorName
  ========

    what the door does

  Version
  =======

    x.xx, release xx, dd/mm/yyyy

  Options
  =======

    N_ND->ActiveDoor->SystemOptions
    -------------------------------



    Command Line Arguments
    ----------------------

    2  <option>

    3  ...

    4  .

  ToDo
  ====

    what you still have to do



*/

/* **** Includes *********************************************************** */

#include <exec/types.h>
#include <exec/memory.h>
#include <dos/dos.h>
#include <clib/exec_protos.h>
#include <clib/dos_protos.h>
#include <clib/alib_protos.h>

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <ctype.h>
#include <time.h>

#include <HBBS/ANSI_Codes.h>
#include <HBBS/Defines.h>
#include <HBBS/Access.h>
#include <HBBS/types.h>
#include <HBBS/structures.h>
#include <HBBS/hbbscommon_protos.h>
#include <HBBS/hbbscommon_pragmas.h>
#include <HBBS/Hbbsnode_protos.h>
#include <HBBS/Hbbsnode_pragmas.h>
#include <HBBS/release.h>
char *versionstr="$VER: OLM "RELEASE_STR;

/* **** Variables ********************************************************** */


struct Library *HBBSCommonBase  = NULL;
struct Library *HBBSNodeBase    = NULL;

struct BBSGlobalData *BBSGlobal = NULL;
struct NodeData *N_ND           = NULL;
int    N_NodeNum                = -1;
char   outstr[1024];

long __stack=16*1024; // increse this in 4k incrments if you suffer from
                      // random/suprious crashings after or during the running
                      // of your door.

int    gargc;         // these are just copies of main()'s argc and argv..
char   **gargv;

/* **** Functions ********************************************************** */


#ifdef __SASC
int CXBRK(void) { return(0); }
int _CXBRK(void) { return(0); }
void chkabort(void) {}
#endif

static VOID cleanup(ULONG num)
{
  if (HBBSNodeBase)
  {
    HBBS_CleanUpDoor();
    CloseLibrary (HBBSNodeBase);
  }

  if (HBBSCommonBase)
  {
    HBBS_CleanUpCommon();
    CloseLibrary (HBBSCommonBase);
  }

  if (num) printf("Door Error = %d\n",num);

  exit(0);
}

static VOID init(char *name)
{
  if(!(HBBSCommonBase = OpenLibrary("HBBSCommon.library",0)))
  {
    cleanup(1);
  }

  if (!(HBBS_InitCommon()))
  {
    cleanup(2);
  }

  if(!(HBBSNodeBase = OpenLibrary("HBBSNode.library",0)))
  {
    cleanup(3);
  }

  if (!(HBBS_InitDoor(N_NodeNum,name)))
  {
    cleanup(4);
  }
  SetProgramName(name);
}

/* **** DoorMain *********************************************************** */

/*
V_BOOL HBBS_AddOLM(V_SMALLNUM FromNode,UBYTE *FromPRG,V_SMALLNUM ToNode,UBYTE *Message,BYTE Pri)
{
  // frommnode should be 0 if something other than a door is sending the OLM
  // otheriwse fromnode should be set to your node number plus 1
  // e.g. N_ND->NodeNum+1, if fromnode


  V_BOOL retval=FALSE;
  struct OLMNode *NewOLM;
  struct NodeData *nd;
  struct NodeData *fnd;
  struct Message *NewMsg=NULL;


  if ((Message) && (FromNode>=0 ) && (FromNode<=BBSGlobal->BBSNodes)  && (nd=HBBS_NodeDataPtr(ToNode)) && (nd->OLMList) && (nd->LoginType!=LOGIN_NONE))
  {
    if (NewOLM=(struct OLMNode *)HBBS_CreateNode(Message,sizeof(struct OLMNode)))
    {
      if (NewOLM->node.ln_Name=DupStr(Message))
      {
        NewOLM->node.ln_Pri=Pri;
        HBBS_GetTime(NewOLM->Time);
        HBBS_GetDate(NewOLM->Date);
        NewOLM->FromNode=FromNode;
        if ((FromNode) && (fnd=HBBS_NodeDataPtr(FromNode-1)))
        {
          if (fnd->User->Valid) // NewOLD has already been blanked by CreateNode() so the string is already null terminated..
          {
            strNcpy(NewOLM->Handle,fnd->User->CallData->Handle,LEN_HANDLE);
          }
        }
        if (FromPRG)
        {
          strNcpy(NewOLM->FromPRG,FromPRG,LEN_HANDLE);
        }

        // *C* add semaphore checking!
        Enqueue(nd->OLMList,(struct Node*)NewOLM);
        nd->OLMCount++;
        if (!(nd->NodeFlags & NFLG_OLMSWAITING)) nd->NodeFlags+=NFLG_OLMSWAITING;

        if (nd->OLMPort)
        {
          if (NewMsg=AllocVec(sizeof (struct Message),MEMF_PUBLIC|MEMF_CLEAR))
          {
            NewMsg->mn_Node.ln_Type = NT_MESSAGE;
            NewMsg->mn_ReplyPort=NULL;
            NewMsg->mn_Length=sizeof(struct Message);

            PutMsg(nd->OLMPort,NewMsg);
          }
        }
        retval=TRUE;
      }
    }
  }
  return(retval);
}
*/

void DoorMain( void )
{
  LONG loop,tonode;

  outstr[0]=0;
  if (gargc>=4)
  {
    if (sscanf(gargv[2],"%ld",&tonode))
    {
      if (tonode>=0 && tonode < BBSGlobal->BBSNodes)
      {
        for (loop=3;loop<gargc;loop++)
        {
          strcat(outstr,gargv[loop]);
          if (loop<gargc-1) strcat(outstr," ");
        }

        if (HBBS_SendOLM(N_ND->NodeNum+1,"HydraOLM",tonode,outstr,0))
        {
          DOOR_WriteText("OLM Sent!\r\n");
        }
        else
        {
          DOOR_WriteText("OLM Failed - node my be busy, offline or there is no user-online\r\n");
        }
      }
    }
  }
  else
  {
    DOOR_WriteText("Invalid Parameters! usage: OLM <node> message...\r\n");
  }
}


int main(int argc,char **argv)
{
  gargc=argc;
  gargv=argv;

  if (sscanf(argv[1],"%d",&N_NodeNum)==0)
  {
    printf("Invalid/No Paramaters for door!\n");
    exit (20);
  }
  init("Writing OLM");

  if (BBSGlobal=HBBS_GimmeBBS())
  {
    if (N_ND=HBBS_NodeDataPtr(N_NodeNum)) // this should not fail in normal circumstances..
    {
      DoorMain();
    }
  }
  cleanup(0);
}

/* **** End Of File ******************************************************** */