home *** CD-ROM | disk | FTP | other *** search
/ Network PC / Network PC.iso / amiga utilities / communication / bbs / hydrabbsa8 / source / src.lha / library / HBBSCommon.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-09-08  |  60.0 KB  |  2,394 lines
  1. /*
  2.  
  3.   todo
  4.   ====
  5.  
  6.   remove LIBCountListItems(), replace with HBBS_NodesInList()  :-)
  7.  
  8. */
  9.  
  10. #define HBBSCOMMON
  11. #define MAIN
  12.  
  13. #include <ctype.h>
  14. #include <time.h>
  15. #include <stdio.h>
  16. #include <stdlib.h>
  17. #include <string.h>
  18.  
  19. #include <exec/exec.h>
  20. #include <exec/types.h>
  21.  
  22. #include <dos/dos.h>
  23. #include <dos/dostags.h>
  24. #include <dos/filehandler.h>
  25. #include <dos/dosextens.h>
  26.  
  27. #include <libraries/reqtools.h>
  28.  
  29.  
  30. #include <clib/exec_protos.h>
  31. #include <clib/dos_protos.h>
  32. #include <clib/alib_protos.h>
  33. #include <clib/reqtools_protos.h>
  34.  
  35. #include <pragmas/exec_pragmas.h>
  36. #include <pragmas/dos_pragmas.h>
  37. #include <pragmas/reqtools.h>
  38.  
  39.  
  40. #include "/common/types.h"
  41. #include "/common/errors.h"
  42. #include "/common/defines.h"
  43. #include "/common/structures.h"
  44. #include "/common/strings.h"
  45. #include "/common/files.h"
  46.  
  47. // some forward defines
  48.  
  49. void __asm __saveds LIBstrNcpy(register __a0 UBYTE *dest,register __a1 UBYTE *source,register __d0 int chars);
  50. void __asm __saveds LIBHBBS_rterror(register __a0 char *str);
  51. BOOL __asm __saveds LIBAssignOK(register __a0 char *checkme );
  52. BOOL __asm __saveds LIBHBBS_AddCfgItem(register __a0 struct CfgFileData *cfgfile,register __a1 UBYTE *itemname,register __a2 UBYTE *params);
  53. struct List __asm __saveds *LIBHBBS_CreateList( void );
  54. void __asm __saveds LIBHBBS_DateStrFromTM(register __a0 UBYTE *datestr, register __a1 struct tm *timestruct);
  55. V_BOOL __asm __saveds LIBHBBS_AddCfgItemQuick(register __a0 struct CfgFileData *cfgfile,register __a1 char *ItemName, register __a2 char *Params);
  56. void  __asm __saveds  LIBHBBS_FlushConfig(register __a0 struct CfgFileData *cfgfile);
  57. BOOL __asm __saveds LIBPathOK(register __a0 char *str);
  58.  
  59. // needed libs..
  60.  
  61. struct DosLibrary *DOSBase=NULL;
  62. struct ExecBase *SysBase=NULL;
  63. struct ReqToolsBase *ReqToolsBase=NULL;
  64.  
  65. // global variables.. (keep to a minimum..)
  66.  
  67. struct BBSGlobalData *BBSGlobal=NULL;
  68.  
  69. UBYTE *OPT_PRIV_LastUserNum="LastUserNum";
  70.  
  71. char monthstr[12][4]={"JAN","FEB","MAR","APR","MAY","JUN","JUL","AUG","SEP","OCT","NOV","DEC"};
  72.  
  73.  
  74. // actual functions..
  75.  
  76. void __asm __saveds LIBFreeStr(register __a0 char *str)
  77. {
  78.   if (str) FreeVec(str);
  79. }
  80.  
  81. char __asm __saveds *LIBDupStr(register __a0 char *str)
  82. {
  83.   char *newstr=NULL;
  84.   if (str)
  85.   {
  86.     if (newstr=(char *)AllocVec(strlen(str)+1,MEMF_PUBLIC))
  87.     {
  88.       newstr[0]=0;
  89.       strcpy(newstr,str);
  90.     }
  91.   }
  92.   return(newstr);
  93. }
  94.  
  95. char __asm __saveds *LIBFreeAndSet(register __a0 char **varname,register __a1 char *newstr)
  96. {
  97.   // this routines frees memory allocated to strings using strdup or
  98.   // and duplicates the string in newstr and sets varname to the newly allocated str
  99.  
  100.   if (*varname!=NULL)
  101.   {
  102.     LIBFreeStr(*varname);
  103.     *varname=NULL;
  104.   }
  105.  
  106.   if (newstr)
  107.   {
  108.     *varname=LIBDupStr(newstr);
  109.   }
  110.   return(*varname); // return varname if you want to test result..
  111. }
  112.  
  113.  
  114. V_BOOL __asm __saveds LIBCheckBoolean(register __a0 char *str)
  115. {
  116.   if (stricmp(str,"TRUE")==0 || stricmp(str,"ON")==0 || stricmp(str,"YES")==0)
  117.     return(TRUE);
  118.   else
  119.     return(FALSE);
  120. }
  121.  
  122.  
  123. // creates a new node with ln_Name set to a copy of str, and appends it to the list specified
  124.  
  125. V_ERROR __asm __saveds LIBNewStrNode(register __a0 char *str,register __a1 struct List *list)
  126. {
  127.   struct Node *NewNode;
  128.   V_ERROR retval=TYPE_MEMORY;
  129.  
  130.   if (NewNode=AllocVec(sizeof(struct Node),MEMF_PUBLIC))
  131.   {
  132.     if (NewNode->ln_Name=LIBDupStr(str))
  133.     {
  134.       AddTail(list,NewNode);
  135.       retval=ERR_NO_ERROR;
  136.     }
  137.     else
  138.     {
  139.       FreeVec(NewNode);
  140.     }
  141.   }
  142.   return(retval);
  143. }
  144.  
  145. void __asm __saveds LIBUpperCase(register __a0 char *str)
  146. {
  147.   // converts str into uppercase
  148.  
  149.   short loop;
  150.  
  151.   for (loop=0;str[loop];loop++) str[loop]=toupper(str[loop]);
  152. }
  153.  
  154. char __asm __saveds *LIBupcase(register __a0 char *str)
  155. {
  156.   // converts str into uppercase and returns a pointer to a new
  157.   // string.
  158.   // returns NULL if it fails.
  159.  
  160.   // dont forget to FreeStr() the output!
  161.  
  162.   char *outstr=NULL;
  163.   short loop;
  164.  
  165.   if (outstr=LIBDupStr(str))
  166.   {
  167.     for (loop=0;str[loop];loop++) outstr[loop]=toupper(str[loop]);
  168.   }
  169.   return(outstr);
  170. }
  171.  
  172. short __asm __saveds LIBposition(register __a0 char *substr,register __a1 char *str)
  173. {
  174.   // returns an character offset of a substring in a string
  175.   // this version is CASE SENSITIVE
  176.   // returns -1 if substring not found in the string
  177.  
  178.   char *whstr;
  179.   return((short)((whstr=strstr(str,substr)) ? (short)((LONG)whstr-(LONG)str) : -1));
  180. }
  181.  
  182. short __asm __saveds LIBiposition(register __a0 char *substr,register __a1 char *str)
  183. {
  184.   // returns an character offset of a substring in a string
  185.   // this version is CASE INSENSITIVE
  186.   // returns -1 if substring not found in the string
  187.   //      or -2 if memory allocation error
  188.  
  189.   short where=-2;
  190.   char *isubstr,*istr;
  191.  
  192.   if (isubstr=LIBupcase(substr))
  193.   {
  194.     if (istr=LIBupcase(str))
  195.     {
  196.       where=LIBposition(isubstr,istr);
  197.       LIBFreeStr(istr);
  198.     }
  199.     LIBFreeStr(isubstr);
  200.   }
  201.   return(where);
  202. }
  203.  
  204. void __asm __saveds LIBstrfcpy(register __a0 char *dest,register __a1 char *source,register __d0 int from)
  205. {
  206.   /*
  207.      copy all chars from "source" to "dest" starting at offset "from"
  208.      (kinda the reverse from strncpy() )
  209.    */
  210.   int loop=from,pos=0;
  211.   if (from<=strlen(source)-1)
  212.   {
  213.     while (source[loop])
  214.     {
  215.       dest[pos]=source[loop];
  216.       loop++;
  217.       pos++;
  218.     }
  219.   }
  220.   dest[pos]=0;
  221. }
  222.  
  223. void __asm __saveds LIBstripcr(register __a0 char *s)
  224. {
  225.   /* New Optimized Version 04-JAN-1996 */
  226.  
  227.   LONG Len;
  228.   if (s)
  229.   {
  230.     Len=strlen(s)-1; // set to point to last char in string 's'
  231.  
  232.     while (Len>=0 && (s[Len]=='\r' || s[Len]=='\n'))
  233.     {
  234.       s[Len--]=0; // string is now 1 char smaller, and overwrite the \r or \n with a null terminator
  235.     }
  236.   }
  237. }
  238.  
  239. /* old version, had problems with small strings!
  240. void __asm __saveds LIBstripcr(register __a0 char *s)
  241. {
  242.   // caters for \n or \r or \r\n or \n\r  :-)
  243.  
  244.   short sl;
  245.   sl=strlen(s);
  246.   if (s[sl-1]==10 || s[sl-1]==13) s[sl-1]=0;
  247.   sl=strlen(s);
  248.   if (s[sl-1]==10 || s[sl-1]==13) s[sl-1]=0;
  249.   // hmm ? how about a for next loop there ?  nah, bigger.. slower...
  250. }
  251. */
  252.  
  253.  
  254. UBYTE  __asm __saveds *LIBStripComments(register __a0 char *s)
  255. {
  256.   /* New Optimized Version 04-JAN-1996 */
  257.  
  258.   // returns a pointer to the start of the comments too..
  259.  
  260.   UBYTE *strptr;
  261.  
  262.   if (strptr=strchr(s,';'))
  263.   {
  264.     *strptr=0;
  265.     strptr++; //we've just killed the ';' so point to next char..
  266.   }
  267.   return(strptr);
  268. }
  269.  
  270. /* older version. allocated memory!!
  271. UBYTE  __asm __saveds *LIBStripComments(register __a0 char *s)
  272. {
  273. // returns a pointer to the start of the comments too..
  274.   int where;
  275.  
  276.   if ((where=LIBposition(";",s))>=0)
  277.   {
  278.     s[where]='\0';
  279.     return(&s[where+1]); // return pointer to character after the ; in the string
  280.   }
  281.   return(NULL);
  282. }
  283. */
  284.  
  285. void __asm __saveds LIBStripSpaces(register __a0 char *s)
  286. {
  287.   /* New Optimized Version 04-JAN-1996 */
  288.   /* this version only parses the string once, much nicer.. */
  289.  
  290.   LONG len=strlen(s)-1;
  291.  
  292.   // while the last char is a ' ', set it to a 0
  293.   while (len>=0 && s[len]==' ') s[len--]=0;  // cooler Kompakt coding! :-)
  294. }
  295.  
  296. /* old version, too slow, keeps parsing strings..
  297. void __asm __saveds LIBStripSpaces(register __a0 char *s)
  298. {
  299.   // while the last char is a ' ', set it to a 0
  300.   while (s[strlen(s)-1]==' ') s[strlen(s)-1]=0;  // Kompakt coding! :-)
  301. }
  302. */
  303. void __asm __saveds LIBreplace(register __a0 char *dest,register __a1 char *compare,register __a2 char *from,register __a3 char *to)
  304. {
  305.  
  306.   /*
  307.      replace all occurences of "from" in "compare" with "to" and store result in "dest"
  308.      (note: this is dead usefull!!!)
  309.    */
  310.   int where;
  311.   char *mystring;
  312.  
  313.   if (mystring=LIBDupStr(compare))
  314.   {
  315.     strcpy(dest,"");
  316.     do
  317.     {
  318.       where=LIBposition(from,mystring);
  319.       if (where!=-1)
  320.       {
  321.         strncat(dest,mystring,where);                    /* copy first part of string */
  322.         strcat(dest,to);                                 /* add repeaced chars */
  323.         LIBstrfcpy(mystring,mystring,where+strlen(from));   /* copy rest of string  so we find first position of from */
  324.       }
  325.     } while (where!=-1);                                 /* keep doing until "from" is not found */
  326.     strcat(dest,mystring);                               /* add the rest of the string */
  327.     LIBFreeStr(mystring);
  328.   }
  329. }
  330.  
  331.  
  332. BOOL __asm __saveds LIBGetParams(register __a0 char *dest,register __a1 char *source)
  333. {
  334.   UBYTE *strptr=NULL;
  335.  
  336.   dest[0]=0;
  337.  
  338.   if (strptr=strchr(source,'='))
  339.   {
  340.     strcpy(dest,strptr+1);
  341.     return(TRUE);
  342.   }
  343.   return(FALSE);
  344. }
  345.  
  346. /* old version, shite...
  347. BOOL __asm __saveds LIBGetParams(register __a0 char *dest,register __a1 char *source)
  348. {
  349.   int where;
  350.  
  351.   dest[0]=0;
  352.  
  353. //  if ( ((where=LIBposition("=",source))!=-1) && (where!=(strlen(source)-1)) )
  354.  
  355.   if ((where=LIBposition("=",source))>=0)
  356.   {
  357.     LIBstrfcpy(dest,source,where+1);
  358.     return(TRUE);
  359.   }
  360.   return(FALSE);
  361. }
  362. */
  363.  
  364.  
  365. BOOL __asm __saveds LIBGetItem(register __a0 char *dest,register __a1 char *source)
  366. {
  367.   int loop=0;
  368.  
  369.   // increment start counter until we encounter a character that's not a space or tab
  370.  
  371.   while (source[loop]==' ' || source[loop]==8) loop++;
  372.  
  373.   while (source[loop] && source[loop]!='=') // not end of string && '=' ?
  374.   {
  375.     dest[loop]=source[loop];
  376.     loop++;
  377.   }
  378.   dest[loop]='\0';
  379.   if (dest[0]!=0) return(TRUE);
  380.  
  381.   return(FALSE);
  382. }
  383.  
  384. void __asm __saveds LIBGetNumber(register __a0 int *num,register __a1 char *item)
  385. {
  386.   int where;
  387.   char numstr[5];
  388.   for (where=strlen(item);isdigit(item[where-1]);where--);
  389.  
  390.   LIBstrfcpy(numstr,item,where);
  391.   *num=atoi(numstr);
  392. }
  393.  
  394.  
  395. ULONG  __asm __saveds LIBSafePutToPort(register __a0 struct Message *message, register __a1 STRPTR portname)
  396. {
  397.   struct MsgPort *port;
  398.   Forbid();
  399.   if (port=FindPort(portname))
  400.   {
  401.     PutMsg(port,message);
  402.   }
  403.   Permit();
  404.   return((ULONG)port);
  405. }
  406.  
  407. // new: if message you are sending has a reply port, it'll return a pointer to the replied
  408. // message, other wise it'll return 1.
  409. // it will ALWAYS return NULL if it fails to send the message tho..
  410.  
  411. struct Message __asm __saveds *LIBSendMessage(register __a0 struct Message *Msg,register __a1 char *MPortName)
  412. {
  413. //  BOOL waitforreply=(Msg->mn_ReplyPort) ? TRUE : FALSE;
  414.  
  415.   if (LIBSafePutToPort(Msg,MPortName))
  416.   {
  417. //  if (waitforreply)
  418.     if (Msg->mn_ReplyPort)
  419.     {
  420.       if (1L << Msg->mn_ReplyPort->mp_SigBit==Wait(1L << Msg->mn_ReplyPort->mp_SigBit))
  421.       {
  422.         return(GetMsg(Msg->mn_ReplyPort));
  423.       }
  424.     }
  425.     else return((struct Message *)1L);
  426.   }
  427.   return(NULL);
  428. }
  429.  
  430. V_BIGNUM __asm __saveds LIBCountListItems( register __a0 struct List *list)
  431. {
  432.   V_BIGNUM retval=0;
  433.   struct Node *node;
  434.  
  435.   if (list)
  436.   {
  437.     for (node = list->lh_Head ; node->ln_Succ ; node =node->ln_Succ)
  438.     {
  439.       retval++;
  440.     }
  441.   }
  442.   return(retval);
  443. }
  444.  
  445. void __asm __saveds LIBFreeStrList(register __a0 V_STRINGLIST strlist)
  446. {
  447.   // free all strings in a list and remove all nodes from the list.
  448.   // then free the nodes and the list itself..
  449.  
  450.   struct Node *node;
  451.   if (strlist)
  452.   {
  453.     while (strlist->lh_Head->ln_Succ)
  454.     {
  455.       node=strlist->lh_Head;
  456.       LIBFreeStr(node->ln_Name);
  457.       Remove(node);
  458.       FreeVec(node);
  459.     }
  460.     FreeVec(strlist);
  461.   }
  462. }
  463.  
  464. struct BBSGlobalData __asm __saveds *LIBHBBS_GimmeBBS( void )
  465. {
  466.   return(BBSGlobal);
  467. }
  468.  
  469. void  __asm __saveds  LIBHBBS_SetBBS(register __a0 struct BBSGlobalData *B)
  470. {
  471.   BBSGlobal=B;
  472. }
  473.  
  474. struct Node __asm __saveds  *LIBGetNode(register __a0 struct List *lh,register __d0 UWORD n)
  475. { // starts from 0, 0 being the first node in the list..
  476.   // thanks to the author of YAK for this and the next function..
  477.   struct Node *ln;
  478.  
  479.   for (ln = lh->lh_Head; n--; ln = ln->ln_Succ);
  480.   return ln;
  481. }
  482.  
  483. UWORD __asm __saveds LIBGetNodeNum(register __a0 struct List *lh,register __a1 struct Node *node)
  484. {
  485.   struct Node *ln;
  486.   UWORD i;
  487.  
  488.   for (i = 0, ln = lh->lh_Head; ln != node; ln = ln->ln_Succ, i++);
  489.   return i;
  490. }
  491.  
  492. struct NodeData  __asm __saveds *LIBHBBS_NodeDataPtr(register __d0 short nodenum)
  493. {
  494.   struct NodeData *nd;
  495.  
  496.   for (nd = (struct NodeData *)BBSGlobal->NodeList->lh_Head ; nd->node.ln_Succ ; nd =(struct NodeData *) nd->node.ln_Succ)
  497.   {
  498.     if (nd->NodeNum==nodenum) return(nd);
  499.   }
  500.   return(NULL);
  501. }
  502.  
  503.  
  504. V_ERROR __asm __saveds LIBHBBS_LogError(register __a0 V_STRING filename,register __d0 V_ERROR errnum,register __a1 V_STRING string,register __d1 V_ERROR errtype)
  505. {
  506.   // this function returns the parameter errnum supplied and unmodified.
  507.   BPTR FH;
  508.   V_STRING errstr;
  509.   struct tm *tp;
  510.   long t;
  511.  
  512.   if (filename)
  513.   {
  514.     if (FH=Open(filename,MODE_READWRITE))
  515.     {
  516.       Seek(FH,0,OFFSET_END);
  517.       if (errstr=AllocVec(BIG_STR,MEMF_PUBLIC))
  518.       {
  519.         time(&t);
  520.         tp=localtime(&t);
  521.         sprintf(errstr,"%s Error\n"
  522.                        "%s"
  523.                        "Details:\n",TYPE_STR[errtype],asctime(tp));
  524.  
  525.         Write(FH,errstr,strlen(errstr)); // don't care if it fails.. (could be diskfull :-)
  526.  
  527.         switch(errnum)
  528.         {
  529.           case ERR_ERROR_OPENING:
  530.             sprintf(errstr,"Error opening the file -> %s",string);
  531.             break;
  532.           case ERR_ERROR_READING:
  533.             sprintf(errstr,"Error reading the file -> %s",string);
  534.             break;
  535.           case ERR_ERROR_WRITING:
  536.             sprintf(errstr,"Error writing the file -> %s",string);
  537.             break;
  538.           case ERR_NODESETTINGS:
  539.             strcpy(errstr,"NodeLocal File Error");
  540.             break;
  541.           case ERR_GENERAL:
  542.             strcpy(errstr,string);
  543.             break;
  544.           case ERR_DOORTIMEOUT:
  545.             sprintf(errstr,"Timout Occured When Loading Door -> %s",string);
  546.             break;
  547.           default:
  548.             sprintf(errstr,"Unknown Error!\n");
  549.             break;
  550.         }
  551.         Write(FH,errstr,strlen(errstr));
  552.  
  553.         Write(FH,"\n***\n",5);
  554.  
  555.         FreeVec(errstr);
  556.       }
  557.       Close(FH);
  558.     }
  559.   }
  560.   return(errnum);
  561. }
  562.  
  563. /*
  564.  
  565. // lets play spot the bug that cuases this routine to crash the system..
  566. // 5 quid goes to the person the finds the problem!!
  567.  
  568. struct CfgFileData __asm __saveds *LIBHBBS_LoadConfig(register __a0 UBYTE *filename,register __d0 ULONG Flags)
  569. {
  570.   // New Optimized Version 04-JAN-1996
  571.  
  572.   BPTR FH;
  573.   LONG found=0;
  574.   UBYTE buffer[BIG_STR+1];
  575.   UBYTE ItemName[BIG_STR+1];
  576.   UBYTE Params[BIG_STR+1];
  577.   struct CfgFileData *cfgfile=NULL;
  578.   struct CfgItemData *node=NULL;
  579.   if (LIBPathOK(filename))
  580.   {
  581.     // create and init our CfgFileData structure..
  582.  
  583.     if (cfgfile=AllocVec(sizeof(struct CfgFileData),MEMF_PUBLIC|MEMF_CLEAR))
  584.     {
  585.       cfgfile->filename=LIBDupStr(filename);
  586.  
  587.       if (cfgfile->ItemsList=LIBHBBS_CreateList())
  588.       {
  589.         if (FH=Open(filename,MODE_OLDFILE))
  590.         {
  591.           while (FGets(FH,buffer,BIG_STR))
  592.           {
  593.             LIBstripcr(buffer);
  594.             ItemName[0]=0;
  595.             Params[0]=0;
  596.  
  597.             LIBStripComments(buffer);
  598.  
  599.             LIBStripSpaces(buffer);
  600.  
  601.             if (LIBGetItem(ItemName,buffer))
  602.             {
  603.               if (LIBGetParams(Params,buffer))
  604.               {
  605.  
  606.                 if (node=AllocVec(sizeof(struct CfgItemData),MEMF_PUBLIC))
  607.                 {
  608.                   node->node.ln_Name=LIBDupStr(ItemName);  // *C* add errorchecking..
  609.                   node->Params=LIBDupStr(Params);
  610.                   AddTail(cfgfile->ItemsList,(struct Node*)node);
  611.                   found++;
  612.                 }
  613.  
  614. //                if (LIBHBBS_AddCfgItemQuick(cfgfile,ItemName,Params))
  615. //                {
  616. //                  found++;
  617. //                }
  618.               }
  619.             }
  620.           }
  621.           Close(FH);
  622.         }
  623.       }
  624.       if (!found)
  625.       {
  626.         LIBHBBS_FlushConfig(cfgfile);
  627.         cfgfile=NULL;
  628.       }
  629.     }
  630.   }
  631.  
  632.  
  633.   return(cfgfile);
  634. }
  635. */
  636.  
  637. struct CfgFileData __asm __saveds *LIBHBBS_LoadConfig(register __a0 UBYTE *filename,register __d0 ULONG Flags)
  638. {
  639.   BPTR FH;
  640.   struct FileInfoBlock *FIB=NULL;
  641.   LONG nr;
  642.   UBYTE *Data;
  643.   ULONG Length;
  644.  
  645.   V_BIGNUM linenum=0;
  646.   V_BOOL done,nearlydone;
  647.   LONG filepos=0,bufferpos,found=0;
  648.   V_STRING buffer;
  649.   V_STRING ItemName;
  650.   V_STRING Params;
  651.   struct CfgItemData *node=NULL;
  652.   struct CfgFileData *cfgfile=NULL;
  653.  
  654.   if (FH=Open(filename,MODE_OLDFILE))
  655.   {
  656.     if (cfgfile=AllocVec(sizeof(struct CfgFileData),MEMF_PUBLIC|MEMF_CLEAR))
  657.     {
  658.  
  659.       if (FIB=(struct FileInfoBlock *)AllocVec(sizeof(struct FileInfoBlock),MEMF_PUBLIC))
  660.       {
  661.         ExamineFH(FH,FIB);
  662.         Length=FIB->fib_Size;
  663.         if (Data=AllocVec(Length,MEMF_PUBLIC))
  664.         {
  665.           if ((nr=Read(FH,Data,Length))!=Length)
  666.           {
  667.             LIBHBBS_LogError(BBSGlobal->ErrorLogFile,ERR_ERROR_READING,filename,TYPE_CRITICAL);
  668.           }
  669.           else
  670.           {
  671.             if (cfgfile->ItemsList=LIBHBBS_CreateList())
  672.             {
  673. //            if (cfgfile->ItemsList=(struct List *)AllocVec(sizeof(struct List ),MEMF_PUBLIC))
  674. //            {
  675. //              NewList(cfgfile->ItemsList);
  676.  
  677.               buffer=AllocVec(BIG_STR,MEMF_PUBLIC);
  678.               ItemName=AllocVec(BIG_STR,MEMF_PUBLIC);
  679.               Params=AllocVec(BIG_STR,MEMF_PUBLIC);
  680.               if (buffer && ItemName && Params)
  681.               {
  682.                 do
  683.                 {
  684.                   bufferpos=0;
  685.                   done=FALSE;
  686.                   nearlydone=FALSE; // :-) love those variable names! :-)
  687.                   do
  688.                   {
  689.                     if (Data[filepos]=='\r' || Data[filepos]=='\n')
  690.                     {
  691.                       nearlydone=TRUE;
  692.                       filepos++;
  693.                     }
  694.                     else
  695.                     {
  696.                       if (nearlydone)
  697.                       {
  698.                         done=TRUE;
  699.                       }
  700.                       else
  701.                       {
  702.                         buffer[bufferpos]=Data[filepos];
  703.                         filepos++;
  704.                         bufferpos++;
  705.                       }
  706.                     }
  707.                   } while (filepos<Length && !done && bufferpos<BIG_STR-2); // 1 for null and 1 more cos we still have to add the null
  708.                   buffer[bufferpos]=0;
  709.  
  710.                   linenum++;
  711.                   ItemName[0]=0; // null terminate both strings..
  712.                   Params[0]=0;
  713.  
  714.                   if (!(Flags & LCFG_NOSTRIPCOMMENTS)) LIBStripComments(buffer);
  715.                   if (!(Flags & LCFG_NOSTRIPSPACES))   LIBStripSpaces(buffer);
  716.  
  717.                   if (LIBGetItem(ItemName,buffer))
  718.                   {
  719.                     if (LIBGetParams(Params,buffer))
  720.                     {
  721. //                      if (Params[0])
  722. //                      {
  723. //  Commented out cos it's WAY too slow like this...
  724. //                        if (LIBHBBS_AddCfgItem(cfgfile,ItemName,Params))
  725. //                        {
  726. //                          found++;
  727. //                       }
  728. //
  729.                         if (node=AllocVec(sizeof(struct CfgItemData),MEMF_PUBLIC))
  730.                         {
  731.                           node->node.ln_Name=LIBDupStr(ItemName);  // *C* add errorchecking..
  732.                           node->Params=LIBDupStr(Params);
  733.                           AddTail(cfgfile->ItemsList,(struct Node*)node);
  734.                           found++;
  735.                         }
  736.  
  737. //                      }
  738.                     }
  739.                   }
  740.                 } while (filepos<Length);
  741.               }
  742.               if (Params)     FreeVec(Params);
  743.               if (ItemName)   FreeVec(ItemName);
  744.               if (buffer)     FreeVec(buffer);
  745.             }
  746.           }
  747.           FreeVec(Data);
  748.         }
  749.         FreeVec(FIB);
  750.       }
  751.       if (found)
  752.       {
  753.         cfgfile->filename=LIBDupStr(filename);
  754.       }
  755.       else
  756.       {
  757.         LIBHBBS_FlushConfig(cfgfile);
  758.         cfgfile=NULL; // just to make sure.. *C* ?? needed ?
  759.       }
  760.     }
  761.     Close(FH);
  762.   }
  763. //  else
  764. //  {
  765. //    LIBHBBS_LogError(BBSGlobal->ErrorLogFile,ERR_ERROR_OPENING,filename,TYPE_FATAL);
  766. //  }
  767.   return(cfgfile);
  768. }
  769.  
  770. void  __asm __saveds  LIBHBBS_FlushConfig(register __a0 struct CfgFileData *cfgfile)
  771. {
  772.   struct CfgItemData *node;
  773.   if (cfgfile)
  774.   {
  775.     while ((cfgfile->ItemsList) && (cfgfile->ItemsList->lh_Head->ln_Succ))
  776.     {
  777.       node=(struct CfgItemData *)cfgfile->ItemsList->lh_Head;
  778.  
  779.       LIBFreeStr(node->node.ln_Name);
  780.       LIBFreeStr(node->Params);
  781.       Remove((struct Node *)node);
  782.       FreeVec(node);
  783.     }
  784.     FreeVec(cfgfile->ItemsList);
  785.     LIBFreeStr(cfgfile->filename);
  786.     FreeVec(cfgfile);
  787.   }
  788. }
  789.  
  790. V_BOOL __asm __saveds LIBHBBS_SaveConfig(register __a0 struct CfgFileData *cfgfile)
  791. {
  792.   BPTR FH;
  793.   struct CfgItemData *node;
  794.   char outstr[BIG_STR];
  795.  
  796.   if (LIBAssignOK(cfgfile->filename))
  797.   {
  798.     if (FH=Open(cfgfile->filename,MODE_NEWFILE))
  799.     {
  800.       for (node = (struct CfgItemData*)cfgfile->ItemsList->lh_Head ; node->node.ln_Succ ; node =(struct CfgItemData *)node->node.ln_Succ)
  801.       {
  802.         sprintf(outstr,"%s=%s\n",node->node.ln_Name,node->Params);
  803.         Write(FH,outstr,strlen(outstr));
  804.       }
  805.       Close(FH);
  806.       return(TRUE);
  807.     }
  808.   }
  809.   return(FALSE);
  810. }
  811.  
  812. struct CfgItemData __asm __saveds *LIBHBBS_GetCfgNode(register __a0 struct CfgFileData *cfgfile,register __a1 V_STRING optionstr)
  813. {
  814.  
  815.   struct CfgItemData *Item;
  816.  
  817.   for (Item = (struct CfgItemData *)cfgfile->ItemsList->lh_Head ; Item->node.ln_Succ ; Item =(struct CfgItemData *) Item->node.ln_Succ)
  818.   {
  819.     if (stricmp(optionstr,Item->node.ln_Name)==0)
  820.     {
  821.       return(Item);
  822.     }
  823.   }
  824.   return(NULL);
  825. }
  826.  
  827. V_SMALLNUM  __asm __saveds LIBHBBS_GetSetting(register __a0 struct CfgFileData *cfgfile,register __a1 void **result,register __d0 V_FLAGS optiontype,register __a2 V_STRING optionstr,register __d1 V_BOOL multi)
  828. {
  829.  
  830.   V_SMALLNUM found=0;
  831.   V_STRING CompareStr;
  832.   struct Node *node;
  833.   struct CfgItemData *Item;
  834.  
  835.   // allocate a big string for comparing the strings..
  836.   if (CompareStr=AllocVec(BIG_STR,MEMF_PUBLIC))
  837.   {
  838.     // parse list..
  839.     for (Item = (struct CfgItemData *)cfgfile->ItemsList->lh_Head ; Item->node.ln_Succ ; Item =(struct CfgItemData *) Item->node.ln_Succ)
  840.     {
  841.       if (multi==OPT_MULTI)
  842.       {
  843.         sprintf(CompareStr,"%s_%d",optionstr,found+1);
  844.       }
  845.  
  846.       if ((multi==OPT_SINGLE) && (stricmp(optionstr,Item->node.ln_Name)==0) ||
  847.          (multi==OPT_MULTI) && (stricmp(CompareStr,Item->node.ln_Name)==0))
  848.       {
  849.         switch(optiontype)
  850.         {
  851.           case VTYPE_STRING:
  852.           case VTYPE_DATE:
  853.             if (*result!=NULL) LIBFreeStr(*result);
  854.             *result=(V_STRING *)LIBDupStr(Item->Params);
  855.             found++;
  856.             break;
  857.           case VTYPE_PATH:
  858.             if (*result!=NULL) LIBFreeStr(*result);
  859.             if (*result=(V_STRING)AllocVec(strlen(Item->Params)+1,MEMF_CLEAR|MEMF_PUBLIC))
  860.             {
  861.               strcpy((V_STRING)*result,Item->Params);
  862.               if ((Item->Params[strlen(Item->Params)-1]!='/') && (Item->Params[strlen(Item->Params)-1]!=':'))
  863.               {
  864.                 strcat((V_STRING)*result,"/");
  865.               }
  866.               found++;
  867.  
  868.             }
  869.             break;
  870.           case VTYPE_BOOL:
  871.             *result=(V_BOOL *)LIBCheckBoolean(Item->Params);
  872.             found++;
  873.             break;
  874.           case VTYPE_BIGNUM:
  875.             *result=(V_BIGNUM *)atoi(Item->Params);
  876.             found++;
  877.             break;
  878.           case VTYPE_WORD:
  879.             *result=(WORD *)atoi(Item->Params);
  880.             found++;
  881.             break;
  882.           case VTYPE_SMALLNUM:
  883.             *result=(V_SMALLNUM *)atoi(Item->Params);
  884.             found++;
  885.             break;
  886.           case VTYPE_STRINGLIST:
  887.           case VTYPE_PATHLIST:
  888.             // free existing stringlist if present
  889.  
  890.             if ((found==0) && (*result))
  891.             {
  892.               LIBFreeStrList((V_STRINGLIST)*result);
  893.             }
  894.             if (!(*result))
  895.             {
  896.               if(*result=AllocVec(sizeof (struct List),MEMF_PUBLIC))
  897.               {
  898.                 NewList((struct List*)*result);
  899.               }
  900.             }
  901.             if (*result) // allocated new list ok ?
  902.             {
  903.               if (node=AllocVec(sizeof(struct Node),MEMF_PUBLIC))
  904.               {
  905.                 if (optiontype==VTYPE_PATHLIST)
  906.                 {
  907.                   if (node->ln_Name=AllocVec(strlen(Item->Params)+1,MEMF_CLEAR|MEMF_PUBLIC))
  908.                   {
  909.                     strcpy(node->ln_Name,Item->Params);
  910.                     if ((node->ln_Name[strlen(node->ln_Name)-1]!=':') && (node->ln_Name[strlen(node->ln_Name)-1]!='/'))
  911.                     {
  912.                       strcat(node->ln_Name,"/");
  913.                     }
  914.                   }
  915.                 }
  916.                 else
  917.                 {
  918.                   node->ln_Name=LIBDupStr(Item->Params);
  919.                 }
  920.  
  921.                 if (!(node->ln_Name))
  922.                 {
  923.                   FreeVec(node);
  924.                 }
  925.                 else
  926.                 {
  927.                   AddTail((struct List *)*result,node);
  928.  
  929.                   found++;
  930.  
  931.                   // go to start of list again or we might miss out something..
  932.                   Item = (struct CfgItemData *)cfgfile->ItemsList->lh_Head;
  933.                 }
  934.  
  935.               }
  936.             }
  937.         }
  938.       }
  939.     }
  940.     FreeVec(CompareStr);
  941.   }
  942.   return(found);
  943. }
  944.  
  945. struct CfgFileData __asm __saveds *LIBHBBS_CreateConfig(register __a0 UBYTE *filename)
  946. {
  947.   struct CfgFileData *newcfg;
  948.  
  949.   if (newcfg=(struct CfgFileData *)AllocVec(sizeof(struct CfgFileData),MEMF_PUBLIC|MEMF_CLEAR))
  950.   {
  951.     if (newcfg->ItemsList=(struct List *)AllocVec(sizeof(struct List ),MEMF_PUBLIC))
  952.     {
  953.       NewList(newcfg->ItemsList);
  954.       newcfg->filename=LIBDupStr(filename);  // *C* add errorchecking..
  955.     }
  956.     else
  957.     {
  958.       FreeVec(newcfg);
  959.       newcfg=NULL;
  960.     }
  961.   }
  962.   return(newcfg);
  963. }
  964.  
  965. BOOL __asm __saveds LIBHBBS_RemoveCfgItem(register __a0 struct CfgFileData *cfgfile,register __a1 UBYTE *itemname)
  966. {
  967.   struct CfgItemData *node;
  968.   BOOL Removed=FALSE;
  969.   char *match;
  970.  
  971.   if (match=AllocVec((strlen(itemname)*2)+2,MEMF_PUBLIC))
  972.   {
  973.     if (cfgfile && cfgfile->ItemsList)
  974.     {
  975.       for (node = (struct CfgItemData*)cfgfile->ItemsList->lh_Head ;(node->node.ln_Succ) ; node =(struct CfgItemData *)node->node.ln_Succ)
  976.       {
  977.         ParsePatternNoCase(itemname,match,(strlen(itemname)*2)+2);
  978.         if (MatchPatternNoCase(match,node->node.ln_Name))
  979.         {
  980.           Remove((struct Node*)node);
  981.           LIBFreeStr(node->Params);
  982.           LIBFreeStr(node->node.ln_Name);
  983.           FreeVec(node);
  984.           // go to start of list again..
  985.           node=node = (struct CfgItemData*)cfgfile->ItemsList->lh_Head;
  986.           Removed=TRUE;
  987.         }
  988.       }
  989.     }
  990.     FreeVec(match);
  991.   }
  992.   return(Removed);
  993. }
  994.  
  995. BOOL __asm __saveds LIBHBBS_AddCfgItem(register __a0 struct CfgFileData *cfgfile,register __a1 UBYTE *itemname,register __a2 UBYTE *params)
  996. {
  997.   struct CfgItemData *node;
  998.   BOOL Done=FALSE;
  999.  
  1000. /*
  1001.   char *offset,*remstr;
  1002.   short loop;
  1003. */
  1004.   if (cfgfile && cfgfile->ItemsList)
  1005.   {
  1006.     // check to see if itemname is already there..
  1007.  
  1008.     LIBHBBS_RemoveCfgItem(cfgfile,itemname);
  1009.  
  1010. /*
  1011.  * Unsed bit of usefull code, was origonally going to make it so that when you start
  1012.  * adding items of a list to a config items list it removed all the parts of the old
  1013.  * list first..  but decided not to do it this way (at all) but left this bit of code
  1014.  * cos it might be usefull.. :-)
  1015.  *
  1016.     if (offset=strrchr(itemname,'_'))
  1017.     {
  1018.       offset++;
  1019.       if (offset[0]!=0)
  1020.       {
  1021.         if (isdigit(offset[0]))
  1022.         {
  1023.           loop=1;
  1024.           while (isdigit(offset[loop]))
  1025.           {
  1026.             loop++;
  1027.           }
  1028.  
  1029.           if (offset[loop]==0)
  1030.           {
  1031.             if (remstr=AllocVec(strlen(itemname)+2,MEMF_PUBLIC))
  1032.             {
  1033.               LIBstrNcpy(remstr,itemname,offset-itemname);
  1034.               strcat(remstr,"#?");
  1035.  
  1036.               LIBHBBS_RemoveCfgItem(cfgfile,remstr);
  1037.  
  1038.               FreeVec(remstr);
  1039.             }
  1040.           }
  1041.         }
  1042.       }
  1043.     }
  1044. */
  1045.  
  1046.     if (node=AllocVec(sizeof(struct CfgItemData),MEMF_PUBLIC))
  1047.     {
  1048.       node->node.ln_Name=LIBDupStr(itemname);  // *C* add errorchecking..
  1049.       node->Params=LIBDupStr(params);
  1050.       AddTail(cfgfile->ItemsList,(struct Node*)node);
  1051.       Done=TRUE;
  1052.     }
  1053.   }
  1054.   return(Done);
  1055. }
  1056.  
  1057. void __asm __saveds LIBHBBS_ResetNodeData(register __a0 struct NodeData *node)
  1058. {
  1059.   // this function is called a) when a node is initialised
  1060.   // and b) when a node shuts down. (everything is freed first tho..
  1061.  
  1062.   node->LoginType=LOGIN_NONE;
  1063.   node->OnlineStatus=OS_OFFLINE; // node program sets this to ONLINE or OFFLINE
  1064.                               // this shot be used in all door programs to determine
  1065.                               // carrier status (even for local logins..)
  1066.   node->User.Valid=FALSE;
  1067.   node->NodeFlags=0L;
  1068.   node->Status=STAT_CLOSED;
  1069.   node->NodePort=NULL;
  1070.   node->SettingsOpen=FALSE;
  1071.   node->InformationOpen=FALSE;
  1072.   node->ConOK=FALSE;
  1073.   node->SerOK=FALSE;
  1074.   node->SerOPEN=FALSE;
  1075.   node->SerWaiting=FALSE;
  1076.   node->ConWaiting=FALSE;
  1077.   node->ReplyPort=NULL;
  1078.   node->RequestShutdown=FALSE;
  1079.   node->ActiveDoor=NULL;
  1080.   node->DoorsRunning=0;
  1081.   node->DoorReturn[0]=0;
  1082.   node->CurrentLine[0]=0;
  1083.   node->TransferringFile=FALSE;
  1084.   node->TaggedFiles=0;
  1085.   node->AllowLogins=TRUE;
  1086.   strcpy(node->Action,"Initialising!"); // max 29 chars!
  1087.   node->ConnectBaud[0]=0; // max 8 chars..
  1088.  
  1089.   node->Current_Last_Callers=0;
  1090.   node->Current_Last_Uploads=0;
  1091.   node->Current_Last_Downloads=0;
  1092.   node->Current_Last_PWFails=0;
  1093.   node->Current_Last_Carrier=0;
  1094.   node->Current_Last_Pagers=0;
  1095.  
  1096.   // *C* make sysop definable..
  1097.   node->Max_Last_Callers=10;
  1098.   node->Max_Last_Uploads=10;
  1099.   node->Max_Last_Downloads=10;
  1100.   node->Max_Last_PWFails=10;
  1101.   node->Max_Last_Carrier=10;
  1102.   node->Max_Last_Pagers=10;
  1103. }
  1104.  
  1105. void  __asm __saveds LIBHBBS_rterror(register __a0 char *str)
  1106. {
  1107.   rtEZRequestTags(str,str_OK,NULL,NULL,RTGS_Flags, GSREQF_CENTERTEXT,TAG_END);
  1108. }
  1109.  
  1110.  
  1111. LONG  __asm __saveds LIBHBBS_RunDOSCMD(register __a0 char *command,register __d0 BOOL ASYNC)
  1112. {
  1113.   LONG retval=-1;
  1114.   static ULONG sysargs[] =
  1115.   {
  1116.     SYS_Input,NULL,
  1117.     SYS_Output,NULL,
  1118.     SYS_Asynch,TRUE,
  1119.     SYS_UserShell,TRUE,
  1120.     NP_Priority,0L,
  1121.     TAG_DONE
  1122.   };
  1123.   BPTR outputfile;
  1124.   sysargs[5]=ASYNC;
  1125.  
  1126.   if (outputfile = Open(str_CONSOLE,MODE_OLDFILE))
  1127.   {
  1128.     sysargs[1]=(ULONG)outputfile;
  1129.     LIBreplace(command,command,"@S@",str_CtrlScrnName);
  1130.     retval=SystemTagList(command,(struct TagItem *)sysargs);
  1131.     if (!ASYNC) Close(outputfile); // close window if not async
  1132.   }
  1133.   return(retval);
  1134.  
  1135.   // *C* perhaps add a routine to close async'ed windows after 5 mins ??
  1136. }
  1137.  
  1138. void __asm __saveds LIBHBBS_DoErrorMessage(register __d0 ULONG num,register __d1 ULONG node,register __a0 char *errstr)
  1139. {
  1140.   char *str;
  1141.   int len=20; // 20 extra chars should be ok for the numbers
  1142.  
  1143.   if (errstr) len+=strlen(errstr);
  1144.  
  1145.   if (str=AllocVec(len+strlen(PRG_ERRORMESSAGE),MEMF_PUBLIC))
  1146.   {
  1147.     sprintf(str,"%s %d %d ",PRG_ERRORMESSAGE,num,node);
  1148.     if (errstr) strcat(str,errstr);
  1149.     LIBHBBS_RunDOSCMD(str,TRUE); // *C* false ?
  1150.     FreeVec(str);
  1151.   }
  1152. }
  1153.  
  1154. void __asm __saveds LIBcvtucase(register __a0  char *str)
  1155. {
  1156.   int loop;
  1157.   for (loop=0;str[loop]!=0;loop++)
  1158.   {
  1159.     str[loop]=toupper(str[loop]);
  1160.   }
  1161. }
  1162.  
  1163. BOOL __asm __saveds LIBAssignOK(register __a0 char *checkme )
  1164. {
  1165.   struct DosList      *DosList;
  1166.   struct DeviceNode   *DevNode;
  1167.   UBYTE           *Pointer;
  1168.   char string[32]="",cmpstring[32]="";
  1169.   int loop;
  1170.   BOOL found=FALSE;
  1171.  
  1172.   for (loop = 0 ; checkme[loop]!=0 && checkme[loop]!=':' && checkme[loop]!='/' ; loop++);
  1173.   LIBstrNcpy(cmpstring,checkme,loop);// +1); // +1 cos we WANT the ':'
  1174.   LIBcvtucase(cmpstring);
  1175.   DosList = LockDosList(LDF_ALL|LDF_READ);
  1176.   while((DosList = NextDosEntry(DosList,LDF_ALL|LDF_READ)) && !found)
  1177.   {
  1178.     DevNode = (struct DeviceNode *)DosList;
  1179.  
  1180.     // assign or volume ?
  1181.     if (DevNode->dn_Type==DLT_DIRECTORY || DevNode->dn_Type==DLT_DEVICE || DevNode->dn_Type==DLT_VOLUME)
  1182.     {
  1183.       Pointer = (UBYTE *)BADDR(DevNode -> dn_Name);
  1184.       if (Pointer[0])
  1185.       {
  1186.         for(loop = 0 ; loop < Pointer[0] ; loop++)
  1187.                           string[loop] = Pointer[loop + 1];
  1188.  
  1189.         string[Pointer[0]]   = 0; /* terminate string */
  1190. //        strcat(string,":");
  1191.         LIBcvtucase(string);
  1192.         if (strcmp(cmpstring,string)==0) found=TRUE;
  1193.       }
  1194.     }
  1195.   }
  1196.   UnLockDosList(LDF_ALL|LDF_READ);
  1197.   return(found);
  1198. }
  1199.  
  1200. BOOL __asm __saveds LIBHBBS_InitCommon( void )
  1201. {
  1202.   SysBase = *(struct ExecBase **) 4L;
  1203.   if (DOSBase = (struct DosLibrary *) OpenLibrary ("dos.library", 0))
  1204.   {
  1205.     if (ReqToolsBase = (struct ReqToolsBase *) OpenLibrary (REQTOOLSNAME, REQTOOLSVERSION))
  1206.     return(TRUE);
  1207.   }
  1208.   return(FALSE);
  1209. }
  1210.  
  1211. void __asm __saveds LIBHBBS_CleanUpCommon( void )
  1212. {
  1213.   if (ReqToolsBase) CloseLibrary ((struct Library *)ReqToolsBase);
  1214.   if (DOSBase) CloseLibrary ((struct Library *) DOSBase);
  1215. }
  1216.  
  1217. struct TimerData __asm __saveds *LIBSubmitTimer(register __a0 struct TimerSetupData *TSD, register __d0 ULONG Seconds,register __d1 ULONG MicroSeconds )
  1218. {
  1219.   struct TimerData *TD=NULL;
  1220.  
  1221.   if (TSD)
  1222.   {
  1223.     if (TD=(struct TimerData*)AllocVec(sizeof(struct TimerData),MEMF_PUBLIC))
  1224.     {
  1225.       // copy fields accross from our blank timer IO request
  1226.       // that was initialised by InitTimer();
  1227.  
  1228.       //      Source             Dest   Size
  1229.       CopyMem(TSD->BlankTimerIO,&TD->TR,sizeof(struct timerequest));
  1230.  
  1231.       TD->TR.tr_time.tv_secs   = Seconds;
  1232.       TD->TR.tr_time.tv_micro   = MicroSeconds;
  1233.       AddHead(TSD->TimerList,(struct Node*)TD);
  1234.  
  1235.       SendIO((struct IORequest *)&TD->TR);
  1236.     }
  1237.   }
  1238.   return(TD);
  1239. }
  1240.  
  1241. void __asm __saveds LIBAbortTimer(register __a0 struct TimerSetupData *TSD, register __a1 struct TimerData *CTD)
  1242. {
  1243.   struct TimerData *TD=NULL;
  1244.  
  1245.   if (CTD)
  1246.   {
  1247.     for (TD = (struct TimerData *)TSD->TimerList->lh_Head ; TD->node.ln_Succ ; TD =(struct TimerData *) TD->node.ln_Succ)
  1248.     {
  1249.       if (TD==CTD)
  1250.       {
  1251.         AbortIO((struct IORequest *)&CTD->TR);
  1252.         WaitIO((struct IORequest *)&CTD->TR);
  1253.         Remove((struct Node*)CTD);
  1254.         FreeVec(CTD);
  1255.         // TD is now null so we dont wat to reference it again so return from the func..
  1256.         return;
  1257.       }
  1258.     }
  1259.   }
  1260. }
  1261.  
  1262. BOOL __asm __saveds LIBCheckTimer(register __a0 struct TimerSetupData *TSD, register __a1 struct TimerData *CTD)
  1263. {
  1264.   struct TimerData *TD=NULL;
  1265.  
  1266.   for (TD = (struct TimerData *)TSD->TimerList->lh_Head ; TD->node.ln_Succ ; TD =(struct TimerData *) TD->node.ln_Succ)
  1267.   {
  1268.     if (TD==CTD)
  1269.     {
  1270.       if (CheckIO((struct IORequest *)&CTD->TR))
  1271.       {
  1272.         WaitIO((struct IORequest *)&CTD->TR);
  1273.         Remove((struct Node*)CTD);
  1274.         FreeVec(CTD);
  1275.         return(TRUE);
  1276.       }
  1277.     }
  1278.   }
  1279.   return(FALSE);
  1280. }
  1281.  
  1282. void __asm __saveds LIBCleanupTimer( register __a0 struct TimerSetupData *TSD )
  1283. {
  1284.   struct TimerData *TD=NULL;
  1285.  
  1286.   if (TSD)
  1287.   {
  1288.     if (TSD->TimerPort)
  1289.     {
  1290.       if (TSD->BlankTimerIO)
  1291.       {
  1292.         if (TSD->TimerOpen)
  1293.         {
  1294.           if (TSD->TimerList)
  1295.           {
  1296.             // remove all outstanding io requests..
  1297.             while ((struct TimerData *)TSD->TimerList->lh_Head->ln_Succ)
  1298.             {
  1299.               TD=(struct TimerData *)TSD->TimerList->lh_Head;
  1300.               AbortIO((struct IORequest *)&TD->TR);
  1301.               WaitIO((struct IORequest *)&TD->TR);
  1302.               Remove((struct Node*)TD);
  1303.               FreeVec(TD);
  1304.             }
  1305.             FreeVec(TSD->TimerList);
  1306.           }
  1307.           CloseDevice((struct IORequest *) TSD->BlankTimerIO);
  1308.           TSD->TimerOpen=FALSE;
  1309.         }
  1310.         DeleteExtIO((struct IORequest *) TSD->BlankTimerIO);
  1311.       }
  1312.       DeleteMsgPort(TSD->TimerPort);
  1313.     }
  1314.     FreeVec(TSD);
  1315.   }
  1316. }
  1317.  
  1318. struct TimerSetupData __asm __saveds *LIBInitTimer( void )
  1319. {
  1320.   struct TimerSetupData *TSD;
  1321.  
  1322.   if (TSD=AllocVec(sizeof(struct TimerSetupData),MEMF_PUBLIC))
  1323.   {
  1324.     TSD->TimerOpen=FALSE;
  1325.     if (TSD->TimerPort = CreateMsgPort())
  1326.     {
  1327.       if (TSD->BlankTimerIO = (struct timerequest *) CreateExtIO(TSD->TimerPort,sizeof(struct timerequest)) )
  1328.       {
  1329.         if (OpenDevice( TIMERNAME, UNIT_VBLANK,(struct IORequest *) TSD->BlankTimerIO, 0L)==0) // success ?
  1330.         {
  1331.           TSD->TimerOpen=TRUE;
  1332.           TSD->BlankTimerIO->tr_node.io_Command = TR_ADDREQUEST;
  1333.           if (TSD->TimerList=AllocVec(sizeof(struct List),MEMF_PUBLIC))
  1334.           {
  1335.             NewList((struct List *)TSD->TimerList);
  1336.             return(TSD);
  1337.           }
  1338.         }
  1339.       }
  1340.     }
  1341.     LIBCleanupTimer(TSD);
  1342.   }
  1343.   return(NULL);
  1344. }
  1345.  
  1346. BOOL __asm __saveds LIBPathOK(register __a0 char *str)
  1347. {
  1348.   BPTR FL;
  1349.  
  1350.   if (LIBAssignOK(str))
  1351.   {
  1352.     if (FL=Lock(str,ACCESS_READ))
  1353.     {
  1354.       UnLock(FL);
  1355.       return(TRUE);
  1356.     }
  1357.   }
  1358.   return(FALSE);
  1359. }
  1360.  
  1361. BOOL  __asm __saveds LIBHBBS_LoadUser(register __d0 V_BIGNUM ID,register __a0 char *handle,register __a1 char *realname,register __a2 struct UserData *user)
  1362. {
  1363.   // specify only one of ID,handle or realname
  1364.   // "user" should already be allocated..
  1365.  
  1366.   BPTR FH;
  1367.   BPTR FL;
  1368.   V_BOOL Found=FALSE;
  1369.  
  1370.   if(user)
  1371.   {
  1372.     if (ID>0)
  1373.     {
  1374.       // keep trying..
  1375.       while (!(FL=Lock(BBSGlobal->UserDataFileName,ACCESS_READ)));
  1376.       if (FH=OpenFromLock(FL))
  1377.       {
  1378.         if (Seek(FH,(ID-1)*sizeof(struct UserData),OFFSET_BEGINNING)!=-1)
  1379.         {
  1380.           if (Read(FH,user,sizeof(struct UserData))==sizeof(struct UserData))
  1381.           {
  1382.             Found=TRUE;
  1383.           }
  1384.           // else puts("Short Read!");
  1385.         }
  1386.         Close(FH);
  1387.       }
  1388.       // else puts("Error Opening Userdata file");
  1389.       if (Found) return(TRUE);
  1390.     }
  1391.     else
  1392.     {
  1393.       if (handle!=NULL)
  1394.       {
  1395. //      printf("Searching for user with a handle of %s\n",handle);
  1396.       }
  1397.       else
  1398.       {
  1399.         if (realname!=NULL)
  1400.         {
  1401. //        printf("Searching for user with a realname of %s\n",realname);
  1402.         }
  1403.       }
  1404.     }
  1405.   }
  1406.   return(FALSE);
  1407. }
  1408.  
  1409. V_BOOL __asm __saveds LIBHBBS_ValidUserHandle(register __a0 char *userhandle, register __a1 struct UserData *FillUser)
  1410. {
  1411.  
  1412.   // Small routing to see if a user name does exist, if the user does
  1413.   // exist and FillUser points an allocated data structure the size of
  1414.   // sizeof(struct UserData) then the uses info that was found will be copied
  1415.   // to there.
  1416.  
  1417.   V_BIGNUM CurrentUserNum=0;
  1418.   V_BOOL Found=FALSE;
  1419.   struct UserData User;
  1420.  
  1421.   if (BBSGlobal->TotalUsers>=0) // spose we better check this :-)
  1422.   {
  1423.     while (!Found && CurrentUserNum<BBSGlobal->TotalUsers)
  1424.     {
  1425.       CurrentUserNum++;
  1426.       // printf("Searching %d For User \"%s\"\n",CurrentUserNum,userhandle);
  1427.       if (LIBHBBS_LoadUser(CurrentUserNum,NULL,NULL,&User))
  1428.       {
  1429.         // *C* insert pattern matching routine here..
  1430.         // or not ?  perhps add an "Interactive Y/N" parameter.
  1431.  
  1432.         if (stricmp(userhandle,User.Handle)==0)
  1433.         {
  1434.           Found=TRUE;
  1435.         }
  1436.       }
  1437.       // else puts("Failed To Load User");
  1438.     }
  1439.   }
  1440.   if (Found && FillUser)
  1441.   {
  1442.  
  1443.     CopyMem(&User,FillUser,sizeof (struct UserData));
  1444.   }
  1445.   return(Found);
  1446. }
  1447.  
  1448. V_BIGNUM __asm __saveds LIBHBBS_FindTotalUsers( void )
  1449. {
  1450.   BPTR FL;
  1451.   struct FileInfoBlock FB;
  1452.  
  1453.   BBSGlobal->TotalUsers=-1;
  1454.  
  1455.   // keep trying!
  1456.  
  1457.   while (!(FL=Lock(BBSGlobal->UserDataFileName,ACCESS_READ)));
  1458.   if (Examine(FL,&FB));
  1459.   {
  1460.     BBSGlobal->TotalUsers=(V_BIGNUM)(FB.fib_Size / sizeof(struct UserData));
  1461.   }
  1462.   UnLock(FL);
  1463.  
  1464.   return(BBSGlobal->TotalUsers);
  1465. }
  1466.  
  1467. BOOL __asm __saveds LIBLoadPrivateData( void )
  1468. {
  1469.   struct CfgFileData *PrivateCFG;
  1470.   BOOL retval=FALSE;
  1471.  
  1472.   if (PrivateCFG=LIBHBBS_LoadConfig(FILE_PRIVATEDATA,LCFG_NONE))
  1473.   {
  1474.     if (LIBHBBS_GetSetting(PrivateCFG,(void *)&BBSGlobal->LastUserNum,VTYPE_BIGNUM,OPT_PRIV_LastUserNum,OPT_SINGLE))
  1475.     {
  1476.       retval=TRUE;
  1477.     }
  1478.     LIBHBBS_FlushConfig(PrivateCFG);
  1479.   }
  1480.  
  1481.   return(retval);
  1482. }
  1483.  
  1484. void __asm __saveds LIBUpdatePrivateData ( void )
  1485. {
  1486.   struct CfgFileData *PrivateCFG;
  1487.   char str[BIG_STR];
  1488.  
  1489.   if (PrivateCFG=LIBHBBS_CreateConfig(FILE_PRIVATEDATA))
  1490.   {
  1491.     sprintf(str,"%d",BBSGlobal->LastUserNum);
  1492.  
  1493.     LIBHBBS_AddCfgItemQuick(PrivateCFG,OPT_PRIV_LastUserNum,str);
  1494.     LIBHBBS_SaveConfig(PrivateCFG);
  1495.     LIBHBBS_FlushConfig(PrivateCFG);
  1496.   }
  1497. }
  1498.  
  1499. BOOL __asm __saveds LIBHBBS_AddUser(register __a0 struct UserData *user)
  1500. {
  1501.   // *C* need to add some checking/locking of file for multinode operation..
  1502.  
  1503.   BPTR FH;
  1504.   BPTR FL;
  1505.  
  1506.   BOOL Saved=FALSE;
  1507.  
  1508.   // *C* need to check to see if file exists... (or get setup program to create..)
  1509.  
  1510.   // get exclusive access to userdata file when writing..
  1511.  
  1512.   while (!(FL=Lock(BBSGlobal->UserDataFileName,ACCESS_WRITE))); // keep trying..
  1513.  
  1514.   if (FH=OpenFromLock(FL)) //(BBSGlobal->UserDataFileName,MODE_OLDFILE))
  1515.   {
  1516.     if (Seek(FH,0,OFFSET_END)!=-1)
  1517.     {
  1518.       BBSGlobal->LastUserNum++;
  1519.       user->UserID=BBSGlobal->LastUserNum;
  1520.       if (Write(FH,user,sizeof(struct UserData))==sizeof(struct UserData))
  1521.       {
  1522.         LIBUpdatePrivateData();
  1523.  
  1524.  
  1525.         Saved=TRUE;
  1526.       }
  1527.       else
  1528.       {
  1529.         // puts("Error Adding Data To File, Truncating..");
  1530.         if (SetFileSize(FH,OFFSET_BEGINNING,BBSGlobal->TotalUsers * sizeof(struct UserData))==-1)
  1531.         {
  1532.           // puts("Cound Not Truncate File!");
  1533.         }
  1534.       }
  1535.     } // else puts("Seek() Failed!");
  1536.     Close(FH);
  1537.   }
  1538.   else UnLock(FL);
  1539.  
  1540.   LIBHBBS_FindTotalUsers();
  1541.   return(Saved);
  1542. }
  1543.  
  1544. void __asm __saveds LIBHBBS_InitUserData(register __a0 struct UserData *User)
  1545. {
  1546.   User->Status=USER_NEW;
  1547.   User->Access=BBSGlobal->NewUserAccessLevel;
  1548.   User->Handle[0]=0;
  1549.   User->RealName[0]=0;
  1550.   User->Group[0]=0;
  1551.   User->GeoLocation[0]=0;
  1552.   User->Country[0]=0;
  1553.   User->PhoneNumber[0]=0;
  1554.   User->Password[0]=0;
  1555.   User->ComputerType[0]=0;
  1556.   User->ConfAccDataFile[0]=0;
  1557.   User->LeechAccDataFile[0]=0;
  1558.   User->UploadBytes=0;
  1559.   User->UploadFiles=0;
  1560.   User->DownloadBytes=0;
  1561.   User->DownloadFiles=0;
  1562.   User->ActualUploadBytes=0;
  1563.   User->ActualUploadFiles=0;
  1564.   User->ActualDownloadBytes=0;
  1565.   User->ActualDownloadFiles=0;
  1566.   User->LastUploadDate=0; // *C* add HBBS_Todate() ?
  1567.   User->LastCalledDate=0;
  1568.   User->BestCPSUp=0;
  1569.   User->BestCPSDown=0;
  1570.   User->CallsMade=0;
  1571.   User->PagesMade=0;
  1572.   User->MessagesWritten=0;
  1573.   User->FilesRatio=3;
  1574.   User->BytesRatio=3;
  1575.   User->LastConf=1;
  1576.   User->PreferedConf=0;
  1577.   User->LinesPerScreen=24;
  1578.   User->Protocol=0; // ASK
  1579.   User->Editor=0; // ASK
  1580.   User->TimeAccessFile[0]=0;
  1581.   User->ExtraTimeLimit=0;
  1582.   User->ExtraBytesLimit=0;
  1583.   User->ExtraCallsLimit=0;
  1584.   User->ExtraChatLimit=0;
  1585.   User->TimeUsed=0;
  1586.   User->BytesUsed=0;
  1587.   User->CallsUsed=0;
  1588.   User->ChatUsed=0;
  1589.   User->BytesAllowed=0;
  1590.   User->TimeAllowed=0;
  1591.   User->CallsAllowed=0;
  1592.   User->ChatAllowed=0;
  1593.   User->UserType=USERTYPE_NORMAL;
  1594.   User->Language=0; // .TXT or the first one in the list..
  1595. }
  1596.  
  1597. void __asm __saveds LIBstrNcpy(register __a0 UBYTE *dest,register __a1 UBYTE *source,register __d0 int chars)
  1598. {
  1599.   int count=0;
  1600.  
  1601.   while ((dest[count]=source[count]) && count<chars-1) count++;
  1602.   dest[count+1]=0;
  1603. }
  1604.  
  1605. char __asm __saveds *LIBHBBS_ListName(register __a0 V_STRINGLIST ListName,register __d0 V_SMALLNUM ItemNum)
  1606. { //starts from offset 0, 0 being the first node in the list..
  1607.   struct Node *node;
  1608.  
  1609.   if(node=LIBGetNode(ListName,ItemNum))
  1610.   {
  1611.     return(node->ln_Name);
  1612.   }
  1613.   return(NULL);
  1614. }
  1615.  
  1616. void __asm __saveds LIBFreeFileTags( register __a0 struct NodeData *N_ND )
  1617. {
  1618.   struct TaggedFile *tfnode;
  1619.   while ((N_ND->TaggedFileList) && (N_ND->TaggedFileList->lh_Head->ln_Succ))
  1620.   {
  1621.     tfnode=(struct TaggedFile *)N_ND->TaggedFileList->lh_Head;
  1622.     LIBFreeStr(tfnode->node.ln_Name);
  1623.     Remove((struct Node*)tfnode);
  1624.     FreeVec(tfnode);
  1625.   }
  1626.   N_ND->TaggedFiles=0;
  1627. }
  1628.  
  1629. /*
  1630.  
  1631.  
  1632. struct List __asm __saveds *LIBHBBS_LoadFile(register __a0 char *filename)
  1633. {
  1634.   BPTR FL,FH;
  1635.   LONG bufferpos;
  1636.   BOOL done;
  1637.   struct FileInfoBlock FB;
  1638.   UBYTE *Data=NULL;
  1639.   LONG Length=0,filepos=0;
  1640.   UBYTE buffer[bufflen];
  1641.   struct List *FileList=NULL;
  1642.  
  1643.   if (FL=Lock(filename,ACCESS_READ))
  1644.   {
  1645.     if (Examine(FL,&FB))
  1646.     {
  1647.       if (FB.fib_Size)
  1648.       {
  1649.         if (Data=AllocVec(FB.fib_Size,MEMF_PUBLIC))
  1650.         {
  1651.           if (FH=OpenFromLock(FL))
  1652.           {
  1653.             Length=Read(FH,Data,FB.fib_Size);
  1654.             Close(FH);
  1655.           }
  1656.         }
  1657.       }
  1658.     }
  1659.     UnLock(FL);
  1660.  
  1661.     if ((Data) && (Length>0))
  1662.     {
  1663.       if (FileList=LIBHBBS_CreateList())
  1664.       {
  1665.  
  1666.         do
  1667.         {
  1668.           bufferpos=0;
  1669.           done=FALSE;
  1670.           do
  1671.           {
  1672.  
  1673.             if (Data[filepos]==13) //cr
  1674.             {
  1675.               if ((filepos+1<Length) && (Data[filepos+1]==10)) // cr followed by lf ?
  1676.               {
  1677.                 done=TRUE;
  1678.                 filepos++;//skip the lf too.
  1679.               }
  1680.               else
  1681.               {
  1682.                 done=TRUE;
  1683.               }
  1684.               filepos++; //skip the cr
  1685.             }
  1686.             else
  1687.             {
  1688.               if (Data[filepos]==10) //lf
  1689.               {
  1690.                 done=TRUE;
  1691.                 filepos++;
  1692.               }
  1693.               else
  1694.               {
  1695.                 buffer[bufferpos]=Data[filepos];
  1696.                 filepos++;
  1697.                 bufferpos++;
  1698.               }
  1699.             }
  1700.           } while (filepos<Length && !done && bufferpos<bufflen-2); // 1 for null and 1 more cos we still have to add the null
  1701.           buffer[bufferpos]=0;
  1702.  
  1703.           LIBNewStrNode(buffer,FileList);
  1704.  
  1705.         } while (filepos<Length);
  1706.       }
  1707.     }
  1708.     if (Data) FreeVec(Data);
  1709.   }
  1710.   return(FileList);
  1711. }
  1712. */
  1713.  
  1714.  
  1715. #define bufflen 1024
  1716.  
  1717. struct List __asm __saveds *LIBHBBS_LoadFile(register __a0 char *filename)
  1718. {
  1719.   /* New Optimized Version: 4-JAN-1996 */
  1720.  
  1721.   BPTR FH;
  1722.   UBYTE buffer[bufflen];
  1723.   struct List *FileList=NULL;
  1724.   BOOL error=FALSE;
  1725.  
  1726.   if (LIBPathOK(filename))
  1727.   {
  1728.     if (FH=Open(filename,MODE_OLDFILE))
  1729.     {
  1730.       if (FileList=LIBHBBS_CreateList())
  1731.       {
  1732.         while (FGets(FH,buffer,bufflen) && !error)
  1733.         {
  1734.           LIBstripcr(buffer);
  1735.           if (LIBNewStrNode(buffer,FileList))
  1736.           {
  1737.             error=TRUE;
  1738.           }
  1739.         }
  1740.       }
  1741.       Close(FH);
  1742.     }
  1743.   }
  1744.   if (error)
  1745.   {
  1746.     LIBFreeStrList(FileList);
  1747.     FileList=NULL;
  1748.   }
  1749.   return(FileList);
  1750. }
  1751.  
  1752.  
  1753. BOOL __asm __saveds LIBHBBS_SaveFile( register __a0 char *file_name, register __a1 struct List *list)
  1754. {
  1755.   BPTR FH;
  1756.   struct Node *node;
  1757.  
  1758.   if (FH=Open(file_name,MODE_NEWFILE))
  1759.   {
  1760.     for (node = list->lh_Head ; node->ln_Succ ; node =node->ln_Succ)
  1761.     {
  1762.       Write(FH,node->ln_Name,strlen(node->ln_Name));
  1763.       Write(FH,"\n",1); //add cr+lf
  1764.     }
  1765.     Close(FH);
  1766.   }
  1767.   return((BOOL)(FH ? TRUE : FALSE));
  1768. }
  1769.  
  1770. struct List __asm __saveds *LIBHBBS_CreateList( void )
  1771. {
  1772.   struct List *NList;
  1773.   if (NList=AllocVec(sizeof(struct List),MEMF_PUBLIC))
  1774.   {
  1775.     NewList(NList);
  1776.   }
  1777.   return(NList);
  1778. }
  1779.  
  1780. void __asm __saveds LIBstrftcpy(register __a0 char *dest,register __a1  char *source,register __d0 int from,register __d1 int topos)
  1781. {
  1782.   int loop=from,pos=0;
  1783.   if (from<=strlen(source)-1)
  1784.   {
  1785.     while (source[loop] && loop<=topos)
  1786.     {
  1787.       dest[pos]=source[loop];
  1788.       loop++;
  1789.       pos++;
  1790.     }
  1791.   }
  1792.   dest[pos]=0;
  1793. }
  1794.  
  1795. void __asm __saveds LIBRemoveSpaces(register __a0 char *string)
  1796. {
  1797.   // removes spaces from the start end end of strings
  1798.   ULONG start,end,len;
  1799.  
  1800.   if (string)
  1801.   {
  1802.     len=strlen(string);
  1803.     for (start=0;string[start]==' ';start++);
  1804.     for (end=len-1;string[end]==' ';end--);
  1805.     LIBstrftcpy(string,string,start,end);
  1806.   }
  1807. }
  1808.  
  1809.  
  1810. void __asm __saveds LIBHBBS_SaveUserData(register __a0 struct UserData *User)
  1811. {
  1812.   // *C* here we should save the data in N_ND->User.NormalData
  1813.   // back to the user file..
  1814.  
  1815.   BPTR FH,FL;
  1816.   BOOL Found,ReadError=FALSE;
  1817.   struct UserData OldUser;
  1818.  
  1819.   while (!(FL=Lock(BBSGlobal->UserDataFileName,ACCESS_WRITE)));
  1820.   if (FH=OpenFromLock(FL))
  1821.   {
  1822.     Found=FALSE;
  1823.     while (!Found && !ReadError)
  1824.     {
  1825.       // keep going until the end of the file or we get a read error..
  1826.       ReadError=((Read(FH,&OldUser,sizeof(struct UserData))==sizeof(struct UserData)) ? FALSE : TRUE );
  1827.  
  1828.       if (!ReadError)
  1829.       {
  1830.         if (OldUser.UserID==User->UserID)
  1831.         {
  1832.           Found=TRUE;
  1833.         }
  1834.       }
  1835.     }
  1836.     if (Found)
  1837.     {
  1838.       // *C* if error on next to commands then loop until it works ?
  1839.  
  1840.       // seek to start of record.
  1841.       Seek(FH,0-sizeof(struct UserData),OFFSET_CURRENT);
  1842.       Write(FH,User,sizeof(struct UserData));
  1843.     }
  1844.     Close(FH);
  1845.   }
  1846.   else UnLock(FL);
  1847. }
  1848.  
  1849. void __asm __saveds LIBHBBS_GetDate(register __a0 char *datestr)
  1850. {
  1851.   struct tm *timestruct;
  1852.   long t;
  1853.   if (datestr)
  1854.   {
  1855.     time(&t);
  1856.     timestruct=localtime(&t);
  1857.  
  1858.     LIBHBBS_DateStrFromTM(datestr,timestruct);
  1859.  
  1860. /*
  1861.     sprintf(datestr,"%s%d-%s-%-04d",(timestruct->tm_mday < 10) ? "0" : "",timestruct->tm_mday,monthstr[timestruct->tm_mon],timestruct->tm_year + 1900);
  1862. */
  1863.   }
  1864.   free(timestruct);
  1865. }
  1866.  
  1867. V_BOOL __asm __saveds LIBHBBS_AddCfgItemQuick(register __a0 struct CfgFileData *cfgfile,register __a1 char *ItemName, register __a2 char *Params)
  1868. {
  1869.   struct CfgItemData *node;
  1870.   V_BOOL retval=FALSE;
  1871.  
  1872.   if (cfgfile && ItemName && Params)
  1873.   {
  1874.     if (node=AllocVec(sizeof(struct CfgItemData),MEMF_PUBLIC))
  1875.     {
  1876.       node->node.ln_Name=LIBDupStr(ItemName);     // *C* error check me! (or not ?)
  1877.       node->Params=LIBDupStr(Params);
  1878.       AddTail(cfgfile->ItemsList,(struct Node*)node);
  1879.       retval=TRUE;
  1880.     }
  1881.   }
  1882.   return(retval);
  1883. }
  1884.  
  1885. void __asm __saveds LIBHBBS_SaveCallsData( void )
  1886. {
  1887.   struct CfgFileData *CfgFile;
  1888.   struct NodeData *nd;
  1889.   UBYTE tmpstr[200],optionstr[200];
  1890.  
  1891.  
  1892.   if (CfgFile=LIBHBBS_CreateConfig("HBBS:System/Data/Calls.CFG"))
  1893.   {
  1894.     LIBHBBS_GetDate(tmpstr);
  1895.     LIBHBBS_AddCfgItemQuick(CfgFile,"Today",tmpstr);
  1896.  
  1897.     sprintf(tmpstr,"%d",BBSGlobal->CallsToday);
  1898.     LIBHBBS_AddCfgItemQuick(CfgFile,"TotalCalls",tmpstr);
  1899.  
  1900.     for (nd=(struct NodeData *)BBSGlobal->NodeList->lh_Head;nd->node.ln_Succ;nd=(struct NodeData *)nd->node.ln_Succ)
  1901.     {
  1902.       sprintf(optionstr,"Node_%d_Calls",nd->NodeNum);
  1903.       sprintf(tmpstr,"%d",nd->CallsToday);
  1904.       LIBHBBS_AddCfgItemQuick(CfgFile,optionstr,tmpstr);
  1905.     }
  1906.     LIBHBBS_SaveConfig(CfgFile);
  1907.     LIBHBBS_FlushConfig(CfgFile);
  1908.   }
  1909.  
  1910. }
  1911.  
  1912. void __asm __saveds LIBHBBS_LoadCallsData( void )
  1913. {
  1914.   struct CfgFileData *CfgFile;
  1915.   BOOL Loaded=FALSE;
  1916.   V_STRING TodayStr=NULL;
  1917.   UBYTE tmpstr[200];
  1918.   struct NodeData *nd;
  1919.  
  1920.   LIBHBBS_GetDate(tmpstr);
  1921.  
  1922.   if (CfgFile=LIBHBBS_LoadConfig("HBBS:System/Data/Calls.CFG",LCFG_NONE))
  1923.   {
  1924.     if (LIBHBBS_GetSetting(CfgFile,(void *)&TodayStr,VTYPE_STRING,"Today",OPT_SINGLE))
  1925.     {
  1926.       if (stricmp(TodayStr,tmpstr)==0) // same day ???
  1927.       {
  1928.         if (LIBHBBS_GetSetting(CfgFile,(void *)&BBSGlobal->CallsToday,VTYPE_BIGNUM,"TotalCalls",OPT_SINGLE))
  1929.         {
  1930.           for (nd=(struct NodeData *)BBSGlobal->NodeList->lh_Head;nd->node.ln_Succ;nd=(struct NodeData *)nd->node.ln_Succ)
  1931.           {
  1932.             sprintf(tmpstr,"Node_%d_Calls",nd->NodeNum);
  1933.             if (!LIBHBBS_GetSetting(CfgFile,(void *)&nd->CallsToday,VTYPE_BIGNUM,tmpstr,OPT_SINGLE))
  1934.             {
  1935.               nd->CallsToday=0;
  1936.             }
  1937.           }
  1938.           Loaded=TRUE;
  1939.         }
  1940.       }
  1941.     }
  1942.   }
  1943.   if (!Loaded)
  1944.   {
  1945.     BBSGlobal->CallsToday=0;
  1946.  
  1947.     for (nd=(struct NodeData *)BBSGlobal->NodeList->lh_Head;nd->node.ln_Succ;nd=(struct NodeData *)nd->node.ln_Succ)
  1948.     {
  1949.       nd->CallsToday=0;
  1950.     }
  1951.     LIBHBBS_SaveCallsData();
  1952.   }
  1953.   if (TodayStr) LIBFreeStr(TodayStr);
  1954. }
  1955.  
  1956. void __asm __saveds LIBHBBS_GetTime(register __a0 char *timestr)
  1957. {
  1958.   struct tm *timestruct;
  1959.   long t;
  1960.  
  1961.   if (timestr)
  1962.   {
  1963.     time(&t);
  1964.     timestruct=localtime(&t);
  1965.  
  1966.     sprintf(timestr,"%s%d:%s%d:%s%d",(timestruct->tm_hour < 10) ? "0" : "",timestruct->tm_hour,
  1967.                                      (timestruct->tm_min < 10) ? "0" : "",timestruct->tm_min,
  1968.                                      (timestruct->tm_sec < 10) ? "0" : "",timestruct->tm_sec);
  1969.   }
  1970.   free(timestruct);
  1971. }
  1972.  
  1973. void __asm __saveds LIBHBBS_GetDateStr(register __a0 char *datestr,register __d0 long t)
  1974. {
  1975.   long tt=t;
  1976.   struct tm *timestruct;
  1977.   if (datestr)
  1978.   {
  1979.     timestruct=localtime(&tt);
  1980.  
  1981. /*
  1982.     if (timestruct->tm_mday<0)
  1983.     {
  1984.       strcpy(datestr,"01-JAN-1970"); // date limit!
  1985.     }
  1986.     else
  1987.     {
  1988.       sprintf(datestr,"%s%d-%s-%-04d",(timestruct->tm_mday < 10) ? "0" : "",timestruct->tm_mday,monthstr[timestruct->tm_mon],timestruct->tm_year+1900);
  1989.     }
  1990. */
  1991.     LIBHBBS_DateStrFromTM(datestr,timestruct);
  1992.     free(timestruct);
  1993.   }
  1994. }
  1995.  
  1996. void __asm __saveds LIBHBBS_DateStrFromTM(register __a0 UBYTE *datestr, register __a1 struct tm *timestruct)
  1997. {
  1998.   if (datestr && timestruct)
  1999.   {
  2000.     if (timestruct->tm_mday<0)
  2001.     {
  2002.       strcpy(datestr,"01-JAN-1970"); // date limit!
  2003.     }
  2004.     else
  2005.     {
  2006.       sprintf(datestr,"%s%d-%s-%-04d",(timestruct->tm_mday < 10) ? "0" : "",timestruct->tm_mday,monthstr[timestruct->tm_mon],timestruct->tm_year+1900);
  2007.     }
  2008.   }
  2009.  
  2010. }
  2011.  
  2012. V_BOOL __asm __saveds LIBHBBS_DateStrToTM(register __a0 UBYTE *datestr, register __a1 struct tm *timestruct)
  2013. {
  2014.   UBYTE tmpstr[5];
  2015.   LONG tday,tmon=-1,tyear,loop;
  2016.  
  2017.   LIBstrNcpy(tmpstr,datestr,2);
  2018.   if (sscanf(tmpstr,"%ld",&tday))
  2019.   {
  2020.     LIBstrftcpy(tmpstr,datestr,3,5);
  2021.     for (loop=0;loop<=12 && tmon==-1;loop++)
  2022.     {
  2023.       if (stricmp(tmpstr,monthstr[loop])==0)
  2024.       {
  2025.         tmon=loop;
  2026.       }
  2027.     }
  2028.     if (tmon>=0)
  2029.     {
  2030.       LIBstrftcpy(tmpstr,datestr,7,10);
  2031.       if (sscanf(tmpstr,"%ld",&
  2032.       tyear))
  2033.       {
  2034.         tyear-=1900;
  2035.         if ((tyear>=70) && (tmon>=0) && (tmon<12) && (tday>=1) && (tday<=31))
  2036.         {
  2037.           // all data is ok, so opy it to the timestruct!
  2038.           timestruct->tm_mday=tday;
  2039.           timestruct->tm_year=tyear;
  2040.           timestruct->tm_mon=tmon;
  2041.           return(TRUE);
  2042.         }
  2043.       }
  2044.     }
  2045.   }
  2046.   return(FALSE);
  2047. }
  2048.  
  2049. void *AllocBuffer(ULONG *BufferSize,ULONG Flags) // min 10 bytes!
  2050. {
  2051.   void *retval=NULL;
  2052.  
  2053.   if (*BufferSize)
  2054.   {
  2055.     if (*BufferSize<10) *BufferSize=10;
  2056.     while ((*BufferSize>10) && ((retval=AllocVec(*BufferSize,Flags))==NULL))
  2057.     {
  2058.       *BufferSize/=2; // divide buffersize by 2!
  2059.     }
  2060.  
  2061.   }
  2062.   return(retval);
  2063. }
  2064.  
  2065. V_BOOL __asm __saveds LIBHBBS_CopyFile(register __a0 char *fromfile, register __a1 char *tofile,register __d0 ULONG BufSize)
  2066. {
  2067.   BOOL retval=FALSE;
  2068.   BPTR FL,FromFH,ToFH;
  2069.   struct FileInfoBlock FB;
  2070.   BOOL error=TRUE;
  2071.   ULONG nr,nw,total=0;
  2072.   UBYTE *Buffer;
  2073.   ULONG MyBufSize=BufSize;
  2074.  
  2075.   if (MyBufSize==0) MyBufSize=BBSGlobal->CopyBufferSize; // *C* user selectable!
  2076.  
  2077.   if (FL=Lock(fromfile,ACCESS_READ))
  2078.   {
  2079.     if (Examine(FL,&FB))
  2080.     {
  2081.       if (FromFH=OpenFromLock(FL))
  2082.       {
  2083.         if (ToFH=Open(tofile,MODE_NEWFILE))
  2084.         {
  2085.           if (FB.fib_Size>0)
  2086.           {
  2087.             if (MyBufSize>FB.fib_Size) MyBufSize=FB.fib_Size; // no sense allocating to much mem
  2088.             if (Buffer=AllocBuffer(&MyBufSize,MEMF_PUBLIC))
  2089.             {
  2090.               do
  2091.               {
  2092.                 error=FALSE;
  2093.                 if (nr=Read(FromFH,Buffer,MyBufSize-1))
  2094.                 {
  2095.                   if (nr==(nw=Write(ToFH,Buffer,nr)))
  2096.                   {
  2097.                     total+=nw;
  2098.                   } else error=TRUE;
  2099.                 } else error=TRUE;
  2100.               } while (!error);
  2101.               if (error && total>=FB.fib_Size) error=FALSE; //end of file rather than error...
  2102.  
  2103.               FreeVec(Buffer);
  2104.             }
  2105.           }
  2106.           else
  2107.           {
  2108.             error=FALSE;
  2109.           }
  2110.           Close(ToFH);
  2111.           SetComment(tofile,FB.fib_Comment);
  2112.           SetProtection(tofile,FB.fib_Protection);
  2113.         }
  2114.         Close(FromFH);
  2115.         FL=NULL;
  2116.       }
  2117.     }
  2118.     if (FL) UnLock(FL);
  2119.   }
  2120.   if (!error)
  2121.   {
  2122.     retval=TRUE;
  2123. //    if (FL=Lock(tofile,ACCESS_READ)) // is the new file the same as the old one ?
  2124. //    {
  2125. //      total=FB.fib_Size;
  2126. //      if (Examine(FL,&FB) && total==FB.fib_Size) retval=TRUE;
  2127. //      UnLock(FL);
  2128. //    }
  2129.   }
  2130.  
  2131.   if (!retval) // if the old file is different then delete it..
  2132.   {
  2133.     DeleteFile(tofile);
  2134.   }
  2135.   return(retval);
  2136. }
  2137.  
  2138. ULONG __asm __saveds LIBHBBS_NodesInList(register __a0 struct List *list)
  2139. {
  2140.   struct Node *node;
  2141.   ULONG Nodes=0;
  2142.   if (list)
  2143.   {
  2144.     for (node=list->lh_Head;node->ln_Succ;node=node->ln_Succ)
  2145.     {
  2146.       Nodes++;
  2147.     }
  2148.     return(Nodes);
  2149.   }
  2150.   return(0);
  2151. }
  2152.  
  2153. V_BOOL __asm __saveds LIBHBBS_AppendStrToFile(register __a0 UBYTE *FileName, register __a1 UBYTE *String)
  2154. {
  2155.   BPTR FH;
  2156.   V_BOOL retval=FALSE;
  2157.  
  2158.   if (LIBAssignOK(FileName))
  2159.   {
  2160.     if (FH=Open(FileName,MODE_READWRITE))
  2161.     {
  2162.       Seek(FH,0,OFFSET_END);
  2163.       if (Write(FH,String,strlen(String))==strlen(String)) retval=TRUE;
  2164.  
  2165.       Close(FH);
  2166.     }
  2167.   }
  2168.   return(retval);
  2169. }
  2170.  
  2171.  
  2172. /*
  2173.    HBBS_CreateNode() creates a node and returns a pointer to it.
  2174.  
  2175.    if namestr is not NULL then the a new string will be allocated and
  2176.    placed the ln_Name field.
  2177.  
  2178.    if you specify 0 for the nodesize, then the size of the node allocated
  2179.    will be the sizeof(struct Node), otherwise it'll allocate however many bytes
  2180.    you specify.
  2181.  
  2182.    All the data will be zero'd, so all your other fields will be intialized to NULL
  2183.    or 0!
  2184.  
  2185. */
  2186.  
  2187. struct Node __asm __saveds *LIBHBBS_CreateNode(register __a0 char *namestr,register __d0 ULONG nodesize)
  2188. {
  2189.   struct Node *newnode;
  2190.  
  2191.   if (nodesize==0) nodesize=sizeof(struct Node);
  2192.  
  2193.   if (newnode=AllocVec(nodesize,MEMF_CLEAR|MEMF_PUBLIC))
  2194.   {
  2195.     if (namestr)
  2196.     {
  2197.       if (!(newnode->ln_Name=LIBDupStr(namestr)))
  2198.       {
  2199.         FreeVec(newnode);
  2200.         newnode=NULL; // failed!
  2201.       }
  2202.     }
  2203.   }
  2204.   return(newnode);  // NULL if not enough mem, or pointer to node otherwise..
  2205. }
  2206.  
  2207. void __asm __saveds LIBHBBS_FreeNode(register __a0 struct Node *node,register __d0 V_BOOL RemoveIt)
  2208. {
  2209.   if (node)
  2210.   {
  2211.     if (RemoveIt) Remove(node);
  2212.     if (node->ln_Name) LIBFreeStr(node->ln_Name);
  2213.     FreeVec(node);
  2214.   }
  2215. }
  2216.  
  2217. void __asm __saveds LIBHBBS_FreeListNodes(register __a0 struct List *list)
  2218. {
  2219.   // free all ln_Names of each node in a list and remove all nodes from the list!
  2220.   // but we DON't free the list itself, we just leave it empty
  2221.  
  2222.   struct Node *node;
  2223.   if (list)
  2224.   {
  2225.     while (list->lh_Head->ln_Succ)
  2226.     {
  2227.       node=list->lh_Head;
  2228.       LIBFreeStr(node->ln_Name);
  2229.       Remove(node);
  2230.       FreeVec(node);
  2231.     }
  2232.   }
  2233. }
  2234.  
  2235. V_BOOL __asm __saveds LIBHBBS_SendOLM(register __d0 V_SMALLNUM FromNode,register __a0 UBYTE *FromPRG,register __d1 V_SMALLNUM ToNode,register __a1 UBYTE *Message,register __d2 BYTE Pri)
  2236. {
  2237.   // frommnode should be 0 if something other than a door is sending the OLM
  2238.   // otheriwse fromnode should be set to your node number plus 1
  2239.   // e.g. N_ND->NodeNum+1, if fromnode
  2240.  
  2241.  
  2242.   V_BOOL retval=FALSE;
  2243.   struct OLMNode *NewOLM;
  2244.   struct NodeData *nd=NULL;
  2245.   struct NodeData *fnd;
  2246.   struct Message *NewMsg=NULL;
  2247.  
  2248.   // lets see if we can send an eall, node must be open and initalised with
  2249.   // a user loggined in and the status must be online
  2250.   if ((Message) &&
  2251.       (FromNode>=0 ) && (FromNode<=BBSGlobal->BBSNodes) &&
  2252.       (nd=LIBHBBS_NodeDataPtr(ToNode)) &&
  2253.       (nd->Status==STAT_ONLINE) &&
  2254.       (nd->OLMList) &&
  2255.       (nd->LoginType!=LOGIN_NONE) &&
  2256.       (nd->OnlineStatus==OS_ONLINE))
  2257.   {
  2258.     if (NewOLM=(struct OLMNode *)LIBHBBS_CreateNode(Message,sizeof(struct OLMNode)))
  2259.     {
  2260.       if (NewOLM->node.ln_Name=LIBDupStr(Message))
  2261.       {
  2262.         NewOLM->node.ln_Pri=Pri;
  2263.         LIBHBBS_GetTime(NewOLM->Time);
  2264.         LIBHBBS_GetDate(NewOLM->Date);
  2265.         NewOLM->FromNode=FromNode;
  2266.         if ((FromNode) && (fnd=LIBHBBS_NodeDataPtr(FromNode-1)))
  2267.         {
  2268.           if (fnd->User.Valid) // NewOLD has already been blanked by CreateNode() so the string is already null terminated..
  2269.           {
  2270.             LIBstrNcpy(NewOLM->Handle,fnd->User.CallData.Handle,LEN_HANDLE);
  2271.           }
  2272.         }
  2273.         if (FromPRG)
  2274.         {
  2275.           LIBstrNcpy(NewOLM->FromPRG,FromPRG,LEN_HANDLE);
  2276.         }
  2277.  
  2278.         // *C* add semaphore checking!
  2279.         Enqueue(nd->OLMList,(struct Node*)NewOLM);
  2280.         nd->OLMCount++;
  2281.         if (!(nd->NodeFlags & NFLG_OLMSWAITING)) nd->NodeFlags+=NFLG_OLMSWAITING;
  2282.  
  2283.         if (nd->OLMPort)
  2284.         {
  2285.           if (NewMsg=AllocVec(sizeof (struct Message),MEMF_PUBLIC|MEMF_CLEAR))
  2286.           {
  2287.             NewMsg->mn_Node.ln_Type = NT_MESSAGE;
  2288.             NewMsg->mn_ReplyPort=NULL;
  2289.             NewMsg->mn_Length=sizeof(struct Message);
  2290.  
  2291.             PutMsg(nd->OLMPort,NewMsg);
  2292.           }
  2293.         }
  2294.         retval=TRUE;
  2295.       }
  2296.     }
  2297.   }
  2298.   return(retval);
  2299. }
  2300.  
  2301. BOOL __asm __saveds LIBFGetsR(register __a0 BPTR FH,register __a1 UBYTE *Buffer,register __d0 LONG BufferLen)
  2302. {
  2303.  
  2304.   // fucking amazing routine to read a file line by line but BACKWARDS from the current
  2305.   // position!! Whay!!
  2306.  
  2307.   LONG nr,startpos,where,back,foundpos=0;
  2308.   BOOL retval=TRUE,sof=FALSE,error=FALSE;
  2309.  
  2310.   UBYTE *strptr=NULL;
  2311.  
  2312.  
  2313.   Buffer[0]=0;
  2314.   BufferLen--;
  2315.  
  2316.   where=Seek(FH,0,OFFSET_CURRENT);  // start of file already ?
  2317.   if (where<=0) //start of file or error
  2318.   {
  2319.     retval=FALSE;
  2320.   }
  2321.   else
  2322.   {
  2323.     startpos=where; // make a note of where we started from.
  2324.     do
  2325.     {
  2326.       back=255;
  2327.       if (where<255) back=where;
  2328.  
  2329.       if (back>BufferLen) back=BufferLen;
  2330.  
  2331.       if ((where=Seek(FH,0-back,OFFSET_CURRENT))!=-1)
  2332.       {
  2333.         where-=back;
  2334.  
  2335.         if (nr=Read(FH,Buffer,back))
  2336.         {
  2337.           Buffer[nr]=0;
  2338.           if (strptr=strrchr(Buffer,'\n'))
  2339.           {
  2340.             foundpos=where+(strptr-Buffer);
  2341.             if (Seek(FH,foundpos+1,OFFSET_BEGINNING)==-1)
  2342.             {
  2343.               error=TRUE;
  2344.             }
  2345.           }
  2346.           else
  2347.           {
  2348.             if (where==0)
  2349.             {
  2350.               if (Seek(FH,0,OFFSET_BEGINNING)==-1)
  2351.               {
  2352.                 error=TRUE;
  2353.               }
  2354.               else
  2355.               {
  2356.                 sof=TRUE;
  2357.                 foundpos=1;
  2358.               }
  2359.             }
  2360.             else
  2361.             {
  2362.  
  2363.               if (Seek(FH,0-nr,OFFSET_CURRENT)!=-1)
  2364.               {
  2365.                 where-=nr;
  2366.               }
  2367.               else
  2368.               {
  2369.                 error=TRUE;
  2370.               }
  2371.             }
  2372.  
  2373.           }
  2374.         }
  2375.         else
  2376.         {
  2377.           error=TRUE;
  2378.         }
  2379.  
  2380.       }
  2381.     } while (strptr==NULL && !error && !sof);
  2382.  
  2383.     Buffer[0]=0;
  2384.     if (strptr || sof )
  2385.     {
  2386.       FGets(FH,Buffer,BufferLen);
  2387.       Seek(FH,foundpos ? foundpos-1 : 0,OFFSET_BEGINNING);
  2388.     }
  2389.   }
  2390.  
  2391.   return(retval);
  2392.  
  2393. }
  2394.