home *** CD-ROM | disk | FTP | other *** search
/ YPA: Your Privacy Assured / YPA.ISO / other_goodies / utilities / amipop116.lha / AmiPOP116 / source / pop_main.c < prev    next >
C/C++ Source or Header  |  1995-01-23  |  9KB  |  520 lines
  1. /* AmiPOP By Scott Ellis */
  2.  
  3. #include "pop.h"
  4.  
  5. static const char VersionID[]="\0$VER:AmiPOP 1.16 (23.1.95)";
  6.  
  7. /* Variables in pop.h */
  8.  
  9. char *pophost=NULL;
  10. char *username=NULL;
  11. char *password=NULL;
  12. char *passfake=NULL;
  13. char *mailbox=NULL;
  14. char *cxname=NULL;
  15. char *cxdesc=NULL;
  16. char *hotkey=NULL;
  17. char *title=NULL;
  18. char *temp=NULL;
  19. char *buf=NULL;
  20. UBYTE *PubScreenName=NULL;
  21.  
  22. const char bum[]="Ok";
  23.  
  24. BOOL delmail=FALSE;
  25. BOOL checkper=FALSE;
  26. BOOL appfile=TRUE;
  27. BOOL winop=TRUE;
  28. BOOL notify=FALSE;
  29. BOOL immediate=FALSE;
  30. BOOL quiet=FALSE;
  31. BOOL once=FALSE;
  32.  
  33. int timecheck=10;
  34. int port=110;
  35. int winx=0;
  36. int winy=0;
  37.  
  38. struct MsgPort *amipop_mp=NULL;
  39. struct MsgPort *timer_mp=NULL;
  40. struct timerequest *timerio=NULL;
  41. CxObj *broker=NULL;
  42. struct Library *TimerBase=NULL;
  43. struct IntuitionBase *IntuitionBase=NULL;
  44. struct Library *GadToolsBase=NULL;
  45.  
  46.  
  47. struct NewBroker newbroker = {
  48.     NB_VERSION,   /* nb_Version - Version of the NewBroker structure */
  49.     "Not Active", /* nb_Name */
  50.     "Amiga POP ⌐ 1994 Scott Ellis",     /* nb_Title - Title of commodity that appears in CXExchange */
  51.     "Not Active", /* nb_Descr */
  52.     NBU_NOTIFY | NBU_UNIQUE ,            /* nb_Unique - Tells CX not to launch another commodity with same name */
  53.     COF_SHOW_HIDE,            /* nb_Flags - Tells CX if this commodity has a window */
  54.     0,            /* nb_Pri - This commodity's priority */
  55.     0,            /* nb_Port - MsgPort CX talks to */
  56.     0             /* nb_ReservedChannel - reserved for later use */
  57. };
  58.  
  59. struct EasyStruct ereq =
  60.     {
  61.     sizeof(struct EasyStruct),
  62.     0,
  63.     "AmiPOP Notice",
  64.     "%s",
  65.     "%s",
  66.     };
  67.  
  68. UWORD __chip waitPointer[] =
  69.     {
  70.     0x0000, 0x0000,     /* reserved, must be NULL */
  71.  
  72.     0x0400, 0x07C0,
  73.     0x0000, 0x07C0,
  74.     0x0100, 0x0380,
  75.     0x0000, 0x07E0,
  76.     0x07C0, 0x1FF8,
  77.     0x1FF0, 0x3FEC,
  78.     0x3FF8, 0x7FDE,
  79.     0x3FF8, 0x7FBE,
  80.     0x7FFC, 0xFF7F,
  81.     0x7EFC, 0xFFFF,
  82.     0x7FFC, 0xFFFF,
  83.     0x3FF8, 0x7FFE,
  84.     0x3FF8, 0x7FFE,
  85.     0x1FF0, 0x3FFC,
  86.     0x07C0, 0x1FF8,
  87.     0x0000, 0x07E0,
  88.  
  89.     0x0000, 0x0000,     /* reserved, must be NULL */
  90.     };
  91.  
  92. enum args
  93.     {
  94.     USERNAME,
  95.     PASSWORD,
  96.     POPHOST,
  97.     MAILBOX,
  98.     CHECKPER,
  99.     TIME,
  100.     DELETE,
  101.     APPEND,
  102.     NOWINDOW,
  103.     PORT,
  104.     NOTIFY,
  105.     CX_POPKEY,
  106.     IMMEDIATE,
  107.     QUIET,
  108.     PUBSCREEN,
  109.     ONCE,
  110.     WINX,
  111.     WINY
  112.     };
  113.  
  114. /* Configure SAS Specific routines */
  115.  
  116. void __regargs __chkabort(void) {}
  117. long __stack = 20000;
  118.  
  119. /* End SAS */
  120.  
  121. /* Now define the structure that we will get when we start up the program */
  122. typedef struct popstruct {
  123.     char pophost[BIGSTRING];
  124.     char username[SMALLSTRING];
  125.     char password[SMALLSTRING];
  126.     char passfake[SMALLSTRING];
  127.     char mailbox[BIGSTRING];
  128.     char cxname[BIGSTRING];
  129.     char cxdesc[3*BIGSTRING];
  130.     char hotkey[BIGSTRING];
  131.     char title[256];
  132.     char temp[BUFSIZE];
  133.     char buf[BUFSIZE];
  134.     char PubScreenName[SMALLSTRING];
  135. } PopStruct;
  136.  
  137. ULONG            sigmask=NULL;
  138. ULONG            cxsigflag=NULL;
  139. ULONG            timesigflag=NULL;
  140.  
  141. struct Library *IconBase;
  142. struct RDArgs   *RDA;
  143.  
  144. int main(int argc, char **argv)
  145. {
  146.     int foo=0;
  147.     ULONG    mysig;
  148.  
  149.     IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library",37L);
  150.     GadToolsBase = OpenLibrary("gadtools.library",37L);
  151.  
  152.     if (GadToolsBase && IntuitionBase)
  153.     {
  154.         if (makevars())
  155.         {
  156.             freevars();
  157.             return(20);
  158.         }
  159.  
  160.         if ( parse(argc) )
  161.         {
  162.             if ( setuptime() )
  163.             {
  164.                 timesigflag = 1L << timer_mp->mp_SigBit;
  165.                 timereq();
  166.                 foo=1;
  167.  
  168.                 if ( setupcx() )
  169.                 {
  170.                     if (winop)
  171.                     {
  172.                         openup();
  173.                     }
  174.                 }
  175.                 else
  176.                 {
  177.                     foo=0;
  178.                 }
  179.             }
  180.         }
  181.         else
  182.         {
  183.             foo=0;
  184.         }
  185.  
  186.         if (once && foo)
  187.         {
  188.             MYGAD_BUTTONClicked();
  189.             foo=0;
  190.         }
  191.  
  192.         if (immediate && foo) MYGAD_BUTTONClicked(); /* Check mail immediately */
  193.  
  194.         while (foo)
  195.         {
  196.             if (winop)
  197.             {
  198.                 sigmask= 1 << Project0Wnd->UserPort->mp_SigBit ;
  199.             }
  200.             else
  201.             {
  202.                 sigmask= NULL;
  203.             }
  204.  
  205.             mysig=Wait ( sigmask | cxsigflag | timesigflag | SIGBREAKF_CTRL_C );
  206.  
  207.             if ( mysig & cxsigflag )
  208.             {
  209.                 foo=docx();
  210.             }
  211.                    if ( mysig & sigmask )
  212.             {
  213.                 foo=HandleProject0IDCMP();
  214.             }
  215.  
  216.             if ( mysig & timesigflag )
  217.             {
  218.                 if (checkper)
  219.                 {
  220.                     MYGAD_BUTTONClicked();
  221.                 }
  222.                 timereq();
  223.             }
  224.  
  225.             if (mysig & SIGBREAKF_CTRL_C )
  226.             {
  227.                 foo=0;
  228.             }
  229.         }
  230.  
  231.         closedown();
  232.  
  233.         closetime();
  234.  
  235.         closecx();
  236.  
  237.         freevars();
  238.  
  239.     }
  240.  
  241.     if (IntuitionBase) CloseLibrary((struct Library *)IntuitionBase);
  242.     if (GadToolsBase) CloseLibrary(GadToolsBase);
  243.  
  244.     return(0);
  245. }
  246.  
  247. void openup(void)
  248. {
  249.     SetupScreen();
  250.     OpenProject0Window();
  251.  
  252.     winop=TRUE;
  253. }
  254.  
  255. void closedown(void)
  256. {
  257.     CloseProject0Window();
  258.     CloseDownScreen();
  259.  
  260.     winop=FALSE;
  261. }
  262.  
  263.  
  264. BOOL parse( int argc )
  265. {
  266.     LONG    *ArgumentArray;        /* array for storing arguments retrieved by */
  267.     const char none[]="None Given";
  268.  
  269.     if (!(ArgumentArray = ParseParameters(argc, "Username/K,Password/K,POPHost/K,MailBox/K,CheckPer/S,"
  270.                                 "Time/K/N,Delete/S,Append/S,NoWindow/S,Port/K/N,Notify/S,"
  271.                                 "Cx_Popkey/K,Immediate/S,Quiet/S,PubScreen/K,Once/S,"
  272.                                 "WinX/K/N,WinY/K/N")))
  273.     {
  274.         FreeParameters(ArgumentArray);
  275.         return(FALSE);
  276.     }
  277.     else
  278.     {
  279.         if (ArgumentArray[USERNAME])
  280.         {
  281.             strcpy(username,(char *)ArgumentArray[USERNAME]);
  282.         }
  283.         else
  284.         {
  285.             strcpy(username,none);
  286.         }
  287.  
  288.         if (ArgumentArray[PASSWORD])
  289.         {
  290.             strcpy(password,(char *)ArgumentArray[PASSWORD]);
  291.         }
  292.         else
  293.         {
  294.             strcpy(password,"");
  295.         }
  296.  
  297.         if (ArgumentArray[POPHOST])
  298.         {
  299.             strcpy(pophost,(char *)ArgumentArray[POPHOST]);
  300.         }
  301.         else
  302.         {
  303.             strcpy(pophost,none);
  304.         }
  305.  
  306.         if (ArgumentArray[MAILBOX])
  307.         {
  308.             strcpy(mailbox,(char *)ArgumentArray[MAILBOX]);
  309.         }
  310.         else
  311.         {
  312.             strcpy(mailbox,none);
  313.         }
  314.  
  315.         checkper=(BOOL)ArgumentArray[CHECKPER];
  316.  
  317.         if (ArgumentArray[TIME])
  318.         {
  319.             timecheck=*(int *)ArgumentArray[TIME];
  320.         }
  321.  
  322.         delmail=(BOOL)ArgumentArray[DELETE];
  323.         appfile=(BOOL)ArgumentArray[APPEND];
  324.         winop=!( (BOOL)ArgumentArray[NOWINDOW] );
  325.  
  326.         if (ArgumentArray[PORT])
  327.         {
  328.             port = *(int *)ArgumentArray[PORT];
  329.         }
  330.  
  331.         notify=(BOOL)ArgumentArray[NOTIFY];
  332.  
  333.         if (ArgumentArray[CX_POPKEY])
  334.         {
  335.             strcpy(hotkey,(char *)ArgumentArray[CX_POPKEY]);
  336.         }
  337.  
  338.         if (ArgumentArray[IMMEDIATE])
  339.         {
  340.             immediate=TRUE;
  341.         }
  342.  
  343.         if (ArgumentArray[QUIET])
  344.         {
  345.             quiet=TRUE;
  346.         }
  347.  
  348.         if (ArgumentArray[PUBSCREEN])
  349.         {
  350.             strcpy(PubScreenName,(UBYTE *)ArgumentArray[PUBSCREEN]);
  351.         }
  352.  
  353.         if (ArgumentArray[ONCE])
  354.         {
  355.             once=TRUE;
  356.         }
  357.  
  358.         if (ArgumentArray[WINX])
  359.         {
  360.             winx = *(int *)ArgumentArray[WINX];
  361.         }
  362.  
  363.         if (ArgumentArray[WINY])
  364.         {
  365.             winy = *(int *)ArgumentArray[WINY];
  366.         }
  367.  
  368.         FreeParameters(ArgumentArray);
  369.  
  370.         return(TRUE);
  371.     }
  372.  
  373. }
  374.  
  375.  
  376. LONG *ParseParameters(int argc, char *OriginalTemplate)
  377. {
  378.     LONG    *ArgumentArray;        /* array for storing arguments retrieved by */
  379.  
  380.     char    **ToolArrayIndex,    /* workbench tooltypes array */
  381.             *ToolStringIndex,    /* index into string of concatenated workbench tooltypes */
  382.             *Template;            /* readargs template - varies slightly for WB or CLI */
  383.  
  384.     struct DiskObject    *DiskObject;    /* pointer to diskobject associated with program icon */
  385.     WORD    ArgCount = 1;        /* number of arguments in template */
  386.  
  387.     RDA = AllocDosObjectTags(DOS_RDARGS, TAG_DONE);
  388.     RDA->RDA_ExtHelp = NULL;
  389.  
  390.     Template = AllocVec(strlen(OriginalTemplate)+16,MEMF_CLEAR);
  391.  
  392.     for (    ToolStringIndex = OriginalTemplate;
  393.             ToolStringIndex = strchr(ToolStringIndex,',');
  394.              ToolStringIndex++, ArgCount++);
  395.  
  396.     ArgumentArray = AllocVec((ArgCount+1)*4,MEMF_CLEAR);
  397.  
  398.     if (argc==0)
  399.     {
  400.         if (IconBase = OpenLibrary("icon.library", 36L) )
  401.         {
  402.             CurrentDir(_WBenchMsg->sm_ArgList->wa_Lock);
  403.  
  404.             if (DiskObject = GetDiskObject(_WBenchMsg->sm_ArgList->wa_Name))
  405.             {
  406.                 for (    ToolArrayIndex = DiskObject->do_ToolTypes;
  407.                         *ToolArrayIndex;
  408.                         ToolArrayIndex++)
  409.                 {
  410.                     RDA->RDA_Source.CS_Length += (strlen(*ToolArrayIndex)+1);
  411.                 }
  412.  
  413.                 if (RDA->RDA_Source.CS_Length)
  414.                 {
  415.                     RDA->RDA_Source.CS_Buffer = AllocVec(RDA->RDA_Source.CS_Length+1,MEMF_CLEAR);
  416.                     ToolStringIndex = RDA->RDA_Source.CS_Buffer;
  417.  
  418.                     for (    ToolArrayIndex = DiskObject->do_ToolTypes;
  419.                             *ToolArrayIndex;
  420.                             ToolArrayIndex++)
  421.                     {
  422.                         ToolStringIndex = stpcpy(stpcpy(ToolStringIndex,*ToolArrayIndex)," ");
  423.                     }
  424.  
  425.                     *(ToolStringIndex-1) = '\n';
  426.                     FreeDiskObject(DiskObject);
  427.                 }
  428.             }
  429.         }
  430.  
  431.         stpcpy(stpcpy(Template,OriginalTemplate),",ThrowAway/M");
  432.  
  433.     }
  434.     else
  435.     {
  436.         strcpy(Template,OriginalTemplate);
  437.     }
  438.  
  439.     RDA = ReadArgs(Template,ArgumentArray,RDA);
  440.  
  441.     FreeVec(Template);
  442.  
  443.     if (RDA)
  444.     {
  445.         return(ArgumentArray);
  446.     }
  447.     else
  448.     {
  449.         return(NULL);
  450.     }
  451. }
  452.  
  453. void FreeParameters(LONG *ArgumentArray)
  454. {
  455.     if (RDA)
  456.     {
  457.         if ((RDA->RDA_Source.CS_Length) && (RDA->RDA_Source.CS_Buffer))
  458.         {
  459.             FreeVec(RDA->RDA_Source.CS_Buffer);
  460.         }
  461.  
  462.         FreeArgs(RDA);
  463.         FreeDosObject(DOS_RDARGS,RDA);
  464.     }
  465.     else
  466.     {
  467.         PrintFault(IoErr(), NULL);
  468.     }
  469.  
  470.     if (ArgumentArray)
  471.     {
  472.         FreeVec(ArgumentArray);
  473.     }
  474. }
  475.  
  476.  
  477. int doreq( const char *mes, const char *but)
  478. {
  479.     LONG answer;
  480.  
  481.     if ( !quiet )
  482.     {
  483.         answer= EasyRequest(NULL, &ereq, NULL, mes, but);
  484.  
  485.         if (Project0Wnd)
  486.         {
  487.             SetWindowTitles(Project0Wnd,Project0Wdt, (UBYTE *) ~0);
  488.         }
  489.  
  490.         return(answer);
  491.     }
  492. }
  493.  
  494. BOOL makevars(void)
  495. {
  496. PopStruct *blockptr;
  497.     if ( blockptr=AllocVec(sizeof(PopStruct),MEMF_CLEAR) )
  498.     {
  499.         pophost=blockptr->pophost;
  500.         username=blockptr->username;
  501.         password=blockptr->password;
  502.         passfake=blockptr->passfake;
  503.         mailbox=blockptr->mailbox;
  504.         cxname=blockptr->cxname;
  505.         cxdesc=blockptr->cxdesc;
  506.         hotkey=blockptr->hotkey;
  507.         title=blockptr->title;
  508.         temp=blockptr->temp;
  509.         buf=blockptr->buf;
  510.         PubScreenName=blockptr->PubScreenName;
  511.         return(FALSE);
  512.     }
  513.     return(TRUE);
  514. }
  515.  
  516. void freevars(void)
  517. {
  518.     if (pophost) FreeVec(pophost);
  519. }
  520.