Return to tlsdll.c CVS log

Up to [WindowsNT SDKs] / mstools / samples / tls

Annotation of mstools/samples/tls/tlsdll.c, revision 1.1

1.1     ! root        1: #include "windows.h"
        !             2: #include "stdlib.h"
        !             3: #include "string.h"
        !             4: #include "stdio.h"
        !             5: #include "tlsdll.h"
        !             6: 
        !             7: #define TLS_MINIMUM_AVAILABLE 64
        !             8: 
        !             9: DWORD TlsIndex;        /* Global TLS index */
        !            10: int TlsCount=0;        /* a counter for data in TLS storage */
        !            11: char chTlsCount[3];    /* string for counter values */
        !            12: 
        !            13: /*-----------------------------------------------------------------*/
        !            14: 
        !            15: void ErrorOut(char errstring[30])
        !            16: /*
        !            17: Purpose: Print out an meainful error code by means of
        !            18:          GetLastError and printf
        !            19: 
        !            20: Inputs:  errstring - the action that failed, passed by the
        !            21:                      calling proc.
        !            22: 
        !            23: Returns: none
        !            24: 
        !            25: Calls:   GetLastError
        !            26: */
        !            27: 
        !            28: {
        !            29: DWORD Error;
        !            30: 
        !            31: Error= GetLastError();
        !            32: printf("Error on %s = %d\n", errstring, Error);
        !            33: }
        !            34: 
        !            35: /*-----------------------------------------------------------------*/
        !            36: 
        !            37: INT  APIENTRY LibMain(HANDLE hInst, ULONG ul_reason_being_called, LPVOID lpReserved)
        !            38: 
        !            39: /*
        !            40: Purpose: Is called by LibEntry, upon entering a dll or detaching
        !            41:          from a DLL.  This function does most of the TLS manipulation.
        !            42: 
        !            43: Inputs:  hInst - not used
        !            44:          ul_reason_being_called - reason LibMain is called
        !            45: 
        !            46: 
        !            47: Returns: N/A
        !            48: 
        !            49: Calls:   TlsAlloc - allocate a TLS index
        !            50:          malloc - allocate space for tls storage
        !            51:          TlsSetValue - Store TLS values
        !            52:          TlsFree - free TLS index
        !            53:          TlsRetreive - retreives TLS values, based on index
        !            54: */
        !            55: 
        !            56: {
        !            57: 
        !            58: LPVOID TlsString;  /* TLS string for storage */
        !            59: 
        !            60: 
        !            61: UNREFERENCED_PARAMETER(hInst);
        !            62: UNREFERENCED_PARAMETER(lpReserved);
        !            63: 
        !            64: switch (ul_reason_being_called)
        !            65:   {
        !            66:   case DLL_PROCESS_ATTACH:           /* process attaches         */
        !            67:     printf("Process Attaching\n");
        !            68:     TlsIndex= TlsAlloc();            /* create TLS index         */
        !            69:     if (TlsIndex == 0xFFFFFFFF)
        !            70:       ErrorOut("TlsAlloc");
        !            71:     break;
        !            72: 
        !            73:   case DLL_THREAD_ATTACH:            /* thread attaches          */
        !            74:     if (!(DLL_PROCESS_ATTACH & ul_reason_being_called))
        !            75:     {
        !            76:     printf("Thread Attaching\n");
        !            77:     TlsCount++;
        !            78:     TlsString= malloc(100);          /* allocate storage         */
        !            79:     strcat(TlsString, "Tls Thread#");/* build -                  */
        !            80:     strcat(TlsString,
        !            81:           itoa(TlsCount, chTlsCount,
        !            82:           10) );                    /* - string                 */
        !            83:     if (TlsSetValue(TlsIndex,        /* set TLS value            */
        !            84:                    TlsString))
        !            85:       printf("TlsSetValue success\n\n");
        !            86:     else
        !            87:       ErrorOut("TlsSetValue");
        !            88:     }
        !            89:     else
        !            90:       printf("Process & Thread attaching\n\n");
        !            91:     break;
        !            92: 
        !            93:   case DLL_THREAD_DETACH:            /* thread detaches          */
        !            94:     printf("Thread Detaching\n");
        !            95:     TlsRetreive(TlsIndex);           /* retreive TLS data        */
        !            96:     break;
        !            97: 
        !            98:   case DLL_PROCESS_DETACH:           /* process detaches         */
        !            99:     printf("Process Detaching\n");
        !           100:     if (!TlsFree(TlsIndex))          /* free TLS index           */
        !           101:       ErrorOut("TlsFree");
        !           102:     else
        !           103:       printf("TlsIndex Freed\n");
        !           104:     break;
        !           105: 
        !           106: 
        !           107:   default:
        !           108:     break;
        !           109:   }
        !           110: 
        !           111: return 1;
        !           112: }
        !           113: 
        !           114: /****************************************************************************/
        !           115: 
        !           116: INT APIENTRY TlsInit()
        !           117: 
        !           118: /*
        !           119: Purpose: Allow LibMain to be executed for each thread
        !           120: 
        !           121: Inputs:  none
        !           122: 
        !           123: Returns: none
        !           124: 
        !           125: Calls:   none
        !           126: */
        !           127: 
        !           128: {
        !           129: return 1;
        !           130: }
        !           131: 
        !           132: /****************************************************************************/
        !           133: 
        !           134: INT APIENTRY TlsRetreive(DWORD TlsIndex)
        !           135: 
        !           136: /*
        !           137: Purpose: Retreive TLS values and display (printf) them
        !           138: 
        !           139: Inputs:  TlsIndex - TLS index value
        !           140: 
        !           141: Returns: none
        !           142: 
        !           143: Calls:   TlsGetValue - Gets the TLS value from the index
        !           144:                        based on the current thread.
        !           145: */
        !           146: 
        !           147: {
        !           148: LPVOID tlsvals;
        !           149: 
        !           150: (LPVOID)tlsvals= TlsGetValue(TlsIndex);   /* get the TLS value */
        !           151: if (tlsvals == 0)
        !           152:   ErrorOut("TlsGetValue");
        !           153: else
        !           154:   printf("tls value=  %s\n\n", tlsvals ); /* output it         */
        !           155: return 1;
        !           156: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.