开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 查看源码
Primec.c
资源名称：COM+编程技术内幕(源码).rar　[点击查看]
上传用户：bjlvip
上传日期：2010-02-08
资源大小：744k
文件大小：19k
源码类别：

Windows编程

开发平台：

Visual C++

Primec.c：源码内容
  1. #include <STDIO.H>
  2. #include <LIMITS.H>
  3. #include <WINDOWS.H>
  4. #include "directio.h"
  5. #include "Serverprime.h"
  7. /* If we found a prime then return PRIME, otherwise return NOT_PRIME */
  9. #define PRIME           1
  10. #define NOT_PRIME       0
  12. /* Coordinates for displaying numbers to be tested */
  14. #define TESTING_X1      3
  15. #define TESTING_Y1      3
  16. #define TESTING_X2     23
  17. #define TESTING_Y2     18
  19. /* Coordinates for displaying prime numbers */
  21. #define PRIME_X1       30
  22. #define PRIME_Y1        3
  23. #define PRIME_X2       50
  24. #define PRIME_Y2       18
  26. #define ERROR_EXIT      2
  27. #define SUCCESS_EXIT    0
  28. #define STRING_LENGTH 256
  30. /* Delay time in microseconds */
  32. #define WAIT          350
  33. #define WAIT_DISPLAY 2000
  35. /* Colors used in this application */
  37. #define WHITE_ON_BLUE FOREGROUND_WHITE|FOREGROUND_INTENSITY|BACKGROUND_BLUE
  38. #define WHITE_ON_CYAN FOREGROUND_WHITE|FOREGROUND_INTENSITY|BACKGROUND_CYAN
  39. #define RED_ON_BLUE   FOREGROUND_RED|FOREGROUND_INTENSITY|BACKGROUND_BLUE
  40. #define RED_ON_CYAN   FOREGROUND_RED|FOREGROUND_INTENSITY|BACKGROUND_CYAN
  41. #define CYAN_ON_CYAN  FOREGROUND_CYAN|BACKGROUND_CYAN
  42. #define BLUE_ON_CYAN  FOREGROUND_BLUE|FOREGROUND_INTENSITY|BACKGROUND_CYAN
  44. /* Max number of threads for this application */
  46. #define MAX_THREADS      15
  47. #define COMP_NAME_LENGTH 7
  49. int NumThreads;
  51. /* Prototypes of functions used in this application */
  53. unsigned char IsPrime(unsigned long TestNumber);
  54. extern char ServerStatus(char);
  55. extern void thread_local(void);
  56. extern void thread_remote(int count);
  57. extern void Usage(void);
  58. extern void InitializeApplication(void);
  59. extern void NotifyServer(char);
  60. extern void thread_client(void);
  61. char IsActiveServer[MAX_THREADS];
  63. DWORD  lpIDThreadClient;
  64. HANDLE hthread_client;
  66. /* Critical Section for choosing next available number for testing */
  68. CRITICAL_SECTION GlobalCriticalSection;
  70. /* Storage for Computer Name */
  72. char computer_name_buffer[MAX_COMPUTERNAME_LENGTH];
  74. /* Unique number returned by the server */
  76. unsigned long PrimeServerHandle[MAX_THREADS];
  78. /*
  79. NextNumber    - Next available number to test
  80. StartTime     - Time that we start to compute primes
  81. CurrTime      - Current Computer time
  82. NoPrimeLocal  - Number of primes computed locally
  83. NoPrimeRemote - Number of primes computed on the remote computer
  84. StartNumber   - The starting number for testing primes
  85. */
  87. unsigned long NextNumber = 1, StartTime, CurrTime, NoPrimeLocal,
  88.    NoPrimeRemoteT, StartNumber = 1;
  90. handle_t BindingHandle[MAX_THREADS];
  91. unsigned long NoPrimeRemote[MAX_THREADS];
  93. PCONTEXT_HANDLE_TYPE phContext[MAX_THREADS];
  95. int ipszNetAdd = 0;
  97. RPC_NS_HANDLE ImportContext;
  99. unsigned char pszRemoteName[MAX_THREADS][MAX_COMPUTERNAME_LENGTH];
  101. #define REMOTE_TRY 100
  103. unsigned char Notry[MAX_THREADS];
  105. void main(int argc, char **argv)
  106.    {
  107.    RPC_STATUS status; /* returned by RPC API function */
  109.    unsigned char *pszUuid                          = NULL;
  110.    unsigned char *pszProtocolSequence              = "ncacn_np";
  111.    unsigned char *pszNetworkAddress[MAX_THREADS]   = { NULL };
  112.    unsigned char *pszEndpoint[MAX_THREADS]         =
  113.       {
  114.       "\pipe\prime", "\pipe\prime", "\pipe\prime", "\pipe\prime",
  115.       "\pipe\prime", "\pipe\prime", "\pipe\prime", "\pipe\prime",
  116.       "\pipe\prime"
  117.       };
  118.    unsigned char *pszOptions                       = NULL;
  119.    unsigned char *pszStringBinding[MAX_THREADS]    = { NULL };
  121.    DWORD  Max_ComputerName_Length = MAX_COMPUTERNAME_LENGTH;
  122.    DWORD  lpIDThread[MAX_THREADS];
  123.    HANDLE hthread_remote[MAX_THREADS];
  125.    int count;
  127.    /* Allow the user to override settings with command line switches */
  129.    for(count = 1; count < argc; count++)
  130.       {
  131.       if((*argv[count] == '-') || (*argv[count] == '/'))
  132.          {
  133.          switch(tolower(*(argv[count]+1)))
  134.             {
  135.             case 'p': /* protocol sequence */
  136.                pszProtocolSequence = argv[++count];
  137.                break;
  139.             case 'n': /* network address */
  140.                {
  141.                char tokensep[] = " t,;", *token;
  142.                token = strtok(argv[++count], tokensep);
  144.                while(token != NULL)
  145.                   {
  146.                   pszNetworkAddress[ipszNetAdd] = token;
  147.                   token = strtok(NULL, tokensep);
  148.                   strcpy(pszRemoteName[ipszNetAdd],
  149.                      strupr(&pszNetworkAddress[ipszNetAdd][2]));
  150.                   pszRemoteName[ipszNetAdd][COMP_NAME_LENGTH] = 0;
  151.                   ipszNetAdd++;
  152.                   }
  153.                }
  154.                break;
  156.             case 'e':
  157.                {
  158.                char tokensep[] = " t,;", *token;
  159.                token =strtok(argv[++count], tokensep);
  161.                while(token != NULL)
  162.                   {
  163.                   pszEndpoint[ipszNetAdd] = token;
  164.                   token = strtok(NULL, tokensep);
  165.                   ipszNetAdd++;
  166.                   }
  167.                }
  168.                break;
  170.             case 'o':
  171.                pszOptions = argv[++count];
  172.                break;
  174.             case 'f': /* first number */
  175.                NextNumber = StartNumber = atol(argv[++count]);
  176.                break;
  178.             case 't': /* number of threads */
  179.                NumThreads = atoi(argv[++count]);
  180.                if(NumThreads > MAX_THREADS)
  181.                   NumThreads = MAX_THREADS;
  182.                break;
  184.             case 'h':
  185.             case '?':
  186.             default:
  187.                Usage();
  188.             }
  189.          }
  190.       else
  191.          Usage();
  192.       }
  194.    if(pszNetworkAddress)
  195.       {
  196.       int i;
  198.       /*
  199.       Use a convenience function to concatenate the elements of
  200.       the string binding into the proper sequence
  201.       */
  203.       for(i = 0; i < ipszNetAdd; i++)
  204.          {
  205.          status = RpcStringBindingCompose(
  206.             pszUuid,
  207.             pszProtocolSequence,
  208.             pszNetworkAddress[i],
  209.             pszEndpoint[i],
  210.             pszOptions,
  211.             &pszStringBinding[i]);
  213.          if(status)
  214.             exit(ERROR_EXIT);
  215.          }
  217.       /* Set the binding handle that will be used to bind to the server */
  219.       for(i = 0; i < ipszNetAdd; i++)
  220.          {
  221.          status = RpcBindingFromStringBinding(pszStringBinding[i],
  222.             &BindingHandle[i]);
  224.          if(status)
  225.             exit(ERROR_EXIT);
  226.          }
  227.       }
  229.    GetComputerName(computer_name_buffer, &Max_ComputerName_Length);
  231.    InitializeCriticalSection(&GlobalCriticalSection);
  233.       {
  234.       char i;
  236.       for(i = 0; i < ipszNetAdd; i++)
  237.          ServerStatus(i);
  238.       }
  240.    for(count = 1; count <= ipszNetAdd ; count++)
  241.        hthread_remote[count-1] = CreateThread(NULL, 0,
  242.           (LPTHREAD_START_ROUTINE)thread_remote, (LPVOID)count, 0,
  243.           &lpIDThread[count-1]);
  245.    InitializeApplication();
  247.    hthread_client = CreateThread(NULL, 0,
  248.       (LPTHREAD_START_ROUTINE)thread_client, NULL,
  249.       CREATE_SUSPENDED, &lpIDThreadClient);
  251.    SetThreadPriority(hthread_client, THREAD_PRIORITY_NORMAL);
  252.    ResumeThread(hthread_client);
  253.    thread_local();
  254.    DeleteCriticalSection(&GlobalCriticalSection);
  256.    /*
  257.    The calls to the remote procedures are complete
  258.    Free the string and the binding handle
  259.    */
  261.    /* remote calls done - unbind */
  263.    if(pszNetworkAddress)
  264.       {
  265.       int i;
  267.       for(i = 0; i < ipszNetAdd; i++)
  268.          {
  269.          status = RpcStringFree(&pszStringBinding[i]);
  271.          if(status)
  272.             exit(ERROR_EXIT);
  273.          }
  274.       }
  276.    exit(SUCCESS_EXIT);
  277.    }
  279. void thread_local(void)
  280.    {
  281.    unsigned long temp;
  282.    char Buffer[STRING_LENGTH];
  283.    int loop;
  285.    SMALL_RECT psrctScrollRectTesting, psrctScrollRectPrime;
  286.    COORD coordDestOriginTesting, coordDestOriginPrime;
  287.    CHAR_INFO pchiFill;
  288.    WORD Color[TESTING_X2-TESTING_X1-3], Normal[TESTING_X2-TESTING_X1-3];
  290.    COORD ComputTestCoord;
  291.    COORD ComputPrimeCoord;
  293.    DWORD dummy;
  294.    COORD PrimeCoord;
  296.    psrctScrollRectTesting.Left   = TESTING_X1+1;
  297.    psrctScrollRectTesting.Top    = TESTING_Y1+2;
  298.    psrctScrollRectTesting.Right  = TESTING_X2-1;
  299.    psrctScrollRectTesting.Bottom = TESTING_Y2-1;
  301.    coordDestOriginTesting.X = TESTING_X1+1;
  302.    coordDestOriginTesting.Y = TESTING_Y1+1;
  304.    psrctScrollRectPrime.Left   = PRIME_X1+1;
  305.    psrctScrollRectPrime.Top    = PRIME_Y1+2;
  306.    psrctScrollRectPrime.Right  = PRIME_X2-1;
  307.    psrctScrollRectPrime.Bottom = PRIME_Y2-1;
  309.    coordDestOriginPrime.X = PRIME_X1+1;
  310.    coordDestOriginPrime.Y = PRIME_Y1+1;
  312.    pchiFill.Char.AsciiChar = (char)32;
  313.    pchiFill.Attributes = WHITE_ON_BLUE;
  315.    ComputTestCoord.X  = TESTING_X2-7;
  316.    ComputTestCoord.Y  = TESTING_Y2-1;
  317.    ComputPrimeCoord.X = PRIME_X2-7;
  318.    ComputPrimeCoord.Y = PRIME_Y2-1;
  320.    for(loop = 0; loop < TESTING_X2-TESTING_X1-3; loop++)
  321.       {
  322.       Color[loop]  = RED_ON_BLUE;
  323.       Normal[loop] = WHITE_ON_BLUE;
  324.       }
  326.    while(1)
  327.       {
  328.       EnterCriticalSection(&GlobalCriticalSection);
  329.       if((temp = ++NextNumber) >= ULONG_MAX)
  330.          break;
  331.       LeaveCriticalSection(&GlobalCriticalSection);
  333.       EnterCriticalSection(&GlobalCriticalSection);
  334.       ScrollConsoleScreenBuffer(hStdOut, &psrctScrollRectTesting, NULL,
  335.          coordDestOriginTesting, &pchiFill);
  336.       sprintf(Buffer, "%d", temp - 1);
  337.       mxyputs((unsigned char)TESTING_X1+2, (unsigned char)(TESTING_Y2-1),
  338.          Buffer, WHITE_ON_BLUE);
  339.       WriteConsoleOutputAttribute(hStdOut, Normal, 7, ComputTestCoord,
  340.          &dummy);
  341.       mxyputs((unsigned char)(TESTING_X2-7), (unsigned char)TESTING_Y2-1,
  342.          "LOCAL ", WHITE_ON_BLUE);
  343.       LeaveCriticalSection(&GlobalCriticalSection);
  345.       if(IsPrime(temp - 1) != 0)
  346.          {
  347.          PrimeCoord.X = PRIME_X1 + 2;
  348.          PrimeCoord.Y = PRIME_Y2 - 1;
  350.          EnterCriticalSection(&GlobalCriticalSection);
  351.          ScrollConsoleScreenBuffer(hStdOut, &psrctScrollRectPrime, NULL,
  352.             coordDestOriginPrime, &pchiFill);
  353.          sprintf(Buffer, "%-17d", temp - 1);
  354.          mxyputs((unsigned char)(PRIME_X1+2), (unsigned char)PRIME_Y2-1,
  355.             Buffer, WHITE_ON_BLUE);
  356.          WriteConsoleOutputAttribute(hStdOut, Normal, 7, ComputPrimeCoord,
  357.             &dummy);
  358.          mxyputs((unsigned char)(PRIME_X2-7), (unsigned char)PRIME_Y2-1,
  359.             "LOCAL ", WHITE_ON_BLUE);
  360.          LeaveCriticalSection(&GlobalCriticalSection);
  361.          NoPrimeLocal++;
  362.          }
  363.       }
  364.    }
  366. void thread_remote(int count)
  367.    {
  368.    unsigned long temp;
  369.    char Buffer[STRING_LENGTH];
  370.    int loop;
  372.    SMALL_RECT psrctScrollRectTesting, psrctScrollRectPrime;
  373.    COORD coordDestOriginTesting, coordDestOriginPrime;
  374.    CHAR_INFO pchiFill;
  375.    WORD Color[TESTING_X2-TESTING_X1-3], Normal[TESTING_X2-TESTING_X1-3];
  377.    COORD ComputTestCoord;
  378.    COORD ComputPrimeCoord;
  380.    DWORD dummy;
  381.    COORD PrimeCoord;
  383.    psrctScrollRectTesting.Left   = TESTING_X1+1;
  384.    psrctScrollRectTesting.Top    = TESTING_Y1+2;
  385.    psrctScrollRectTesting.Right  = TESTING_X2-1;
  386.    psrctScrollRectTesting.Bottom = TESTING_Y2-1;
  388.    coordDestOriginTesting.X = TESTING_X1+1;
  389.    coordDestOriginTesting.Y = TESTING_Y1+1;
  391.    psrctScrollRectPrime.Left   = PRIME_X1+1;
  392.    psrctScrollRectPrime.Top    = PRIME_Y1+2;
  393.    psrctScrollRectPrime.Right  = PRIME_X2-1;
  394.    psrctScrollRectPrime.Bottom = PRIME_Y2-1;
  396.    coordDestOriginPrime.X = PRIME_X1+1;
  397.    coordDestOriginPrime.Y = PRIME_Y1+1;
  399.    pchiFill.Char.AsciiChar = (char)32;
  400.    pchiFill.Attributes = WHITE_ON_BLUE;
  402.    ComputTestCoord.X  = TESTING_X2-7;
  403.    ComputTestCoord.Y  = TESTING_Y2-1;
  404.    ComputPrimeCoord.X = PRIME_X2-7;
  405.    ComputPrimeCoord.Y = PRIME_Y2-1;
  407.    for(loop = 0; loop < TESTING_X2-TESTING_X1-3; loop++)
  408.       {
  409.       Color[loop]  = RED_ON_BLUE;
  410.       Normal[loop] = WHITE_ON_BLUE;
  411.       }
  413.    while(1)
  414.       {
  415.       if(!IsActiveServer[count-1])
  416.          {
  417.          if(Notry[count-1]++ > REMOTE_TRY)
  418.             {  
  419.             Notry[count - 1] = 0;
  420.             EnterCriticalSection(&GlobalCriticalSection);
  421.              ServerStatus((char)(count - 1));
  422.             LeaveCriticalSection(&GlobalCriticalSection);
  423.             }
  424.          else        
  425.             continue;
  426.          }   
  427.       if(!IsActiveServer[count-1])
  428.          continue;       
  430. /* To make sure that we won't test the same number twice */
  432.       EnterCriticalSection(&GlobalCriticalSection);
  433.       if((temp = ++NextNumber) >= ULONG_MAX)
  434.          break;
  435.       LeaveCriticalSection(&GlobalCriticalSection);
  437.       EnterCriticalSection(&GlobalCriticalSection);
  438.       ScrollConsoleScreenBuffer(hStdOut, &psrctScrollRectTesting, NULL,
  439.          coordDestOriginTesting, &pchiFill);
  440.       sprintf(Buffer, " %-17d", temp - 1);
  441.       mxyputs((unsigned char)TESTING_X1+1, (unsigned char)(TESTING_Y2-1),
  442.          Buffer, RED_ON_BLUE);
  443.       WriteConsoleOutputAttribute(hStdOut, Color, 7, ComputTestCoord,
  444.          &dummy);
  445.       mxyputs((unsigned char)(TESTING_X2-7), (unsigned char)TESTING_Y2-1,
  446.          pszRemoteName[count-1], RED_ON_BLUE);
  447.       LeaveCriticalSection(&GlobalCriticalSection);
  449.       RpcTryExcept
  450.          {
  451.          if(RemoteIsPrime(BindingHandle[count-1], PrimeServerHandle[count-1],
  452.             temp - 1) != 0)
  453.             {
  454.             EnterCriticalSection(&GlobalCriticalSection);
  455.             PrimeCoord.X = TESTING_X1 + 2;
  456.             LeaveCriticalSection(&GlobalCriticalSection);
  458.             PrimeCoord.X = PRIME_X1 + 2;
  459.             PrimeCoord.Y = PRIME_Y2 - 1;
  461.             EnterCriticalSection(&GlobalCriticalSection);
  462.             ScrollConsoleScreenBuffer(hStdOut, &psrctScrollRectPrime, NULL,
  463.                coordDestOriginPrime, &pchiFill);
  464.             sprintf(Buffer, " %-17d", temp - 1);
  465.             mxyputs((unsigned char)(PRIME_X1+1), (unsigned char)PRIME_Y2-1,
  466.                Buffer, RED_ON_BLUE);
  467.             WriteConsoleOutputAttribute(hStdOut, Color, 7, ComputPrimeCoord,
  468.                &dummy);
  469.             mxyputs((unsigned char)(PRIME_X2-7), (unsigned char)PRIME_Y2-1,
  470.                pszRemoteName[count-1], RED_ON_BLUE);
  471.             LeaveCriticalSection(&GlobalCriticalSection);
  472.                NoPrimeRemote[count-1]++;
  473.             NoPrimeRemoteT++;
  474.             }
  475.          }
  476.       RpcExcept(1)
  477.          {
  478.          /* if exceptions occurs */
  480.          EnterCriticalSection(&GlobalCriticalSection);
  481.          ServerStatus((char)(count - 1));
  482.          LeaveCriticalSection(&GlobalCriticalSection);
  483.          }
  484.       RpcEndExcept
  485.       }
  486.    }
  488. /* Tests for prime number on the local computer */
  490. unsigned char IsPrime(unsigned long TestNumber)
  491.    {
  492.    unsigned long count;
  493.    unsigned long HalfNumber = TestNumber / 2 + 1;
  495.    for(count = 2; count < HalfNumber; count++)
  496.       if(TestNumber % count == 0)
  497.          return NOT_PRIME;
  499.    return PRIME;
  500.    }
  502. /* Displays command line options */
  504. void Usage(void)
  505.    {
  506.    printf("nDistributed client/server prime number example.nn");
  507.    printf("Usage: PRIMEn");
  508.    printf(" -p protocol_sequencen");
  509.    printf(" -n network_addressn");
  510.    printf(" -e endpointn");
  511.    printf(" -o optionsn");
  512.    printf(" -f first numbern");
  513.    exit(1);
  514.    }
  516. /* Screen Initialization and colors and title lines */
  518. void InitializeApplication(void)
  519.    {
  520.    set_vid_mem();
  522.    clearscreen(BACKGROUND_CYAN);
  523.    StartTime = GetTickCount();
  525.    box(0, 0, 79, 24, DOUBLE);
  526.    mxyputs(37, 0, " PRIMEC ", WHITE_ON_CYAN);
  528.    mxyputs(TESTING_X1, 2, "Testing...", WHITE_ON_CYAN);
  529.    box(TESTING_X1, TESTING_Y1, TESTING_X2, TESTING_Y2, SINGLE);
  531.    mxyputs(PRIME_X1, 2, "Prime!",WHITE_ON_CYAN);
  532.    box(PRIME_X1, PRIME_Y1, PRIME_X2, PRIME_Y2, SINGLE);
  533.    mxyputs(32, 23, "Press Esc to exit", WHITE_ON_CYAN);
  534.    }
  536. /*
  537.    Check the Server status if it is of line, then try to connect, return
  538.    server status
  539. */
  541. char ServerStatus(char iserver)
  542.    {
  543.    char value = FALSE;
  545.    RpcTryExcept
  546.       {
  547.       PrimeServerHandle[iserver] = InitializePrimeServer(
  548.          BindingHandle[iserver], &phContext[iserver], computer_name_buffer);
  549.       IsActiveServer[iserver] = TRUE;
  550.       }      
  551.    RpcExcept(1)
  552.       {
  553.       value = TRUE;
  554.       IsActiveServer[iserver] = FALSE;
  555.       }
  556.    RpcEndExcept
  558.    return value;
  559.    }
  561. /* Let the Server know that we are about to exit */
  563. void NotifyServer(char iserver)
  564.    {
  565.    RpcTryExcept
  566.       {
  567.       TerminatePrimeServer(BindingHandle[iserver],
  568.          PrimeServerHandle[iserver]);
  569.       }
  570.    RpcExcept(1)
  571.       {
  572.       return;
  573.       }
  574.    RpcEndExcept
  575.    }
  577. void thread_client()
  578.    {
  579.    unsigned char no_active =0;
  581.    while(1)
  582.       {
  583.       char Buffer[STRING_LENGTH];
  584.       int  i;
  586.       if(VK_ESCAPE == get_character_no_wait())
  587.          {
  588.          EnterCriticalSection(&GlobalCriticalSection);
  589.          Sleep(WAIT);
  590.          for(i = 0;i < ipszNetAdd; i++)
  591.             NotifyServer((char)i);
  592.          clearscreen(0);
  593.          exit(0);
  594.          LeaveCriticalSection(&GlobalCriticalSection);
  595.          }
  597.       mxyputs(58, 2, "Number of Primes", WHITE_ON_CYAN);
  598.       sprintf(Buffer, "%s:%5d", "LOCAL  ", NoPrimeLocal);
  599.       mxyputs((unsigned char)(60), (unsigned char)(4), Buffer,
  600.          WHITE_ON_CYAN);
  601.          {
  602.          no_active = 0;
  603.          EnterCriticalSection(&GlobalCriticalSection);
  604.          for(i = 0; i < ipszNetAdd; i++)
  605.             if(IsActiveServer[i])
  606.                {
  607.                sprintf(Buffer, " %7s:%5d ", pszRemoteName[i],
  608.                   NoPrimeRemote[i]);
  609.                mxyputs(59, (unsigned char)(4+1+no_active), Buffer,
  610.                   RED_ON_CYAN);
  611.                no_active++;
  612.                }
  613.          box(58, 3, 74, (unsigned char)(5 + no_active), SINGLE);
  614.          mxyputc(58, (unsigned char)(6 + no_active), (char)32, 17,
  615.             CYAN_ON_CYAN);
  616.          }
  618.       no_active = 0;
  619.       for(i = 0; i < ipszNetAdd; i++)
  620.          if(!IsActiveServer[i])
  621.             {
  622.             sprintf(Buffer, " %7s:%5d ", pszRemoteName[i], NoPrimeRemote[i]);
  623.             mxyputs(59, (unsigned char)(4+15+no_active), Buffer,
  624.                RED_ON_CYAN);
  625.             no_active ++;
  626.             }
  628.       if(no_active)
  629.          {
  630.          mxyputs(58, (unsigned char)(17), "Inactive Servers",
  631.             WHITE_ON_CYAN);
  632.          box(58, (unsigned char)(18), 74, (unsigned char)(19 + no_active),
  633.             SINGLE);
  634.          mxyputc(58, (unsigned char)(20 + no_active), (char)32, 17,
  635.             CYAN_ON_CYAN);
  636.          }
  637.       else
  638.          for(i = 0; i < 5; i++)
  639.             mxyputc(58, (unsigned char)(17 + no_active + i), (char)32, 17,
  640.                CYAN_ON_CYAN);
  642.       LeaveCriticalSection(&GlobalCriticalSection);
  643.       CurrTime = (GetTickCount() - StartTime) / 1000;
  644.       sprintf(Buffer, "Primes = %d", NoPrimeLocal + NoPrimeRemoteT);
  645.       mxyputs(58, (unsigned char)(7 + ipszNetAdd), Buffer, WHITE_ON_CYAN);
  646.       sprintf(Buffer, "Time = %d.%02d min.", CurrTime/60, CurrTime%60);
  647.       mxyputs(58, (unsigned char)(8 + ipszNetAdd), Buffer, WHITE_ON_CYAN);
  649.       sprintf(Buffer,"First = %d", StartNumber);
  650.       mxyputs(58,(unsigned char)(1+5+3+ipszNetAdd), Buffer, WHITE_ON_CYAN);
  651.       }
  652.    }
  654. void __RPC_FAR * __RPC_USER midl_user_allocate(size_t len)
  655. {
  656.     return(malloc(len));
  657. }
  659. void __RPC_USER midl_user_free(void __RPC_FAR * ptr)
  660. {
  661.     free(ptr);
  662. }