home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 11 Util / 11-Util.zip / kbstuf.zip / STUFFER / STUFFER.C < prev    next >
C/C++ Source or Header  |  1993-08-22  |  9KB  |  260 lines
  1. /*******************************************************************************
  2.  
  3.  File Name       : STUFFER.C
  4.  Job Name        : KbStuffer
  5.  Program Name    : Stuffer.exe
  6.  Date Created    : February 15, 1993
  7.  Description     : Sample File To Stuff KeyStokes Into The Keyboard Buffer Via
  8.                    KbStuffer.
  9.  
  10.                    In Order To Send Information To KbStuffer:
  11.                        1 - Attach To Shared Memory And Semaphores
  12.                        2 - Put Data Into Shared Memory
  13.  
  14.                     To Attach To Shared Memory:
  15.                        1 - Open The Shared Memory InUse Semaphore
  16.                        2 - Open The Shared Memory DataWaiting Semaphore
  17.                        3 - Wait For InUse Semaphore To Clear Signaling Shared
  18.                            Memory Has Been Created.
  19.                        4 - Get The Address Of KbStuffer's Shared Memory
  20.                        5 - Turn Shared Memory's Address Into A Pointer
  21.  
  22.                    To Place Data Into KbStuffer's Shared Memory:
  23.                        1 - Get Id Of Keyboard Buffer Session To Stuff
  24.                        2 - Wait For Shared Memory To Be Cleared
  25.                            - In Use Semaphore
  26.                        3 - Place Data Into KbStuffer Shared Memory
  27.                        4 - Clear InUse Semaphore
  28.  
  29.  
  30.                    KbStuffer's Shared Memory In Use Semaphore
  31.                        "/Sem/WLM/KbStuff/InUseSem."
  32.  
  33.                    KbStuffer's Shared Memory Data Waiting Semaphore
  34.                        "/Sem/WLM/KbStuff/DataWaitSem."
  35.  
  36.                    KbStuffer's Shared Memory
  37.                        "/ShareMem/WLM/KbStuff/Buffer."
  38.  
  39.  
  40.  Routines        : main() - Place Command Line KeyStroke Codes Into Keyboard Buffer
  41.                    SetupSharedMem() - Attach To KbStuffer Shared Memory And Semaphores
  42.                    StuffShrMemory() - Place Passed KeyStroke Codes Into KbStuffer's Shared Memory
  43.  
  44.  
  45. *******************************************************************************/
  46.  
  47. #define INCL_DOSINFOSEG
  48. #define INCL_DOSMEMMGR
  49. #define INCL_DOSSEMAPHORES
  50.  
  51. #include "os2.h"
  52. #include "string.h"
  53. #include "stdlib.h"
  54. #include "stdio.h"
  55. #include "Stuffer.h"
  56.  
  57. /*******************************************************************************
  58.  
  59.  Routine Name    : main()
  60.  Date Prepared   : February 15, 1993
  61.  Prepared By     : William L. Moussiaux
  62.  Inputs          : KeyStroke Codes To Stuff In Keyboard Buffer
  63.  Outputs         : TRUE/FALSE
  64.  Globals         : 
  65.  Description     : Place Command Line KeyStroke Codes Into Keyboard Buffer
  66.  
  67. *******************************************************************************/
  68. int main (int argc, char *argv[])
  69. {
  70. USHORT Result;
  71. char   chTmp[10];
  72. CHAR   *chShrMemData;
  73. int    ArgVar, i;
  74.  
  75. ScreenGroup = -1;                            /* -1 = Use Current OS/2 Session */
  76. ArgVar = 1;                         /* KeyStroke Data Is 1st Passed Parameter */
  77.  
  78. if (argc > 1)             /* Get Passed Arguments To Stuff To KeyBoard Buffer */
  79.    {
  80.    if (argv[1][0] == '/' || argv[1][0] == '-')
  81.        {                                 /* Get OS/2 Session To Stuff Data To */
  82.        i = 0;
  83.        do  {
  84.            chTmp[i] = argv[1][i + 1];
  85.            i ++;
  86.            } while (argv[1][i] != ' ' && argv[1][i] != '\0');
  87.  
  88.        ScreenGroup = atoi (chTmp);
  89.        ArgVar = 2;                  /* KeyStroke Data Is 2nd Passed Parameter */
  90.        }
  91.  
  92.    chShrMemData = (char *)malloc (SHARED_MEM_SIZE + 1);
  93.    if (chShrMemData == NULL)
  94.        {
  95.        printf ("ERROR - Allocating Memory For chShrMemData\n");
  96.        return (FALSE);
  97.        }
  98.  
  99.    strcpy (chShrMemData, argv[ArgVar]);                 /* Get KeyStroke Data */
  100.    }
  101.  
  102.  
  103. else
  104.    {
  105.    printf ("Must Pass Characters To Send To Keyboard Buffer\n");
  106.    return (FALSE);
  107.    }
  108.  
  109. /*----------------------------------------------------------------------------*/
  110.  
  111. Result = SetupSharedMem();               /* Open Semaphores And Shared Memory */
  112. if (Result == FALSE)
  113.    {
  114.    free (chShrMemData);                                        /* Free Memory */
  115.    return (FALSE);
  116.    }
  117.  
  118.  
  119. StuffShrMemory (chShrMemData);               /* Place Data Into Shared Memory */
  120. free (chShrMemData);                                           /* Free Memory */
  121.  
  122. return (TRUE);
  123. }
  124. /*******************************************************************************
  125.  
  126.  Routine Name    : SetupSharedMem()
  127.  Date Prepared   : February 15, 1993
  128.  Prepared By     : William L. Moussiaux
  129.  Inputs          : None
  130.  Outputs         : TRUE/FALSE
  131.  Globals         : CHAR FAR *SharedMemPtr
  132.                    HSEM semDataWaiting, semInUse
  133.  Description     : Attach To KbStuffer Shared Memory And Semaphores
  134.  
  135. *******************************************************************************/
  136. USHORT SetupSharedMem()
  137. {
  138. USHORT         Result;
  139. SEL            SharedMem;
  140.  
  141.                                         /* Open Shared Memory InUse Semaphore */
  142. Result = DosOpenSem (&semInUse, SEM_INUSE_NAME);
  143. if (Result != 0)
  144.    {
  145.    printf ("ERROR - Opening Shared Memory Semaphore %d\n", Result);
  146.    if (Result == 187)
  147.        printf ("KbStuffer May Not Be Running\n");
  148.  
  149.    return (FALSE);
  150.    }
  151.  
  152.                                   /* Open Shared Memory DataWaiting Semaphore */
  153. Result = DosOpenSem (&semDataWaiting, SEM_WAIT_NAME);
  154. if (Result != 0)
  155.    {
  156.    printf ("ERROR - Opening Data Waiting Semaphore %d\n", Result);
  157.    return (FALSE);
  158.    }
  159.  
  160.                                       /* Wait For Shared Memory To Be Created */
  161. Result = DosSemWait (semInUse, SEM_WAIT_TIME);
  162. if (Result != 0)
  163.    {
  164.    printf ("ERROR - Waiting For Shared Memory Semaphore %d\n", Result);
  165.    return (FALSE);
  166.    }
  167.  
  168.                                                  /* Get Shared Memory Address */
  169. Result = DosGetShrSeg (SHARED_MEM_NAME, &SharedMem);
  170. if (Result != 0)
  171.    {
  172.    printf ("ERROR - Getting Shared Memory Address %d\n", Result);
  173.    return (FALSE);
  174.    }
  175.  
  176.                                  /* Turn Shared Memory Address Into A Pointer */
  177. SharedMemPtr = (char far *)MAKEP (SharedMem, 0L);
  178.  
  179. return (TRUE);
  180. }
  181. /*******************************************************************************
  182.  
  183.  Routine Name    : StuffShrMemory()
  184.  Date Prepared   : February 15, 1993
  185.  Prepared By     : William L. Moussiaux
  186.  Inputs          : char * - Data To Be Placed In KbStuffer's Shared Memory
  187.  Outputs         : TRUE/FALSE
  188.  Globals         : CHAR FAR *SharedMemPtr
  189.                    HSEM semDataWaiting, semInUse
  190.  Description     : Place Passed KeyStroke Codes Into KbStuffer's Shared Memory
  191.  
  192. *******************************************************************************/
  193. USHORT StuffShrMemory (char *chShrMemData)
  194. {
  195. USHORT         Result;
  196. CHAR           *chBuffer, *TmpPtr;
  197. unsigned int   GlobalSeg, LocalSeg;
  198. LINFOSEG       far *lInfo;
  199.  
  200. chBuffer = (char *)malloc (SHARED_MEM_SIZE + 1);
  201. if (chBuffer == NULL)
  202.    {
  203.    printf ("ERROR - Allocating Memory For chBuffer\n");
  204.    return (FALSE);
  205.    }
  206.  
  207. /*----------------------------------------------------------------------------*/
  208.  
  209. if (ScreenGroup == -1)
  210.    {         /* OS/2 Session To Stuff Data To Not Passed, Use Current Session */
  211.    DosGetInfoSeg (&GlobalSeg, &LocalSeg);        /* Get Foreground Session Id */
  212.    lInfo = MAKEP (LocalSeg, 0);
  213.    ScreenGroup = lInfo->sgCurrent;
  214.    }
  215.  
  216.                        /* Put Session Id And Keys To Stuff Into Shared Memory */
  217. sprintf (chBuffer, "%u %s", ScreenGroup, chShrMemData);
  218. printf (chBuffer);
  219.  
  220. /*----------------------------------------------------------------------------*/
  221.                           /* Wait For KeyBoard Monitor To Clear Shared Memory */
  222. Result = DosSemRequest (semInUse, SEM_WAIT_TIME);
  223. if (Result != 0)
  224.    {
  225.    printf ("ERROR - Requesting Shared Memory Semaphore %d\n", Result);
  226.    free (chBuffer);                                            /* Free Memory */
  227.    return (FALSE);
  228.    }
  229.  
  230. /*----------------------------------------------------------------------------*/
  231.  
  232. TmpPtr = chBuffer;
  233. while (*TmpPtr)                          /* Copy Data To Shared Memory Buffer */
  234.    *SharedMemPtr ++ = *TmpPtr ++;
  235.  
  236. *SharedMemPtr = '\0';                                  /* Null Terminate Data */
  237.  
  238. /*----------------------------------------------------------------------------*/
  239.  
  240. Result = DosSemClear (semInUse);      /* Clear Shared Memory In Use Semaphore */
  241. if (Result != 0)
  242.    {
  243.    printf ("ERROR - Clearing InUse Semaphore %d\n", Result);
  244.    free (chBuffer);                                            /* Free Memory */
  245.    return (FALSE);
  246.    }
  247.  
  248. Result = DosSemClear (semDataWaiting);  /* Tell KeyBoard Monitor Data Waiting */
  249. if (Result != 0)
  250.    {
  251.    printf ("ERROR - Clearing Data Waiting Semaphore %d\n", Result);
  252.    free (chBuffer);                                            /* Free Memory */
  253.    return (FALSE);
  254.    }
  255.  
  256. free (chBuffer);                                               /* Free Memory */
  257. return (TRUE);
  258. }
  259.  
  260.