home *** CD-ROM | disk | FTP | other *** search
/ Stars of Shareware: Programmierung / SOURCE.mdf / programm / windows / c / recomm10 / recomsrv / recomsrv.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-10-12  |  12.7 KB  |  616 lines
  1. #define MAIN
  2. #define CFILES 
  3. #include "recomsrv.h"
  4. #include <dos.h>
  5.  
  6. #define WM_NB_RESPONSE WM_USER +2000 
  7.  
  8. #define WM_DEBUG WM_USER + 101
  9. BOOL IN_DEBUG = FALSE;
  10.  
  11. BOOL FAR __cdecl  SRV_DEBUG( UINT DebugNr, char huge *szFormat, ...)
  12. {
  13.     static char szBuffer[200];
  14.     HWND hDebug;
  15.     LPSTR pArgs;
  16.  
  17.     hDebug = FindWindow("HKR_DEBUG_WND", NULL);
  18.     if(hDebug == (HWND)NULL)
  19.     {
  20.         return FALSE;
  21.     }
  22.     if(IN_DEBUG == TRUE) return FALSE;
  23.     IN_DEBUG = TRUE;
  24.  
  25.     pArgs = (LPSTR)&szFormat + sizeof(szFormat);
  26.     wvsprintf( szBuffer, szFormat, pArgs );
  27.     SendMessage(hDebug, WM_DEBUG, DebugNr, (LPARAM)(LPSTR)szBuffer);
  28.  
  29.     IN_DEBUG = FALSE;
  30.     return TRUE;
  31. }
  32.  
  33. unsigned long tick, tack;  
  34.  
  35. char cmd[][10] = {  "CONNECT",
  36.                     "INICOM",
  37.                     "SETCOM",
  38.                     "SETQUE",
  39.                     "RECCOM",
  40.                     "SNDCOM",
  41.                     "CTX",
  42.                     "TRMCOM",
  43.                     "STACOM",
  44.                     "CEXTFCN", 
  45.                     "CFLUSH",
  46.                     "CEVT",
  47.                     "CEVTGET",
  48.                     "CSETBRK",
  49.                     "CCLRBRK",
  50.                     "GETDCB",
  51.                     "CWSTRING",
  52.                     "CRSTRING",
  53.                     "ENABLENOT", 
  54.                     "GETMASK", 
  55.                     "UNKWON" };
  56.                     
  57. #define SC (sizeof(comData) - sizeof(comData.a) +1)            
  58.                     
  59. int cmdsize[] = {   SC,    // CONNECT
  60.                     SC,    // INICOM
  61.                     SC,    // SETCOM
  62.                     SC,    // SETQUE
  63.                     SC + sizeof(comData.a.x), // RECCOM
  64.                     SC,   // SNDCOM
  65.                     SC,   // CTX
  66.                     SC,   // TRMCOM
  67.                     SC + sizeof(comData.a.cs), // STACOM
  68.                     SC,   // CEXTFCN
  69.                     SC,   // CFLUSH
  70.                     SC,      // CEVT
  71.                     SC,   // CEVTGET
  72.                     SC,   // CSETBRK
  73.                     SC,   // CCLRBRK
  74.                     SC + sizeof(comData.a.dcb), // GETDCB
  75.                     SC,      // CWSTRING
  76.                     SC,   // CRSTRING Σndert sich
  77.                     SC,   // ENABLENOTI
  78.                     SC,   // GETMASK
  79.                     SC };
  80.                     
  81. typedef struct {
  82.     BYTE cLSN;
  83.     BYTE cNum;
  84.     BYTE cGroupNum;
  85.     char szName[17];
  86.     char szCaller[17];
  87.     char hostname[30];
  88.     char hostini[144];
  89.     BYTE Adapter;    
  90.     
  91. } DATA, FAR * LPDATA;
  92.  
  93. DATA srvData;
  94.                     
  95.  
  96. BOOL FAR PASCAL AboutDlgProc(HWND hDlg, WORD message,
  97. WORD wParam, LONG lParam)
  98. {
  99.     switch (message)
  100.     {
  101.     case WM_INITDIALOG:  
  102.         return TRUE; 
  103.         
  104.     case WM_COMMAND:
  105.         switch(wParam)
  106.         {    
  107.             
  108.         case IDCANCEL:      
  109.         case IDOK:     
  110.             EndDialog(hDlg, wParam);
  111.             return TRUE;
  112.         }
  113.         break;
  114.     }
  115.     return FALSE;
  116. }       
  117. #pragma optimize( "", off)
  118.  
  119. void getNetBiosName(LPSTR name)
  120. {                 
  121.     register x, y;
  122.                 
  123.     extern void FAR PASCAL DOS3Call();
  124.  
  125.     x = _FP_SEG(name);
  126.     __asm mov ds, x;
  127.     y = _FP_OFF(name);
  128.     __asm mov dx, y;
  129.     __asm mov ah, 0x5e ;
  130.     __asm mov al, 0x00 ;
  131.     
  132.     DOS3Call();
  133. }
  134.  
  135. #pragma optimize( "", on)    
  136.  
  137. TelHangUp()
  138. {   
  139.     long tick;
  140.     
  141.     if(CONECTED == TRUE) 
  142.     {    
  143.         tick = GetTickCount();
  144.         FlushComm(com, 0);
  145.         FlushComm(com, 1);
  146.         
  147.         WriteComm(com, "+++\x0d\x0aATH\x0d\0aATZ\x0d\x0a       ", 15);
  148.         FlushComm(com, 0);
  149.         FlushComm(com, 1);
  150.         EscapeCommFunction(com, CLRDTR);
  151.         
  152.         while((tick - GetTickCount()) < 500) // 50 msec -> Modem legt auf
  153.         {
  154.             handleMessage();
  155.         }
  156.     }
  157. }
  158. handleMessage()
  159. {
  160.     MSG msg;
  161.     
  162.     while(PeekMessage(&msg, HwnD, 0, 0, PM_REMOVE))
  163.     {
  164.         if(msg.message == WM_QUIT) return FALSE;
  165.         
  166.         TranslateMessage(&msg);
  167.         DispatchMessage(&msg);
  168.     }   
  169.     return TRUE;
  170. }    
  171.     
  172. long FAR PASCAL WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
  173. {    
  174.     FARPROC lpfnDlgProc;
  175.     
  176.     int rc; 
  177.     char tmp[30];
  178.     char * c1;
  179.     
  180.     switch(msg)
  181.     {
  182.     case WM_NB_RESPONSE:
  183.         lpNCB = (LPNCB) lParam;
  184.         
  185.         if(lpNCB->cCmdCplt)
  186.         {
  187.             // SRV_DEBUG(DB_ACTION, "SERVER: NB_RESPONSE (0x%x)", lpNCB->cCmdCplt);
  188.             DestroyNCB(lpNCB);
  189.             KillTimer(hwnd, 1);
  190.             new_init();
  191.             return 0;
  192.         }
  193.         switch(lpNCB->cCommand & ~NO_WAIT)
  194.         {
  195.             case NETBIOS_LISTEN:
  196.                 srvData.cLSN = lpNCB->cLSN;
  197.                 _fmemcpy(srvData.szCaller, lpNCB->cCallName, MAX_NAME_SIZE);
  198.                 srvData.szCaller[MAX_NAME_SIZE] = '\0';
  199.                 
  200.                 if(sendAnswer() == FALSE)
  201.                 {
  202.                     new_init();
  203.                 }
  204.                 CONECTED = TRUE;                
  205.                     
  206.                 SetWindowText(hwnd, srvData.szCaller);
  207.                 
  208.                 KillTimer(hwnd, 1);
  209.                 SetTimer(hwnd, 1, 300, NULL);
  210.                                     
  211.                 tick = GetTickCount();
  212.                 ShowWindow(hwnd, SW_SHOWMINIMIZED);
  213.                                              
  214.                 // SRV_DEBUG(DB_ACTION, "SERVER: WAIT FOR CMD'S");                                             
  215.                                              
  216.                 // rc =  PostReceiveDatagram(srvData.Adapter, srvData.cNum, 
  217.                 //     (LPSTR)&comData, sizeof(comData), hwnd, WM_NB_RESPONSE, 0, &lpNCB);
  218.                      
  219.                 rc = PostReceive(srvData.Adapter, srvData.cLSN, 
  220.                      (LPSTR)&comData, sizeof(comData), hwnd, WM_NB_RESPONSE, 0, &lpNCB);
  221.                      
  222.                 if(rc != 0)
  223.                 {
  224.                     // SRV_DEBUG(DB_ACTION, "SERVER: LISTEN (0x%x)", rc);
  225.                 }    
  226.                 break;                     
  227.                 
  228.             case NETBIOS_RECEIVE_BROADCAST:
  229.             
  230.                 // SRV_DEBUG(DB_ACTION, "SERVER: I'M HERE");
  231.                 
  232.                 fndSrv.stat = CONECTED;
  233.                 wsprintf(fndSrv.name, "%s\t%s", 
  234.                     (LPSTR)srvData.szName, (LPSTR)srvData.hostname);
  235.                 
  236.                     
  237.                 rc = SendDatagram(WAIT_WND_MODAL, srvData.Adapter, srvData.cGroupNum, 
  238.                     lpNCB->cCallName,(LPSTR)&fndSrv, sizeof(fndSrv), HwnD);
  239.                 
  240.                 DestroyNCB(lpNCB);
  241.                 
  242.                 if(rc != 0)
  243.                 {
  244.                     // SRV_DEBUG(DB_ACTION, "SERVER: BROADCAST (0x%x)", rc);
  245.                 }                
  246.                     
  247.                 rc = PostReceiveBroadcast(srvData.Adapter, srvData.cGroupNum, 
  248.                       (LPSTR)&fndSrv, sizeof(fndSrv), HwnD, WM_NB_RESPONSE, 1, &brdNCB);
  249.  
  250.                 if(rc != 0)
  251.                 {
  252.                     // SRV_DEBUG(DB_ACTION, "SERVER: ANSWER BROADCAST (0x%x)", rc);
  253.                 }                
  254.                 // SRV_DEBUG(DB_ACTION, "SERVER: WAIT");
  255.                 return 0;                        
  256.         
  257.             
  258.             // case NETBIOS_RECEIVE_DATAGRAM:
  259.             case NETBIOS_RECEIVE:
  260.                 tick = GetTickCount();
  261.                 
  262.                 // SRV_DEBUG(DB_ACTION, "SERVER: CMD %d=%s ev=%d",comData.fnc, (LPSTR)cmd[comData.fnc], *lpevent);
  263.         
  264.                 DestroyNCB(lpNCB);
  265.         
  266.                 analizeMessage();
  267.                 
  268.                 // and wait again
  269.                 
  270.                 // rc = PostReceiveDatagram(srvData.Adapter, srvData.cNum, 
  271.                 //      (LPSTR)&comData, sizeof(comData), hwnd, WM_NB_RESPONSE, 0, &lpNCB);
  272.                 
  273.                 rc = PostReceive(srvData.Adapter, srvData.cLSN, 
  274.                      (LPSTR)&comData, sizeof(comData), hwnd, WM_NB_RESPONSE, 0, &lpNCB);
  275.                     
  276.                 // SRV_DEBUG(DB_ACTION, "SERVER: CMD DONE ev=%d", *lpevent);
  277.                 if(rc != 0)
  278.                 {
  279.                     // SRV_DEBUG(DB_ACTION, "SERVER: RECEIVE (0x%x)", rc);
  280.                 }                
  281.                 return 0;
  282.         }
  283.         DestroyNCB(lpNCB);
  284.         return 0;
  285.         
  286.     case WM_QUERYENDSESSION:
  287.         return 1;
  288.         
  289.     case WM_ENDSESSION:
  290.         CancelAllPending(hwnd);
  291.         DeleteName(WAIT_WND_MODAL, APPNAME, srvData.Adapter, hwnd);
  292.         DeleteName(WAIT_WND_MODAL, srvData.szName, srvData.Adapter, hwnd);
  293.         return 1;
  294.             
  295.     case WM_CREATE:
  296.         hInstance = ((LPCREATESTRUCT) lParam)->hInstance;  
  297.  
  298.         HwnD = hwnd;          
  299.         REMOTE_COM = 2;
  300.         lpevent = &event[0];
  301.         event[0] = evcnt = 0;
  302.         
  303.         CONECTED = FALSE;
  304.         srvData.Adapter = 0;
  305.         getNetBiosName(tmp);
  306.         wsprintf(srvData.szName, "RS_%12s", (LPSTR)tmp);
  307.         c1 = (srvData.szName + sizeof(srvData.szName) -1);
  308.         while(*c1 == ' ') *c1-- = '\0';
  309.         srvData.szName[sizeof(srvData.szName)] = '\0';
  310.         
  311.         rc = AddGroupName(WAIT_WND_MODAL, APPNAME, srvData.Adapter, hwnd, &srvData.cGroupNum);
  312.         
  313.         rc = AddName(WAIT_WND_MODAL, srvData.szName, srvData.Adapter, hwnd, &srvData.cNum);
  314.         
  315.         if(rc != 0)
  316.         {
  317.             DeleteName(WAIT_WND_MODAL, srvData.szName, srvData.Adapter, hwnd);
  318.             rc = AddName(WAIT_WND_MODAL, srvData.szName, srvData.Adapter, hwnd, &srvData.cNum);
  319.         }
  320.         if(rc != 0)
  321.         {
  322.             MessageBox(NULL, 
  323.                 "ACHTUNG: Der Server konnte nicht initialisiert werden \n"
  324.                 "Remotezugriffe sind nicht m÷glich"
  325.                 , APPTITLE,     MB_OK|MB_ICONHAND);
  326.                 
  327.             return -1;
  328.         }            
  329.         new_init();
  330.         return TRUE;
  331.         
  332.     case WM_SYSCOMMAND:
  333.         if( (wParam == SC_MAXIMIZE)
  334.         ||  (wParam == SC_RESTORE))
  335.         {
  336.             return 0;      
  337.         }
  338.         break;
  339.                 
  340.     case WM_TIMER:
  341.         tack = GetTickCount();
  342.         if((tack - tick) > 360000)
  343.         {                     
  344.             tick = GetTickCount();
  345.             // SRV_DEBUG(DB_ACTION, "SERVER: CLIENT TIME OUT!");    
  346.             
  347.             TelHangUp();
  348.             new_init();
  349.         }
  350.         return 0;    
  351.                 
  352.     case WM_COMMNOTIFY:
  353.         event[evcnt] = LOWORD(lParam);
  354.         // SRV_DEBUG(DB_ACTION, "SERVER: WM_COMMNOTIFY %d", event[evcnt]);    
  355.         if(++evcnt > 20) evcnt = 20;
  356.         return TRUE;
  357.                 
  358.         
  359.     case WM_CLOSE: 
  360.         TelHangUp();           
  361.         
  362.         DestroyWindow(hwnd);
  363.         return 0;
  364.         
  365.     case WM_DESTROY:           
  366.         CancelAllPending(hwnd);
  367.         DeleteName(WAIT_WND_MODAL, APPNAME, srvData.Adapter, hwnd);
  368.         DeleteName(WAIT_WND_MODAL, srvData.szName, srvData.Adapter, hwnd);
  369.         CancelAllPending(hwnd);
  370.         
  371.         // SRV_DEBUG(DB_ACTION, "SERVER: EXIT");
  372.         PostQuitMessage(0);
  373.         return 0;
  374.     }
  375.     return DefWindowProc(hwnd, msg, wParam, lParam);
  376. }   
  377. analizeMessage()
  378. {    
  379.     int x;
  380.     
  381.     switch(comData.fnc)
  382.     {
  383.         case SETQUE:
  384.             setque();
  385.             if(sendAnswer() == FALSE)
  386.             {
  387.                 new_init();
  388.             }    
  389.             return TRUE;
  390.             
  391.         case INICOM:
  392.             inicom();
  393.             break;
  394.             
  395.         case SETCOM:    
  396.             setcom();
  397.             break;
  398.             
  399.         case RECCOM:
  400.             reccom();
  401.             break;
  402.             
  403.         case SNDCOM:
  404.             sndcom();
  405.             break;
  406.             
  407.         case CTX:
  408.             ctx();
  409.             break;
  410.             
  411.         case TRMCOM:
  412.             trmcom();
  413.             CancelAllPending(HwnD);    
  414.             new_init();
  415.             return TRUE;
  416.             
  417.         case STACOM:
  418.             stacom();
  419.             break;   
  420.             
  421.         case CEXTFCN:
  422.             cextfcn();
  423.             break;
  424.             
  425.         case CFLUSH:
  426.             cflush();
  427.             break;
  428.             
  429.         case CEVT:
  430.             cevt();
  431.             break;
  432.             
  433.         case CEVTGET:
  434.             cevtget();
  435.             break;
  436.             
  437.         case CSETBRK:
  438.             csetbrk();
  439.             break;
  440.             
  441.         case CCLRBRK:
  442.             cclrbrk();
  443.             break;
  444.             
  445.         case GETDCB:
  446.             getdcb();
  447.             break;
  448.             
  449.         case CWSTRING:
  450.             cwstring();
  451.             break;
  452.             
  453.         case CRSTRING:
  454.             crstring();
  455.             cmdsize[comData.fnc] = SC + comData.len;
  456.             break;
  457.             
  458.         case ENABLENOTI:
  459.             enablenoti();
  460.             break;     
  461.         case GETMASK:
  462.             break;
  463.     }
  464.     if(lpevent != NULL)                  
  465.     {
  466.         comData.evmask = *lpevent;  
  467.         if(evcnt != 0)
  468.         {
  469.             for(x = 1; x < 20; x++)
  470.             {
  471.                 event[x-1] = event[x];
  472.             }
  473.             evcnt--;
  474.         }
  475.     }else
  476.     {
  477.         comData.evmask = EV_ERR;
  478.     }
  479.     if(sendAnswer() == FALSE)
  480.     {
  481.         new_init();
  482.     }
  483. }    
  484. sendAnswer()
  485. {
  486.     int rc;
  487.     
  488.     tick = GetTickCount();
  489.     
  490.     // rc = SendDatagram(WAIT_WND_MODAL, srvData.Adapter, srvData.cNum, srvData.szCaller, 
  491.     //          (LPSTR)&comData, cmdsize[comData.fnc], HwnD);
  492.             
  493.     rc = Send(WAIT_WND_MODAL, srvData.Adapter, srvData.cLSN, 
  494.               (LPSTR)&comData, cmdsize[comData.fnc], HwnD);
  495.     
  496.     if(rc != 0)
  497.     {
  498.         // SRV_DEBUG(DB_ACTION, "SERVER: NET_ERROR (0x%x)", rc);        
  499.         return FALSE;
  500.     }
  501.     return TRUE;
  502. }
  503.  
  504.  
  505. int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
  506. LPSTR lpszCmdLine, int nCmdShow)
  507. {
  508.     
  509.     HWND    hwnd;
  510.     MSG    msg;
  511.     WNDCLASS wndclass;
  512.     WNDCLASS gwndclass;
  513.     
  514.     lstrcpy(szAppName, APPNAME);
  515.     
  516.     if(!hPrevInstance)
  517.     {
  518.         wndclass.style = CS_HREDRAW |CS_VREDRAW;
  519.         wndclass.lpfnWndProc = WndProc;
  520.         wndclass.cbClsExtra = 0;
  521.         wndclass.cbWndExtra = 0;
  522.         wndclass.hInstance = hInstance;
  523.         wndclass.hIcon = LoadIcon(hInstance, "recomsrvico");
  524.         wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
  525.         wndclass.hbrBackground = GetStockObject(WHITE_BRUSH);
  526.         wndclass.lpszMenuName = "recomsrv_SYSMENU";
  527.         wndclass.lpszClassName = szAppName;
  528.         
  529.         RegisterClass(&wndclass);
  530.     }
  531.     hwnd = CreateWindow(szAppName, APPTITLE,
  532.         WS_OVERLAPPEDWINDOW, 0, 0, 30, 100, NULL, NULL, hInstance, NULL);
  533.     
  534.     ShowWindow(hwnd, SW_SHOWMINIMIZED);
  535.     UpdateWindow(hwnd);
  536.     
  537.     while(GetMessage(&msg, NULL, 0, 0))
  538.     {
  539.         TranslateMessage(&msg);
  540.         DispatchMessage(&msg);
  541.     }
  542.     return msg.wParam;
  543. }
  544.  
  545.     
  546.     
  547.  
  548. static int initReceive()
  549. {
  550.     // SRV_DEBUG(DB_ACTION, "SERVER: PUBLISH HOST NAME");
  551.     
  552.     getNetBiosName(srvData.hostname);
  553.                              
  554.     if(lstrlen(srvData.hostname) == 0)
  555.     {   
  556.         // SRV_DEBUG(DB_ACTION, "SERVER: PUBLISH HOST NAME (NO NBNAME)");
  557.         return FALSE;
  558.     }           
  559.     return TRUE;
  560. }
  561. new_init()
  562. {                    
  563.     int rc;
  564.     
  565.     // SRV_DEBUG(DB_ACTION, "SERVER: INIT");
  566.     
  567.     lpevent = &event[0];
  568.     evcnt = event[0] = 0;
  569.     
  570.     SetWindowText(HwnD, APPTITLE);
  571.                 
  572.     if(CONECTED == TRUE) 
  573.     {    
  574.         CONECTED = FALSE;
  575.             
  576.         tick = GetTickCount();
  577.         FlushComm(com, 0);
  578.         FlushComm(com, 1);
  579.         
  580.         WriteComm(com, "+++\x0d\x0aATH\x0d\0aATZ\x0d\x0a       ", 15);
  581.         FlushComm(com, 0);
  582.         EscapeCommFunction(com, CLRDTR);
  583.         
  584.         while((tick - GetTickCount()) < 500); // 50 msec -> Modem legt auf
  585.         
  586.         CloseComm(com);            
  587.         
  588.         CancelAllPending(HwnD);
  589.         HangUp(WAIT_WND_MODAL, srvData.Adapter, srvData.cLSN, HwnD);
  590.         
  591.         // SRV_DEBUG(DB_ACTION, "SERVER: DISCONECTED");
  592.     }                       
  593.     
  594.     if(initReceive() == FALSE) return FALSE;
  595.     
  596.     CONECTED = FALSE;                     
  597.     
  598.     rc = PostReceiveBroadcast(srvData.Adapter, srvData.cGroupNum, 
  599.               (LPSTR)&fndSrv, sizeof(fndSrv), HwnD, WM_NB_RESPONSE, 1, &brdNCB);
  600.     
  601.     rc = PostListen(srvData.szName, "*", srvData.Adapter, 0, 60, 
  602.         HwnD,  WM_NB_RESPONSE, 0, &lpNCB);
  603.     
  604.     if(rc != 0)
  605.     {
  606.         // SRV_DEBUG(DB_ACTION, "SERVER: ERROR LISTEN (0x%x)", rc);        
  607.         return FALSE;
  608.     }
  609.     
  610.     ShowWindow(HwnD, SW_HIDE);
  611.     
  612.     // SRV_DEBUG(DB_ACTION, "SERVER: NET_LISTEN");
  613.     
  614.     return TRUE;
  615. }
  616.