home *** CD-ROM | disk | FTP | other *** search
/ linuxmafia.com 2016 / linuxmafia.com.tar / linuxmafia.com / pub / palmos / genpw-0.3.tar.gz / genpw-0.3.tar / genpw / genpw.c < prev    next >
C/C++ Source or Header  |  1999-08-13  |  19KB  |  580 lines
  1. /*************************************************************
  2.  *
  3.  * genpw.c:  Program to generate a random password for the
  4.  *           Palm Connected Organizers.
  5.  *
  6.  * This program is distributed under the GNU General 
  7.  * Public License (GPL).
  8.  * See http://www.gnu.org/copyleft/gpl.html
  9.  *
  10.  * This software comes with NO warranty at all and I
  11.  * cannot be held responsible for anything it may do.
  12.  * I make no claims as to my ability to write programs.
  13.  * You have the source code, so check it out.
  14.  *
  15.  * This program was developed on a Linux/GNU system using FREE
  16.  * tools.  A special thanks to all programmers who developed
  17.  * the following tools I used:
  18.  *
  19.  *   pilot-xfer-0.9.3
  20.  *   gcc-2.7.2 cross compiler for Palm Connected Organizers
  21.  *   gdb-4.16
  22.  *   prctools-0.5.0
  23.  *   pilot-template-1.31
  24.  *   xcopilot-0.6.6
  25.  *   pilrc-2.3a
  26.  *
  27.  * Kevin Dupree
  28.  * kdupree@flash.net
  29.  *************************************************************/
  30.  
  31. #pragma pack(2)
  32.  
  33. #include "genpw.h"
  34. #include <Common.h>
  35. #include <System/SysAll.h>
  36. #include <UI/UIAll.h>
  37.  
  38. /*************************************************************
  39.  *      Defines                                              *
  40.  *************************************************************/
  41. #define genpwCreator   'GenP'
  42. /* Define the minimum OS version allowed */
  43. #define Version20    sysMakeROMVersion (2, 0, 0, 0, 0)
  44. #define BITS_SET(w,b) (((w) & (b)) == (b))
  45.  
  46. /*************************************************************
  47.  *    Global Variables                                     *
  48.  *************************************************************/
  49. /* Possible characters that can be used in password */
  50. VoidHand hndValidChars;
  51. /* Password used in Generation routine */
  52. VoidHand hndPasswdChars;
  53. /* Character version of number of characters in password */
  54. VoidHand hndNumber;
  55. /* Password used for display on form */
  56. VoidHand hndPassword;
  57. static CharPtr sLower = "abcdefghijklmnopqrstuvwxyz";
  58. static CharPtr sUpper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
  59. static CharPtr sNumber = "1234567890";
  60. static CharPtr sHex = "123456789ABCDEF";
  61. static CharPtr sSpecial = "!@#$%^&*-_=+,<.>/?";
  62. static Boolean bUseNumber = true;
  63. static Boolean bUseSpecial = true;
  64. static Boolean bUseUpper = true;
  65. static Boolean bUseLower = true;
  66. static Boolean bUseHex = false;
  67. static Int iGenNumber = 10;
  68.  
  69.  
  70. /*************************************************************
  71.  *    Routines                                             *
  72.  *************************************************************/
  73. static CharPtr GeneratePW( void );
  74. static VoidPtr Id2Ptr( Word );
  75. static Word StartApplication (void);
  76. static void StopApplication (void);
  77. static Err CheckRomVersion(DWord requiredVersion, Word launchFlags);
  78.  
  79.  
  80. /*************************************************************
  81.  *    Type Definitions                                     *
  82.  *************************************************************/
  83.  
  84. /* preferences state file. */
  85. typedef struct {
  86.   Boolean useUpper;
  87.   Boolean useLower;
  88.   Boolean useNumber;
  89.   Boolean useSpecial;
  90.   Int NumberChars;
  91.   Boolean useHex;
  92. } GenPWPrefType;
  93.  
  94. /*************************************************************
  95.  *
  96.  * NAME:        PilotMain
  97.  *
  98.  * DESCRIPTION: This is the main entry point for the GenPW
  99.  *              application.
  100.  *
  101.  * REVISION HISTORY:
  102.  *   Name   Date       Description
  103.  *   ----   --------   -----------
  104.  *   kld    5 Nov 98   Initial Revision
  105.  *
  106.  *************************************************************/
  107. DWord PilotMain(Word cmd, Ptr cmdPBP, Word launchFlags)
  108. {
  109.   short err;
  110.   EventType e;
  111.   Word error;
  112.   FormType *pfrm;
  113.   FieldPtr fld;
  114.   CharPtr sFld;
  115.   ControlPtr ctl;
  116.   ControlPtr pNumberCtl;
  117.  
  118.   err = CheckRomVersion (Version20, launchFlags);
  119.   if (err) return (err);
  120.  
  121.   if (cmd == sysAppLaunchCmdNormalLaunch) 
  122.     {
  123.       error = StartApplication ();
  124.       /* For now just use default settings if preferences load failed */
  125.       /* if (error) return (error); */
  126.  
  127.       hndPassword = MemHandleNew ( 21 );
  128.       if (hndPassword == NULL) return (1);
  129.       hndValidChars = MemHandleNew ( 85 );
  130.       if (hndValidChars == NULL) return(1);
  131.       hndPasswdChars = MemHandleNew ( 21 );
  132.       if (hndPasswdChars == NULL) return (1);
  133.       hndNumber = MemHandleNew ( 3 );
  134.       if (hndNumber == NULL) return (1);
  135.  
  136.       FrmGotoForm(genpwFormMain);
  137.  
  138.       while(1) 
  139.         {
  140.           EvtGetEvent(&e, -1);  // Don't want nilEvent
  141.           if (SysHandleEvent(&e)) 
  142.             continue;
  143.           if (MenuHandleEvent((void *)0, &e, &err)) 
  144.             continue;
  145.           
  146.           switch (e.eType) 
  147.             {
  148.             case ctlSelectEvent:
  149.               if (e.data.ctlSelect.controlID == idOKB)
  150.                 {
  151.                   fld = Id2Ptr(idPasswdFld);
  152.                   sFld = (CharPtr) MemHandleLock (hndPassword);
  153.                   StrCopy( sFld, GeneratePW());
  154.                   MemHandleUnlock (hndPassword);
  155.                   FldSetTextHandle (fld, (Handle) hndPassword);
  156.                   FldDrawField(fld);
  157.                 }
  158.               else if (e.data.ctlSelect.controlID == idNumberCB)
  159.                 {
  160.                   bUseNumber = !bUseNumber;
  161.                 }
  162.               else if (e.data.ctlSelect.controlID == idSpecCharCB)
  163.                 {
  164.                   bUseSpecial = !bUseSpecial;
  165.                 }
  166.               else if (e.data.ctlSelect.controlID == idMixedPB)
  167.                 {
  168.                   bUseUpper = true;
  169.                   bUseLower = true;
  170.                   bUseHex = false;
  171.                   CtlSetUsable( pNumberCtl, true );
  172.                   CtlSetValue( pNumberCtl, bUseNumber );
  173.                 }
  174.               else if (e.data.ctlSelect.controlID == idUpperPB)
  175.                 {
  176.                   bUseUpper = true;
  177.                   bUseLower = false;
  178.                   bUseHex = false;
  179.                   CtlSetUsable( pNumberCtl, true );
  180.                   CtlSetValue( pNumberCtl, bUseNumber );
  181.                 }
  182.               else if (e.data.ctlSelect.controlID == idLowerPB)
  183.                 {
  184.                   bUseUpper = false;
  185.                   bUseLower = true;
  186.                   bUseHex = false;
  187.                   CtlSetUsable( pNumberCtl, true );
  188.                   CtlSetValue( pNumberCtl, bUseNumber );
  189.                 }
  190.               else if (e.data.ctlSelect.controlID == idHexPB)
  191.                 {
  192.                   bUseHex = true;
  193.                   bUseNumber = false;
  194.                   bUseUpper = false;
  195.                   bUseLower = false;
  196.                   CtlSetUsable( pNumberCtl, false );
  197.                   CtlSetValue( pNumberCtl, false );
  198.                 }
  199.               else if (e.data.ctlSelect.controlID == idNumPB)
  200.                 {
  201.                   bUseNumber = true;
  202.                   bUseHex = false;
  203.                   bUseUpper = false;
  204.                   bUseLower = false;
  205.                   CtlSetUsable( pNumberCtl, false );
  206.                   CtlSetValue( pNumberCtl, true );
  207.                 }
  208.               else if (e.data.ctlSelect.controlID == idDownRB)
  209.                 {
  210.                   if (iGenNumber > 4)
  211.                     {
  212.                       iGenNumber--;
  213.                       fld = Id2Ptr(idNumberFld);
  214.                       sFld = (CharPtr) MemHandleLock (hndNumber);
  215.                       StrCopy ( sFld, "" );
  216.                       StrIToA( sFld, iGenNumber);
  217.                       MemHandleUnlock (hndNumber);
  218.                       FldSetTextHandle (fld, (Handle) hndNumber);
  219.                       FldDrawField(fld);
  220.                     }
  221.                 }
  222.               else if (e.data.ctlSelect.controlID == idUpRB)
  223.                 {
  224.                   if (iGenNumber < 20)
  225.                     {
  226.                       iGenNumber++;
  227.                       fld = Id2Ptr(idNumberFld);
  228.                       sFld = (CharPtr) MemHandleLock (hndNumber);
  229.                       StrCopy ( sFld, "" );
  230.                       StrIToA( sFld, iGenNumber);
  231.                       MemHandleUnlock (hndNumber);
  232.                       FldSetTextHandle (fld, (Handle) hndNumber);
  233.                       FldDrawField(fld);
  234.                     }
  235.                 }
  236.               break;
  237.             case ctlRepeatEvent:
  238.               
  239.               if (e.data.ctlRepeat.controlID == idDownRB)
  240.                 {
  241.                   if (iGenNumber > 4)
  242.                     {
  243.                       iGenNumber--;
  244.                       fld = Id2Ptr(idNumberFld);
  245.                       sFld = (CharPtr) MemHandleLock (hndNumber);
  246.                       StrCopy ( sFld, "" );
  247.                       StrIToA( sFld, iGenNumber);
  248.                       MemHandleUnlock (hndNumber);
  249.                       FldSetTextHandle (fld, (Handle) hndNumber);
  250.                       FldDrawField(fld);
  251.                     }
  252.                   /* call FrmHandleEvent to finish processing for
  253.                      repeating buttons */
  254.                   FrmHandleEvent( FrmGetActiveForm(), &e );
  255.                 }
  256.               else if (e.data.ctlRepeat.controlID == idUpRB)
  257.                 {
  258.                   if (iGenNumber < 20)
  259.                     {
  260.                       iGenNumber++;
  261.                       fld = Id2Ptr(idNumberFld);
  262.                       sFld = (CharPtr) MemHandleLock (hndNumber);
  263.                       StrCopy ( sFld, "" );
  264.                       StrIToA( sFld, iGenNumber);
  265.                       MemHandleUnlock (hndNumber);
  266.                       FldSetTextHandle (fld, (Handle) hndNumber);
  267.                       FldDrawField(fld);
  268.                     }
  269.                   /* call FrmHandleEvent to finish processing for
  270.                      repeating buttons */
  271.                   FrmHandleEvent( FrmGetActiveForm(), &e );
  272.                 }
  273.               break;
  274.  
  275.             case frmLoadEvent:
  276.               FrmSetActiveForm(FrmInitForm(e.data.frmLoad.formID));
  277.               break;
  278.     
  279.             case frmOpenEvent:
  280.               pfrm = FrmGetActiveForm();
  281.               pNumberCtl = FrmGetObjectPtr( pfrm,
  282.                                             FrmGetObjectIndex( pfrm, idNumberCB ) );
  283.  
  284.               /* Display the selected number of characters */
  285.               fld = Id2Ptr(idNumberFld);
  286.               sFld = (CharPtr) MemHandleLock (hndNumber);
  287.               StrCopy ( sFld, "" );
  288.               StrIToA( sFld, iGenNumber);
  289.               MemHandleUnlock (hndNumber);
  290.               FldSetTextHandle (fld, (Handle) hndNumber);
  291.               FrmDrawForm(pfrm);
  292.  
  293.               /* Intialize the Number Check Box */
  294.               ctl = (ControlPtr) Id2Ptr (idNumberCB);
  295.               CtlSetValue (ctl, bUseNumber);
  296.  
  297.               /* Initialize the Special Character Check Box */
  298.               ctl = (ControlPtr) Id2Ptr (idSpecCharCB);
  299.               CtlSetValue (ctl, bUseSpecial);
  300.  
  301.               /* Select the Case push button */
  302.               if (bUseLower == true && bUseUpper == true)
  303.                 {
  304.                   fld = Id2Ptr(idMixedPB);
  305.                   FrmSetControlGroupSelection( pfrm, 1, idMixedPB );
  306.                 }
  307.               else if (bUseLower)
  308.                 {
  309.                   fld = Id2Ptr(idLowerPB);
  310.                   FrmSetControlGroupSelection( pfrm, 1, idLowerPB );
  311.                 }
  312.               else if (bUseUpper)
  313.                 {
  314.                   fld = Id2Ptr(idUpperPB);
  315.                   FrmSetControlGroupSelection( pfrm, 1, idUpperPB );
  316.                 }
  317.               else if (bUseHex)
  318.                 {
  319.                   fld = Id2Ptr(idHexPB);
  320.                   FrmSetControlGroupSelection( pfrm, 1, idHexPB );
  321.                   CtlSetUsable( pNumberCtl, false );
  322.                 }
  323.               else
  324.                 {
  325.                   fld = Id2Ptr(idNumPB);
  326.                   FrmSetControlGroupSelection( pfrm, 1, idNumPB );
  327.                   CtlSetUsable( pNumberCtl, true );
  328.                 }
  329.  
  330.               break;
  331.  
  332.             case menuEvent:
  333.               if (e.data.ctlSelect.controlID == idGenMenu)
  334.                 {
  335.                   fld = Id2Ptr(idPasswdFld);
  336.                   sFld = (CharPtr) MemHandleLock (hndPassword);
  337.                   StrCopy( sFld, GeneratePW());
  338.                   MemHandleUnlock (hndPassword);
  339.                   FldSetTextHandle (fld, (Handle) hndPassword);
  340.                   FldDrawField( fld );
  341.                 }
  342.               else if (e.data.ctlSelect.controlID == idCopyMenu)
  343.                 {
  344.                   /* Copy the current password to the clipboard */
  345.                   fld = Id2Ptr( idPasswdFld );
  346.                   FldSetSelection( fld, 0, iGenNumber );
  347.                   FldCopy( fld );
  348.                   FldSetSelection( fld, 0, 0 );
  349.                 }
  350.               else if (e.data.ctlSelect.controlID == idHelpMenu)
  351.                 {
  352.                   FrmHelp( genpwHelp1 );
  353.                 }
  354.               else if (e.data.ctlSelect.controlID == idAboutMenu)
  355.                 {
  356.                   FrmHelp( genpwAbout1 );
  357.                 }
  358.               break;
  359.  
  360.             case appStopEvent:
  361.               StopApplication();
  362.               return 0;
  363.  
  364.             default:
  365.               FrmHandleEvent( FrmGetActiveForm(), &e );
  366.  
  367.             }
  368.         }
  369.  
  370.       /* Save the current preferences selected */
  371.       StopApplication();
  372.     }
  373.   return 0;
  374. }
  375.  
  376.  
  377. /*************************************************************
  378.  *
  379.  * NAME:         StartApplication
  380.  *
  381.  * DESCRIPTION:  This routine loads the saved prefrences
  382.  *               information and initializes global variables.
  383.  *
  384.  * REVISION HISTORY:
  385.  *   Name   Date       Description
  386.  *   ----   --------   -----------
  387.  *   kld    5 Nov 98   Initial Revision
  388.  *
  389.  *************************************************************/
  390. static Word StartApplication (void)
  391. {
  392.   Word error = 1;
  393.   GenPWPrefType prefs;
  394.   Int prefsVersion;
  395.   Int prefsSize;
  396.  
  397.   /* Read the preferences saved-state information. */
  398.   prefsSize = sizeof (GenPWPrefType);
  399.   prefsVersion = PrefGetAppPreferences (genpwCreator,
  400.                                         GenPWPrefID, 
  401.                                         &prefs,
  402.                                         &prefsSize,
  403.                                         true);
  404.   if (prefsVersion == GenPWPrefsVersionNum)
  405.     {
  406.       bUseUpper = prefs.useUpper;
  407.       bUseLower = prefs.useLower;
  408.       bUseHex = prefs.useHex;
  409.       bUseNumber = prefs.useNumber;
  410.       bUseSpecial = prefs.useSpecial;
  411.  
  412.       iGenNumber = prefs.NumberChars;
  413.       error = 0;
  414.     }
  415.   else if (prefsVersion == GenPWPrefsVersionOld)
  416.     {
  417.       bUseUpper = prefs.useUpper;
  418.       bUseLower = prefs.useLower;
  419.       bUseNumber = prefs.useNumber;
  420.       bUseSpecial = prefs.useSpecial;
  421.  
  422.       iGenNumber = prefs.NumberChars;
  423.       error = 0;
  424.       bUseHex = false;
  425.     }
  426.   /* Seed the random function */
  427.   SysRandom(TimGetSeconds());
  428.  
  429.   return (error);
  430. }
  431.  
  432.  
  433. /*************************************************************
  434.  *
  435.  * NAME:        StopApplication
  436.  *
  437.  * DESCRIPTION: This routine saves the current state
  438.  *              of the application.
  439.  *
  440.  * REVISION HISTORY:
  441.  *   Name   Date       Description
  442.  *   ----   --------   -----------
  443.  *   kld    5 Nov 98   Initial Revision
  444.  *
  445.  *************************************************************/
  446. static void StopApplication (void)
  447. {
  448.   GenPWPrefType prefs;
  449.  
  450.   prefs.useUpper = bUseUpper;
  451.   prefs.useLower = bUseLower;
  452.   prefs.useNumber = bUseNumber;
  453.   prefs.useSpecial = bUseSpecial;
  454.   prefs.NumberChars = iGenNumber;
  455.   prefs.useHex = bUseHex;
  456.  
  457.   PrefSetAppPreferences (genpwCreator,
  458.                          GenPWPrefID,
  459.                          GenPWPrefsVersionNum,
  460.                          &prefs, 
  461.                          sizeof (GenPWPrefType),
  462.                          true);
  463.  
  464. }
  465.  
  466.  
  467. /*************************************************************
  468.  *
  469.  * NAME:        CheckRomVersion
  470.  *
  471.  * DESCRIPTION: This routine checks that a ROM version meets the
  472.  *              minimum requirement.
  473.  *
  474.  * REVISION HISTORY:
  475.  *   Name   Date       Description
  476.  *   ----   --------   -----------
  477.  *   kld    5 Nov 98   Initial Revision
  478.  *
  479.  *************************************************************/
  480. static Err CheckRomVersion(DWord requiredVersion, Word launchFlags)
  481. {
  482.   DWord romVersion;
  483.  
  484.   /* Get the ROM version for what is running GenPW */
  485.   FtrGet(sysFtrCreator, sysFtrNumROMVersion, &romVersion);
  486.   if (romVersion >=  requiredVersion)
  487.     return (0);
  488.  
  489.   
  490.   /* If the user launched the app from the launcher, explain
  491.      why the app shouldn't run using FrmAlert. */
  492.   if (BITS_SET(launchFlags, sysAppLaunchFlagNewGlobals | sysAppLaunchFlagUIApp))
  493.     {
  494.       FrmAlert (RomIncompatibleAlert);
  495.       if (romVersion < Version20)
  496.         {
  497.           Err err;     // Why is this var needed? See <AppLaunchCmd.h>!
  498.           AppLaunchWithCommand(sysFileCDefaultApp,
  499.                                sysAppLaunchCmdNormalLaunch,
  500.                                NULL);
  501.         }
  502.     }
  503.  
  504.   return (sysErrRomIncompatible);
  505. }
  506.  
  507.  
  508. /*************************************************************
  509.  *
  510.  * NAME:        Id2Ptr
  511.  *
  512.  * DESCRIPTION: This routine is is used to convert an object ID 
  513.  *              into a pointer to the object.
  514.  *
  515.  * REVISION HISTORY:
  516.  *   Name   Date       Description
  517.  *   ----   --------   -----------
  518.  *   kld    5 Nov 98   Initial Revision
  519.  *
  520.  *************************************************************/
  521. static VoidPtr Id2Ptr( Word wID )
  522. {
  523.   return( FrmGetObjectPtr( FrmGetActiveForm(), 
  524.                            FrmGetObjectIndex( FrmGetActiveForm(), wID ) ) );
  525. }
  526.  
  527.  
  528. /*************************************************************
  529.  *
  530.  * NAME:        GeneratePW
  531.  *
  532.  * DESCRIPTION: This routine is used to generate
  533.  *              a random password based on the user's selection
  534.  *              for possible characters and requested size.
  535.  *
  536.  *
  537.  * REVISION HISTORY:
  538.  *   Name   Date       Description
  539.  *   ----   --------   -----------
  540.  *   kld    5 Nov 98   Initial Revision
  541.  *
  542.  *************************************************************/
  543. static CharPtr GeneratePW( void )
  544. {
  545.   UInt NumberChars;
  546.   CharPtr sValidChars;
  547.   CharPtr sPassword;
  548.   Char sTemp;
  549.   int i;
  550.  
  551.   /* Build a string with all possible characters
  552.      requested by the user */
  553.   sValidChars = (CharPtr) MemHandleLock (hndValidChars);
  554.   StrCopy(sValidChars, "");
  555.   if ( bUseLower )
  556.     StrCat( sValidChars, sLower );
  557.   if ( bUseUpper )
  558.     StrCat( sValidChars, sUpper );
  559.   if ( bUseNumber )
  560.     StrCat( sValidChars, sNumber );
  561.   if ( bUseHex )
  562.     StrCat( sValidChars, sHex );
  563.   if ( bUseSpecial )
  564.     StrCat( sValidChars, sSpecial );
  565.   MemHandleUnlock (hndValidChars);
  566.  
  567.   /* Generate the password of the requested size */
  568.   NumberChars = StrLen(sValidChars);
  569.   sPassword = (CharPtr) MemHandleLock (hndPasswdChars);
  570.   StrCopy(sPassword, "");
  571.   MemHandleUnlock (hndPasswdChars);
  572.   for (i=0; i<iGenNumber; i++) {
  573.     sTemp = sValidChars[SysRandom(0)%NumberChars];
  574.     sPassword = (CharPtr) MemHandleLock (hndPasswdChars);
  575.     StrCat(sPassword, &sTemp);
  576.     MemHandleUnlock (hndPasswdChars);
  577.   }
  578.   return sPassword;
  579. }
  580.