home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Misc / JOE_SOUR.LHA / Sources.lha / s!x / confed / confed.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-07-21  |  27.7 KB  |  1,080 lines
  1. /************************************************/
  2.                                              /***/
  3. #define REVISION "1.2"                         /***/
  4. #define REVDATE  "21.Jul.1996"                     /***/
  5. #define PROGNAME "Conference Editor"         /***/
  6. #define AUTHOR   "Joe Cool"                     /***/
  7.                                              /***/
  8. /************************************************/
  9.  
  10. #include <exec/types.h>
  11. #include <exec/ports.h>
  12. #include <exec/memory.h>
  13. #include <dos/dos.h>
  14. #include <clib/exec_protos.h>
  15. #include <clib/dos_protos.h>
  16. #include <clib/alib_protos.h>
  17. #include <stdio.h>
  18. #include <stdlib.h>
  19. #include <string.h>
  20. #include <ctype.h>
  21. #include "aedoor.h"
  22. static const char VersionTag[] = "\0$VER: "PROGNAME" "REVISION" ("REVDATE")";
  23. #define ws WriteStr
  24.  
  25.  
  26. #define CLEAR            0
  27. #define PROCESSING        1
  28. #define FAILED            2
  29. #define PASSED            3
  30. #define NOTPROCESSED    4
  31. #define CONFDAT    "bbs:Conferences.dat"
  32.  
  33.  
  34. void Start(int node);
  35. void lowerstring(char *s);
  36. void upperstring(char *s);
  37. void createpath(char *s);
  38. void editpaths(char *filename,char **paths);
  39. void editarea(void);
  40. BOOL getconfigbool(char **main_search,char *lookfor,BOOL std);
  41. char *getconfig(char **main_search,char *lookfor);
  42.  
  43. struct ConfCfg
  44. {
  45.  int  ConfNum;
  46.  char ConfName[100];
  47.  char ConfLoc[255];
  48.  char MsgLoc[255];
  49.  char Password[30];
  50.  BOOL SentBy;
  51.  BOOL MsgShared;
  52. };
  53.  
  54.  
  55.  
  56.  
  57.  
  58. void main(int argc, char *argv[])
  59. {
  60.  
  61.     int    Node=0;
  62. if(argc<2)
  63. {
  64.     printf("Sorry, %s must be called from S!X or /X\n",argv[0]);
  65.     exit(0);
  66. }
  67. Node=atoi(argv[1]);
  68. Register(Node);
  69.  
  70. XIM_Msg->Command=140;                    
  71. CheckMessage();
  72. SetTaskPri(FindTask(0),atol(XIM_Msg->String));
  73.  
  74. Start(Node);
  75. ShutDown();
  76.  
  77. }
  78.  
  79.  
  80.  
  81. void Start(Node)
  82. {
  83.     struct    ConfCfg        *conf;
  84.     char                buffer[255],selectstr[10]="",selectstr2[10]="",delselectstr[10]="",
  85.                         **paths=NULL,ch='\0',**main_config=NULL;
  86.     ULONG                pos=0,max=0,select=0,select2=0,delselect=0,ndirs=0,len=0;
  87.     BPTR                fh=NULL,writefh=NULL,lock=NULL;
  88.     BOOL                quit=FALSE,extra=FALSE,donotread=FALSE,success=FALSE,freedown=FALSE,
  89.                         twocol;
  90.  
  91.     SendStrDataCmd(177,"Conference Edit",0);
  92.     conf=(struct ConfCfg *) malloc (sizeof(struct ConfCfg));
  93.  
  94.  
  95.     lock = GetProgramDir();
  96.     NameFromLock(lock, buffer, 220);
  97.     if (buffer[strlen(buffer)-1]==':')    strcat(buffer,"confed.config");
  98.     else                                strcat(buffer,"/confed.config");
  99.  
  100.     fh=Open(buffer,MODE_OLDFILE);
  101.     if (fh)
  102.     {
  103.         for (pos=0;FGets(fh,buffer,254);pos++)
  104.         {
  105.             main_config=(char **) realloc(main_config,(pos+1)*sizeof(char *));
  106.             main_config[pos]=NULL;
  107.             len=strlen(buffer);
  108.             if (buffer[len-1]=='\n') buffer[len-1]='\0';
  109.             upperstring(buffer);
  110.             main_config[pos]=(char *) malloc (len+1);
  111.             if (main_config[pos]!=NULL)
  112.                 strcpy(main_config[pos],buffer);
  113.         }
  114.         Close(fh);
  115.         main_config=(char **) realloc(main_config,(pos+1)*sizeof(char *));
  116.         main_config[pos]=NULL;
  117.     }
  118.  
  119.     twocol    =getconfigbool(main_config,"TWO_COLOUMNS",   FALSE);
  120.  
  121.     do
  122.     {
  123.  
  124.         ws("c",1);
  125.         ws("ConfEd V1.2 ©1996 by Joe Cool",1);
  126.         ws("",1);    
  127.  
  128.         fh=Open(CONFDAT,MODE_OLDFILE);
  129.         if (!fh) fh=Open(buffer,MODE_NEWFILE);
  130.         pos=0;
  131.         while (Read(fh,conf,sizeof(struct ConfCfg)))
  132.         {
  133.             pos++;
  134.             if (conf->ConfName[0]!=0)
  135.                 sprintf(buffer," [%2d] %-30.30s",pos,conf->ConfName);
  136.             else
  137.                 sprintf(buffer," [%2d] %-30.30s",pos,"<not defined!>");
  138.             if (twocol)
  139.             {
  140.                 if ( (pos+1)/2 != pos/2)
  141.                 {
  142.                     ws(buffer,0);
  143.                 }
  144.                 else
  145.                 {
  146.                     ws(buffer,1);
  147.                 }
  148.             }
  149.             else
  150.             {
  151.                 ws(buffer,1);
  152.             }
  153.         }
  154.         if ( (pos+1)/2 != pos/2) ws("",1);
  155.  
  156.         ws("",1);
  157.         ws(" [ A] AreaNames",1);
  158.         ws(" [ N] New Conference",1);
  159.         ws(" [ D] Del Conference",1);
  160.         if (fh) Close(fh);
  161.         max=pos;    
  162.  
  163.         sprintf(buffer,"%d",max);
  164.         ws("",1);
  165.         SendStrDataCmd(JH_PM,"Conference: ",strlen(buffer));
  166.         if (XIM_Msg->Data==-1) return;
  167.         strcpy(selectstr,XIM_Msg->String);
  168.         lowerstring(selectstr);
  169.         select=atoi(selectstr);
  170.         donotread=FALSE;
  171.  
  172.  
  173.         if (select==0)
  174.         {
  175.             switch (selectstr[0])
  176.             {
  177.                 case 'n'        :
  178.                                     {
  179.                                         if  (max<25)
  180.                                         {
  181.                                             select=max+1;
  182.                                             donotread=TRUE;
  183.                                             strcpy(conf->ConfName,"");
  184.                                             strcpy(conf->ConfLoc,"");
  185.                                             strcpy(conf->MsgLoc,"");
  186.                                             strcpy(conf->Password,"");
  187.                                             conf->SentBy=FALSE;
  188.                                             conf->MsgShared=FALSE;
  189.                                             extra=TRUE;
  190.                                         }
  191.                                         else
  192.                                         {
  193.                                             select=max+1;
  194.                                             Hotkey("Not more than 25 Confs Possible!");
  195.                                         }
  196.                                     }
  197.                                     break;
  198.                 case 'd'        :    
  199.                                     {
  200.                                         SendStrDataCmd(JH_PM,"Deleting Conference: ",strlen(buffer));
  201.                                         if (XIM_Msg->Data==-1) return;
  202.                                         delselect=atoi(XIM_Msg->String);
  203.                                         if (delselect<=max && delselect>0)
  204.                                         {
  205.                                             SendStrDataCmd(JH_PM,"Are U sure (y/N): ",3);    
  206.                                             strcpy(delselectstr,XIM_Msg->String);
  207.                                             lowerstring(delselectstr);
  208.                                             if (delselectstr[0]=='y')
  209.                                             {
  210.                                                 fh=Open(CONFDAT,MODE_OLDFILE);
  211.                                                 writefh=Open(CONFDAT".temp",MODE_NEWFILE);
  212.                                                 if (fh && writefh)
  213.                                                 {
  214.                                                     ws("Deleting Conference!!!",1);
  215.                                                         success=FALSE;
  216.                                                     for (pos=0;pos<max;pos++)
  217.                                                     {
  218.                                                         Read(fh,conf,sizeof(struct ConfCfg));
  219.                                                         if (pos!=delselect-1) Write(writefh,conf,sizeof(struct ConfCfg));
  220.                                                         success=TRUE;
  221.                                                     }
  222.                                                 }
  223.                                                 if (fh) Close(fh);
  224.                                                 if (writefh) Close(writefh);
  225.                                                 if (success)
  226.                                                 {
  227.                                                     DeleteFile(CONFDAT);
  228.                                                     Rename(CONFDAT".temp",CONFDAT);
  229.                                                 }
  230.                                             }
  231.                                         }            
  232.                                         select=max+1;
  233.                                             
  234.                                     }
  235.                                     break;
  236.                 case 'a'        :    {
  237.                                         editarea();
  238.                                         
  239.                                         select=max+1;
  240.                                     }
  241.             }
  242.         }
  243.  
  244.  
  245.         if ((select>0) && (select<=max) || extra)
  246.         {    
  247.             extra=FALSE;
  248.             ndirs=0;
  249.             freedown=FALSE;
  250.  
  251.  
  252.  
  253.  
  254.  
  255.                 if (!donotread)
  256.                 {           
  257.                     fh=Open(CONFDAT,MODE_OLDFILE);
  258.                     if (fh)
  259.                     {
  260.                         Seek(fh,(select-1)*sizeof(struct ConfCfg) , OFFSET_BEGINNING );
  261.                         Read(fh,conf,sizeof(struct ConfCfg));
  262.                         Close(fh);
  263.                         sprintf(buffer,"%sNdirs",conf->ConfLoc);
  264.                         fh=Open(buffer,MODE_OLDFILE);
  265.                         if (fh)
  266.                         {
  267.                             FGets(fh,buffer,20);
  268.                             Close(fh);
  269.                             ndirs=atoi(buffer);
  270.                         }
  271.                         sprintf(buffer,"%sFreedownloads",conf->ConfLoc);
  272.                         fh=Open(buffer,MODE_OLDFILE);
  273.                         if (fh)
  274.                         {
  275.                             Close(fh);
  276.                             freedown=TRUE;
  277.                         }
  278.                         
  279.                     }
  280.                 }
  281.                 quit=FALSE;
  282.                 do
  283.                 {
  284.                     ws("c",1);
  285.                     sprintf(buffer,"Conference Number: %d",select);
  286.                     ws(buffer,1); 
  287.                     ws("",1);
  288.                     if (conf->ConfName[0]!=0)
  289.                         sprintf(buffer," [ 1] Conf Name   : %s",conf->ConfName);
  290.                     else
  291.                         sprintf(buffer," [ 1] Conf Name   : <Please Edit>");
  292.                     ws(buffer,1);
  293.  
  294.                     if (conf->ConfLoc[0]!=0)
  295.                         sprintf(buffer," [ 2] Conf Locatio: %s",conf->ConfLoc);
  296.                     else
  297.                         sprintf(buffer," [ 2] Conf Locatio: <Please Edit>");
  298.                     ws(buffer,1);
  299.  
  300.                     if (conf->MsgLoc[0]!=0)
  301.                         sprintf(buffer," [ 3] Conf MsgLoca: %s",conf->MsgLoc);
  302.                     else
  303.                         sprintf(buffer," [ 3] Conf MsgLoca: <Default>");
  304.  
  305.                     ws(buffer,1);
  306.                     if (conf->Password[0]!=0)
  307.                         sprintf(buffer," [ 4] Conf Passwor: %s",conf->Password);
  308.                     else
  309.                         sprintf(buffer," [ 4] Conf Passwor: <None>");
  310.                     ws(buffer,1);    
  311.                         if (conf->SentBy)    ws(" [ 5] Conf Sentby : Yes",1); else    ws(" [ 5] Conf Sentby : No",1);
  312.                     if (conf->MsgShared) ws(" [ 6] Shared Msgb : Yes",1); else    ws(" [ 6] Shared Msgb : No",1);
  313.  
  314.                     ws("",1);
  315.                     sprintf(buffer," [ 7] NDirs       : %d",ndirs);
  316.                     ws(buffer,1);
  317.                     ws(" [ 8] Ulpaths",1);
  318.                     ws(" [ 9] Paths",1);
  319.  
  320.                     if (freedown) ws(" [10] Free Down   : Yes",1); else    ws(" [10] Free Down   : No",1);
  321.  
  322.  
  323.                     ws("",1);
  324.                     ws(" [ C] Create Paths&Files",1);
  325.                     ws(" [ S] Save & Quit",1);
  326.                     ws(" [ Q] Quit without saving",1);
  327.                     ws("",1);
  328.                     SendStrDataCmd(JH_PM,"Select: ",strlen(buffer));
  329.                     if (XIM_Msg->Data==-1) return;
  330.                     strcpy(selectstr2,XIM_Msg->String);
  331.                     lowerstring(selectstr2);
  332.                     select2=atoi(selectstr2);
  333.                     switch (select2)
  334.                     {
  335.                         case 0        :    
  336.                                         {
  337.                                             switch (selectstr2[0])
  338.                                             {
  339.                                                 case 'q' :  {
  340.                                                                 quit=TRUE;
  341.                                                             }
  342.                                                             break;
  343.                                                 case 's' :  {
  344.                                                                 fh=Open(CONFDAT,MODE_READWRITE);
  345.                                                                 if (fh)
  346.                                                                 {
  347.                                                                 
  348.                                                                     Seek(fh,(select-1)*sizeof(struct ConfCfg) , OFFSET_BEGINNING );
  349.                                                                     Write(fh,conf,sizeof(struct ConfCfg));
  350.                                                                     Close(fh);
  351.                                                                 }
  352.  
  353.  
  354.  
  355.                                                                 quit=TRUE;
  356.                                                             }
  357.                                                             break;
  358.                                                 case 'c' :  {
  359.                                                                 ws ("Create all Paths (y/N) ?",0);
  360.                                                                 ch=Hotkey("");
  361.                                                                 ch=tolower(ch);
  362.                                                                 sprintf(buffer,"%c",ch);
  363.                                                                 ws(buffer,1);
  364.                                                                 if (conf->ConfLoc[0]==0)
  365.                                                                     ws("Please edit the Conference Location!",1);
  366.                                                                 else
  367.                                                                 if (ch=='y') 
  368.                                                                 {
  369.                                                                     sprintf(buffer,"%s",conf->ConfLoc);
  370.                                                                     if (buffer[strlen(buffer)-1]=='/') buffer[strlen(buffer)-1]=0;
  371.                                                                     createpath(buffer);
  372.  
  373.                                                                     sprintf(buffer,"%sHold",conf->ConfLoc);
  374.                                                                     createpath(buffer);
  375.  
  376.                                                                     sprintf(buffer,"%sLCFiles",conf->ConfLoc);
  377.                                                                     createpath(buffer);
  378.  
  379.                                                                     if (conf->MsgLoc[0]==0)
  380.                                                                     {
  381.                                                                         sprintf(buffer,"%sMsgBase",conf->ConfLoc);
  382.                                                                         createpath(buffer);
  383.                                                                     }
  384.                                                                     else
  385.                                                                     {
  386.                                                                         sprintf(buffer,"%s",conf->MsgLoc);
  387.                                                                         createpath(buffer);
  388.                                                                     }
  389.  
  390.                                                                     sprintf(buffer,"%sPartUpload",conf->ConfLoc);
  391.                                                                     createpath(buffer);
  392.  
  393.                                                                     for (pos=1;pos<=ndirs;pos++)
  394.                                                                     {
  395.                                                                         sprintf(buffer,"%sdir%d",conf->ConfLoc,pos);
  396.                                                                         fh=Open(buffer,MODE_OLDFILE);
  397.                                                                         if (fh)
  398.                                                                         {
  399.                                                                             Close(fh);
  400.                                                                             ws("Exists  : ",0);
  401.                                                                             ws(buffer,1);
  402.                                                                         }
  403.                                                                         else
  404.                                                                         {
  405.                                                                             fh=Open(buffer,MODE_NEWFILE);
  406.                                                                             Close(fh);
  407.                                                                             ws("Creating: ",0);
  408.                                                                             ws(buffer,1);
  409.                                                                         }
  410.                                                                     }
  411.                                                                     Hotkey("<Press any key!>");
  412.                                                                 }
  413.                                                             }
  414.                                                             break;
  415.                                             }
  416.                                         }
  417.                                         break;
  418.                                         
  419.                                 
  420.                         case 1        :    {
  421.                                             ws("Conf Name: ",0);
  422.                                             GetStr(99,conf->ConfName);
  423.                                             strcpy(conf->ConfName,XIM_Msg->String);
  424.                                         }
  425.                                         break;
  426.                         case 2        :    {
  427.                                             ws("Conf Location: ",0);
  428.                                             GetStr(254,conf->ConfLoc);
  429.                                             strcpy(conf->ConfLoc,XIM_Msg->String);
  430.                                         }
  431.                                         break;
  432.                         case 3        :    {
  433.                                             ws("Conf MsgLocation: ",0);
  434.                                             GetStr(254,conf->MsgLoc);
  435.                                             strcpy(conf->MsgLoc,XIM_Msg->String);
  436.                                         }
  437.                                         break;
  438.                         case 4        :    {
  439.                                             ws("Conf Password: ",0);
  440.                                             GetStr(29,conf->Password);
  441.                                             strcpy(conf->Password,XIM_Msg->String);
  442.                                         }
  443.                                         break;
  444.                         case 5        :    {
  445.                                             if (conf->SentBy) conf->SentBy=FALSE; else conf->SentBy=TRUE;
  446.                                         }
  447.                                         break;
  448.                         case 6        :    {
  449.                                             if (conf->MsgShared) conf->MsgShared=FALSE; else conf->MsgShared=TRUE;
  450.                                         }
  451.                                         break;
  452.                         case 7        :    {
  453.                                             if (conf->ConfLoc[0]==0)
  454.                                             {
  455.                                                 ws("Please edit the Conference Location!",1);
  456.                                                 Hotkey("<Press any key!>");
  457.                                             }
  458.                                             else
  459.                                             {
  460.                                                 sprintf(buffer,"%s",conf->ConfLoc);
  461.                                                 fh=Lock(buffer,ACCESS_READ);
  462.                                                 if (fh)
  463.                                                 {
  464.                                                     UnLock(fh);                
  465.                                                     sprintf(buffer,"%sNdirs",conf->ConfLoc);
  466.                                                     fh=Open(buffer,MODE_NEWFILE);
  467.                                                     if (fh)
  468.                                                     {
  469.                                                         sprintf(buffer,"%d",ndirs);
  470.                                                         ws("NDirs: ",0);
  471.                                                         GetStr(2,buffer);
  472.                                                         ndirs=atoi(XIM_Msg->String);
  473.                                                         sprintf(buffer,"%d\n",ndirs);
  474.                                                         FPuts(fh,buffer);
  475.                                                         Close(fh);
  476.                                                     }    
  477.                                                 }
  478.                                                 else
  479.                                                 {
  480.                                                     ws("Please create Paths first!",1);
  481.                                                     Hotkey("<Press any key!>");
  482.                                                 }
  483.                                             }
  484.                                         }
  485.                                         break;
  486.                         case 8        :    {
  487.                                             if (conf->ConfLoc[0]==0)
  488.                                             {
  489.                                                 ws("Please edit the Conference Location!",1);
  490.                                                 Hotkey("<Press any key!>");
  491.                                             }
  492.                                             else
  493.                                             {
  494.                                                 sprintf(buffer,"%s",conf->ConfLoc);
  495.                                                 fh=Lock(buffer,ACCESS_READ);
  496.                                                 if (fh)
  497.                                                 {
  498.                                                     UnLock(fh);                
  499.                                                     if (conf->ConfLoc[0]!=0)
  500.                                                     {
  501.                                                         paths=(char **) realloc(paths,sizeof(char *));
  502.                                                         paths[0]=NULL;
  503.                                                         sprintf(buffer,"%sUlpaths",conf->ConfLoc);
  504.                                                         fh=Open(buffer,MODE_OLDFILE);
  505.                                                         if (fh)
  506.                                                         {
  507.                                                 
  508.                                                             for (pos=0;FGets(fh,buffer,255);pos++)
  509.                                                             {
  510.                                                                 paths=(char **) realloc(paths,(pos+1)*sizeof(char *));
  511.                                                                 paths[pos]=NULL;
  512.                                                                 if(buffer[strlen(buffer)-1]=='\n') buffer[strlen(buffer)-1]='\0';
  513.                                                                 len=strlen(buffer);
  514.                                                                 paths[pos]=(char *) malloc (len+1);
  515.                                                                 if (paths[pos]!=NULL)
  516.                                                                 strcpy(paths[pos],buffer);
  517.                                                             }
  518.                                                             Close(fh);
  519.                                                             paths=(char **) realloc(paths,(pos+1)*sizeof(char *));
  520.                                                             paths[pos]=NULL;
  521.                                                         }                                                        
  522.                                                         sprintf(buffer,"%sUlPaths",conf->ConfLoc);
  523.                                                         editpaths(buffer,paths);
  524.                                                         for (pos=0;paths[pos]!=NULL;pos++)
  525.                                                         free(paths[pos]);
  526.                                                         free (paths);
  527.                                                         paths=NULL;
  528.                                                     }
  529.                                                 }
  530.                                                 else
  531.                                                 {
  532.                                                     ws("Please create Paths first!",1);
  533.                                                     Hotkey("<Press any key!>");
  534.                                                 }
  535.                                             }
  536.                                         }
  537.                                         break;
  538.                         case 9        :    {
  539.                                             if (conf->ConfLoc[0]==0)
  540.                                             {
  541.                                                 ws("Please edit the Conference Location!",1);
  542.                                                 Hotkey("<Press any key!>");
  543.                                             }
  544.                                             else
  545.                                             {
  546.                                                 sprintf(buffer,"%s",conf->ConfLoc);
  547.                                                 fh=Lock(buffer,ACCESS_READ);
  548.                                                 if (fh)
  549.                                                 {
  550.                                                     UnLock(fh);                
  551.                                                     if (conf->ConfLoc[0]!=0)
  552.                                                     {
  553.                                                         paths=(char **) realloc(paths,sizeof(char *));
  554.                                                         paths[0]=NULL;
  555.                                                         sprintf(buffer,"%sPaths",conf->ConfLoc);
  556.                                                         fh=Open(buffer,MODE_OLDFILE);
  557.                                                         if (fh)
  558.                                                         {
  559.                                                 
  560.                                                             for (pos=0;FGets(fh,buffer,255);pos++)
  561.                                                             {
  562.                                                                 paths=(char **) realloc(paths,(pos+1)*sizeof(char *));
  563.                                                                 paths[pos]=NULL;
  564.                                                                 if(buffer[strlen(buffer)-1]=='\n') buffer[strlen(buffer)-1]='\0';
  565.                                                                 len=strlen(buffer);
  566.                                                                 paths[pos]=(char *) malloc (len+1);
  567.                                                                 if (paths[pos]!=NULL)
  568.                                                                 strcpy(paths[pos],buffer);
  569.                                                             }
  570.                                                             Close(fh);
  571.                                                             paths=(char **) realloc(paths,(pos+1)*sizeof(char *));
  572.                                                             paths[pos]=NULL;
  573.                                                         }
  574.  
  575.                                                         sprintf(buffer,"%sPaths",conf->ConfLoc);
  576.                                                         editpaths(buffer,paths);
  577.                                                         for (pos=0;paths[pos]!=NULL;pos++)
  578.                                                         free(paths[pos]);
  579.                                                         free (paths);
  580.                                                         paths=NULL;
  581.                                                     }
  582.                                                 }
  583.                                                 else
  584.                                                 {
  585.                                                     ws("Please create Paths first!",1);
  586.                                                     Hotkey("<Press any key!>");
  587.                                                 }
  588.                                             }
  589.                                         }
  590.                                         break;
  591.                         case 10        :    {
  592.                                             if (conf->ConfLoc[0]==0)
  593.                                             {
  594.                                                 ws("Please edit the Conference Location!",1);
  595.                                                 Hotkey("<Press any key!>");
  596.                                             }
  597.                                             else
  598.                                             {
  599.                                                 sprintf(buffer,"%s",conf->ConfLoc);
  600.                                                 fh=Lock(buffer,ACCESS_READ);
  601.                                                 if (fh)
  602.                                                 {
  603.                                                     UnLock(fh);                
  604.                                                     if (freedown) freedown=FALSE; else freedown=TRUE;
  605.                                                     if (freedown)
  606.                                                     {
  607.                                                         sprintf(buffer,"%sFreedownloads",conf->ConfLoc);
  608.                                                         fh=Open(buffer,MODE_NEWFILE);
  609.                                                         if (fh)    Close(fh);
  610.                                                     }    
  611.                                                     else
  612.                                                     {
  613.                                                         sprintf(buffer,"%sFreedownloads",conf->ConfLoc);
  614.                                                         DeleteFile(buffer);
  615.                                                     }
  616.                                                 }
  617.                                                 else
  618.                                                 {
  619.                                                     ws("Please create Paths first!",1);
  620.                                                     Hotkey("<Press any key!>");
  621.                                                 }
  622.                                             }
  623.                                         }
  624.                                         break;                                                
  625.  
  626.  
  627.                     }
  628.  
  629.                 } while (!quit);
  630.             
  631.         }
  632.     } while (select!=0);
  633.  
  634.     free(conf);
  635. }
  636.  
  637. void lowerstring(char *s)
  638. {
  639.     while((*s=tolower(*s)) != '\0') s++;
  640. }
  641. void upperstring(char *s)
  642. {
  643.     while((*s=toupper(*s)) != '\0') s++;
  644. }
  645. void createpath(char *s)
  646. {
  647.     BPTR    fh=NULL;
  648.  
  649.     fh=Lock(s,ACCESS_READ);
  650.     if (fh)
  651.     {
  652.         ws("Exists  : ",0);
  653.         UnLock(fh);
  654.     }
  655.     else
  656.     {
  657.         ws("Creating: ",0);
  658.         fh=CreateDir(s);
  659.         UnLock(fh);
  660.     }    
  661.     ws (s,1);
  662. }
  663.  
  664. void editpaths(char *filename,char **paths)
  665. {
  666.     ULONG    pos=0,pos2=0,select=0,select2=0,select3=0,max=0;
  667.     char    buffer[255],selectstr[3]="",**paths2=NULL,*p=NULL;
  668.     BOOL    quit=FALSE;
  669.     BPTR    fh=NULL;
  670.  
  671.     do 
  672.     {
  673.         sprintf(buffer,"cEditing: %s",filename);
  674.         ws(buffer,1);
  675.         ws("",1);    
  676.  
  677.         for (pos=1;paths[pos-1]!=NULL;pos++)
  678.         {
  679.             sprintf(buffer," [%2d] %s",pos,paths[pos-1]);
  680.             ws(buffer,1);
  681.         }
  682.         max=pos;
  683.     
  684.         ws("",1);
  685.         ws(" [ A] Add path",1);
  686.         ws(" [ C] Change paths",1);
  687.         ws(" [ D] Delete path",1);
  688.         ws(" [ #] Edit path",1);
  689.         ws(" [ S] Save paths and quit",1);
  690.         ws(" [ Q] Quit without save",1);
  691.         ws("",1);
  692.         SendStrDataCmd(JH_PM,"Choose: ",2);
  693.         if (XIM_Msg->Data==-1) return;
  694.         strcpy(selectstr,XIM_Msg->String);
  695.         lowerstring(selectstr);
  696.         select=atoi(selectstr);
  697.         switch (select)
  698.         {
  699.             case     0        :    {
  700.                                     
  701.  
  702.                                     switch (selectstr[0])
  703.                                     {
  704.                                         case 'a'    :    {
  705.                                                             strcpy(buffer,"");
  706.                                                             ws("Path: ",0);
  707.                                                             GetStr(200,buffer);
  708.                                                             strcpy(buffer,XIM_Msg->String);
  709.                                                             if (strlen(buffer)!=0)
  710.                                                             {    
  711.                                                                 paths=(char **) realloc(paths,(max+3)*sizeof(char *));
  712.                                                                 paths[max-1]=NULL;
  713.                                                                 paths[max-1]=(char *) realloc(paths[max-1],(strlen(buffer)+1)*sizeof(char));
  714.                                                                 strcpy(paths[max-1],buffer);
  715.                                                                 paths[max]=NULL;
  716.                                                                 max++;
  717.                                                             }
  718.                                                             select=max+1;
  719.                                                         }
  720.                                                         break;
  721.                                         case 'c'    :    {    
  722.                                                             select2=select3=0;
  723.                                                             ws("Change: ",0);
  724.                                                             strcpy(buffer,"");
  725.                                                             GetStr(3,buffer);
  726.                                                             select2=atoi(XIM_Msg->String);
  727.                                                             strcpy(buffer,"");
  728.                                                             ws("With  : ",0);
  729.                                                             GetStr(3,buffer);
  730.                                                             select3=atoi(XIM_Msg->String);
  731.                                                             if(select2>0 && select3>0 && select2<max && select3<max && select2!=select3)
  732.                                                             {
  733.                                                                 p=paths[select2-1];
  734.                                                                 paths[select2-1]=paths[select3-1];
  735.                                                                 paths[select3-1]=p;
  736.                                                                 p=NULL;
  737.                                                             }
  738.                                                             select=max+1;
  739.                                                         }
  740.                                                         break;
  741.                                         case 'd'    :    {
  742.                                                             SendStrDataCmd(JH_PM,"Delete which path: ",2);
  743.                                                             if (XIM_Msg->Data==-1) return;
  744.                                                             select2=atoi(XIM_Msg->String);
  745.                                                             if ((select2>0) && (select2<max))
  746.                                                             {    
  747.             
  748.                                                                 SendStrDataCmd(JH_PM,"Are U sure (y/N): ",3);    
  749.                                                                 lowerstring(XIM_Msg->String);
  750.                                                                 if (XIM_Msg->String[0]=='y')
  751.                                                                 {
  752.  
  753.                                             
  754.                                                                     paths2=(char **) realloc(paths2,max*sizeof(char *));
  755.                                                                     if (paths2)
  756.                                                                     {
  757.                                                                         for (pos=0;paths[pos]!=NULL;pos++)
  758.                                                                         {
  759.                                                                             if (pos!=(select2-1))
  760.                                                                             {
  761.                                                                                 paths2[pos2++]=paths[pos];
  762.                                                                             }
  763.                                                                         }
  764.                                                                         paths2[pos2]=NULL;
  765.                                                                         pos2=0;
  766.                                                                         free(paths);
  767.                                                                         paths=paths2;
  768.                                                                         paths2=NULL;
  769.                                                                         max--;
  770.                                                                     }
  771.                                                                 }
  772.                                                             }
  773.                                     
  774.                                                             select=max+1;
  775.                                                         }    
  776.                                                         break;
  777.                                         case 's'    :    {
  778.                                                             fh=Open(filename,MODE_NEWFILE);
  779.                                                             if (fh)
  780.                                                             {
  781.                                                                 for (pos=0;paths[pos]!=NULL;pos++)
  782.                                                                 {
  783.                                                                     sprintf(buffer,"%s\n",paths[pos]);
  784.                                                                     FPuts(fh,buffer);
  785.                                                                 }
  786.                                                                 Close(fh);
  787.                                                             }
  788.                                                             select=max+1;
  789.                                                             quit=TRUE;
  790.                                                         }
  791.                                                         break;
  792.                                         case 'q'    :    {
  793.                                                             quit=TRUE;
  794.                                                         }
  795.                                                         break;
  796.                                         
  797.                                     }
  798.                                 }
  799.                                 break;
  800.             default            :    {
  801.                                     if ((select>0) && (select<max))
  802.                                     {
  803.                                         strcpy(buffer,paths[select-1]);
  804.                                         ws("Path: ",0);
  805.                                         GetStr(200,buffer);
  806.                                         strcpy(buffer,XIM_Msg->String);
  807.                                         if (strlen(buffer)==0)
  808.                                         {    
  809.                                             paths2=(char **) realloc(paths2,max*sizeof(char *));
  810.                                             if (paths2)
  811.                                             {
  812.                                                 for (pos=0;paths[pos]!=NULL;pos++)
  813.                                                 {
  814.                                                     if (pos!=(select-1))
  815.                                                     {
  816.                                                         paths2[pos2++]=paths[pos];
  817.                                                     }
  818.                                                 }
  819.                                                 paths2[pos2]=NULL;
  820.                                                 pos2=0;
  821.                                                 free(paths);
  822.                                                 paths=paths2;
  823.                                                 paths2=NULL;
  824.                                                 max--;
  825.                                             }
  826.                                         }
  827.                                         else
  828.                                         {
  829.                                             if (strcmp(buffer,paths[select-1]))
  830.                                             {
  831.                                                 paths[select-1]=(char *) realloc(paths[select-1],(strlen(buffer)+1)*sizeof(char ));
  832.                                                 strcpy(paths[select-1],buffer);
  833.                                             }
  834.                                         }
  835.                                     }                                        
  836.                                         
  837.  
  838.  
  839.                                 }
  840.         
  841.  
  842.  
  843.  
  844.  
  845.  
  846.  
  847.  
  848.         }
  849.     } while (!quit);
  850.  
  851. }
  852.  
  853. void editarea(void)
  854. {
  855.     ULONG    pos=0,select=0,select2=0,max=0,len=0;
  856.     char    selectstr[3]="",buffer[255],buffer2[255],buffer3[30],**area=NULL;
  857.     BPTR    fh=NULL;
  858.     struct    FileInfoBlock *fib=NULL;
  859.  
  860.     
  861.     do
  862.     {
  863.         area=(char **) realloc(area,sizeof(char *));
  864.         fh=Lock("bbs:AreaNames/",ACCESS_READ);
  865.         if (fh)    UnLock(fh);
  866.         else
  867.         {
  868.             fh=CreateDir("bbs:AreaNames");
  869.             UnLock(fh);
  870.         }
  871.         fib = AllocDosObject(DOS_FIB, NULL);
  872.         fh=Lock("bbs:AreaNames",ACCESS_READ);
  873.         if (fh)
  874.         {
  875.             Examine(fh,fib);
  876.             pos=0;
  877.             while (ExNext(fh,fib))
  878.             {    
  879.                 strcpy(buffer,fib->fib_FileName);
  880.                 area=(char **) realloc(area,(pos+1)*sizeof(char *));
  881.                 area[pos]=NULL;
  882.                 if(buffer[strlen(buffer)-1]=='\n') buffer[strlen(buffer)-1]='\0';
  883.                 len=strlen(buffer);
  884.                 area[pos]=(char *) malloc (len+1);
  885.                    if (area[pos]!=NULL)
  886.                 strcpy(area[pos],buffer);
  887.                 pos++;
  888.             }
  889.             area=(char **) realloc(area,(pos+1)*sizeof(char *));
  890.             area[pos]=NULL;
  891.         }
  892.         UnLock(fh);
  893.         FreeDosObject(DOS_FIB,fib);
  894.  
  895.         ws ("c",1);
  896.         ws (" Areanames:",1);
  897.         ws ("",1);
  898.         
  899.         for (pos=0;area[pos];pos++)
  900.         {
  901.             sprintf(buffer," [%2d] %s",pos+1,area[pos]);
  902.             ws(buffer,1);
  903.         }
  904.         ws("",1);
  905.         ws(" [ A] Add AreaName",1);
  906.         ws(" [ D] Delete AreaName",1);
  907.         ws(" [ R] Rename AreaName",1);
  908.  
  909.         max=pos;
  910.         ws("",1);
  911.         SendStrDataCmd(JH_PM,"Choose: ",2);
  912.         if (XIM_Msg->Data==-1) return;
  913.         strcpy(selectstr,XIM_Msg->String);
  914.         lowerstring(selectstr);
  915.         select=atoi(selectstr);
  916.         switch (select)
  917.         {
  918.             case     0        :    {
  919.  
  920.  
  921.                                     switch (selectstr[0])
  922.                                     {
  923.                                         case 'a'    :    {
  924.                                                             SendStrDataCmd(JH_PM,"New AreaName: ",9);
  925.                                                             if (XIM_Msg->Data==-1) return;
  926.                                                             strcpy(buffer3,XIM_Msg->String);
  927.                                                             if (buffer3[0]!='\0')
  928.                                                             {            
  929.                                                                 sprintf(buffer,"bbs:AreaNames/%s",buffer3);
  930.                                                                 fh=Open(buffer,MODE_OLDFILE);
  931.                                                                 if (fh)
  932.                                                                 {
  933.                                                                     ws("Already exists!",1);
  934.                                                                 }
  935.                                                                     else
  936.                                                                 {
  937.                                                                     ws("                         1111111111222222",1);
  938.                                                                     ws("                1234567890123456789012345",1);
  939.                                                                     ws("Conference axx: ",0);
  940.                                                                         GetStr(25,"");
  941.                                                                     strcpy(buffer2,XIM_Msg->String);    
  942.  
  943.                                                                     sprintf(buffer,"bbs:AreaNames/%s",buffer3);
  944.                                                                     fh=Open(buffer,MODE_NEWFILE);
  945.                                                                     if (fh)
  946.                                                                     {
  947.                                                                         sprintf(buffer,"%s\n",buffer2);    
  948.                                                                         FPuts(fh,buffer);
  949.                                                                         Close(fh);
  950.                                                                     }                
  951.                                                                 }
  952.                                                             }
  953.                                                             select=max+1;
  954.                                                         }    
  955.                                                         break;
  956.                                         case 'd'    :    {
  957.                                                             SendStrDataCmd(JH_PM,"Delete which AreaName: ",2);
  958.                                                             if (XIM_Msg->Data==-1) return;
  959.                                                             select2=atoi(XIM_Msg->String);
  960.                                                             if ((select2>0) && (select2<=max))
  961.                                                             {    
  962.             
  963.                                                                 SendStrDataCmd(JH_PM,"Are U sure (y/N): ",3);    
  964.                                                                 lowerstring(XIM_Msg->String);
  965.                                                                 if (XIM_Msg->String[0]=='y')
  966.                                                                 {
  967.                                                                     sprintf(buffer,"bbs:Areanames/%s",area[select2-1]);
  968.                                                                     DeleteFile(buffer);
  969.                                                                 }
  970.                                                             }
  971.                                                             select=max+1;
  972.                                                         }
  973.                                                         break;
  974.                                         case 'r'    :    {
  975.                                                             SendStrDataCmd(JH_PM,"Rename which AreaName: ",2);
  976.                                                             if (XIM_Msg->Data==-1) return;
  977.                                                             select2=atoi(XIM_Msg->String);
  978.                                                             if ((select2>0) && (select2<=max))
  979.                                                             {    
  980.                                                                 ws("New name: ",0);
  981.                                                                 GetStr(9,area[select2-1]);
  982.                                                                 strcpy(buffer2,XIM_Msg->String);
  983.                                                             }
  984.                                                                         
  985.                                                             sprintf(buffer3,"bbs:AreaNames/%s",area[select2-1]);
  986.                                                             sprintf(buffer,"bbs:AreaNames/%s",buffer2);
  987.                                                             Rename(buffer3,buffer);
  988.                                                                 
  989.                                                             select=max+1;
  990.                                                         }
  991.                                                         
  992.                                                         break;
  993.  
  994.                                     }
  995.  
  996.                                                                 
  997.                                                             
  998.  
  999.  
  1000.                                 
  1001.                                 }
  1002.                                 break;
  1003.  
  1004.  
  1005.             default            :    {
  1006.                                     if ((select>0) && (select<=max))
  1007.                                     {
  1008.                                         sprintf(buffer,"bbs:AreaNames/%s",area[select-1]);
  1009.                                         fh=Open(buffer,MODE_OLDFILE);
  1010.                                         if (fh)
  1011.                                         {
  1012.                                             FGets(fh,buffer,50);
  1013.                                             Close(fh);
  1014.                                         }                
  1015.                                         if (buffer[strlen(buffer)-1]=='\n') buffer[strlen(buffer)-1]='\0';
  1016.                                         ws("                         1111111111222222",1);
  1017.                                         ws("                1234567890123456789012345",1);
  1018.                                         ws("Conference axx: ",0);
  1019.                                         GetStr(25,buffer);
  1020.                                         strcpy(buffer2,XIM_Msg->String);
  1021.  
  1022.                                         sprintf(buffer,"bbs:AreaNames/%s",area[select-1]);
  1023.                                         fh=Open(buffer,MODE_OLDFILE);
  1024.                                         if (fh)
  1025.                                         {
  1026.                                             sprintf(buffer,"%s\n",buffer2);    
  1027.                                             FPuts(fh,buffer);
  1028.                                             Close(fh);
  1029.                                         }                
  1030.                                     }
  1031.                                 }
  1032.                                 break;
  1033.         }
  1034.  
  1035.         for (pos=0;area[pos];pos++)
  1036.             if (area[pos]) free(area[pos]);
  1037.         if (area) free (area);
  1038.  
  1039.     } while (select!=0);
  1040.     
  1041.  
  1042.  
  1043. }
  1044.  
  1045.  
  1046. BOOL getconfigbool(char **main_search,char *lookfor,BOOL std)
  1047. {
  1048.     char *p=NULL;
  1049.  
  1050.     p=getconfig(main_search,lookfor);
  1051.     if (p) 
  1052.     {
  1053.         upperstring(p);
  1054.         if (p[0]=='Y') 
  1055.             return(TRUE);
  1056.         else
  1057.             return(FALSE);
  1058.     }
  1059.     else return(std);
  1060. }
  1061.  
  1062. char *getconfig(char **main_search,char *lookfor)
  1063. {
  1064.     char     *p=NULL,    *q=NULL;
  1065.     ULONG    pos=0;
  1066.     
  1067.     for (pos=0;main_search[pos]!=NULL && (!p);pos++)
  1068.     {
  1069.         q=main_search[pos];
  1070.         for (;!isalpha(*q);q++);
  1071.         if (strncmp(q,lookfor,strlen(lookfor))==0)
  1072.         {
  1073.             p=q+strlen(lookfor);
  1074.             for (;!isalpha(*p);p++);
  1075.         }    
  1076.     }
  1077.     return p;
  1078.             
  1079. }
  1080.