home *** CD-ROM | disk | FTP | other *** search
/ PCNET 2006 September - Disc 1 / PCNET_CD_2006_09.iso / surpriz / MSRMesh-VirtualWIFI.MSI / addnetwork.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2005-06-24  |  13.6 KB  |  508 lines
  1. /*
  2.  * Author   : Ranveer Chandra
  3.  * Directory: VirtualWiFi_Root\install
  4.  * File Name: addnetwork.cpp
  5.  * Purpose  : Has the code to add a VirtualWiFi network
  6.  */
  7.  
  8. #include <windows.h>
  9. #include <stdio.h>
  10. #include <strsafe.h>
  11. #include <setupapi.h>
  12. #include <netcfgx.h>
  13. #include <devguid.h>
  14. #include <netcon.h>
  15. #include <netcfgn.h>
  16.  
  17. extern bool Verbose;
  18.  
  19. extern VOID ReleaseRef (IN IUnknown* punk)
  20. {
  21.     if ( punk ) {
  22.         punk->Release();
  23.     }
  24.  
  25.     return;
  26. }
  27.  
  28. extern HRESULT HrGetINetCfg (IN BOOL fGetWriteLock,
  29.                       IN LPCWSTR lpszAppName,
  30.                       OUT INetCfg** ppnc,
  31.                       OUT LPWSTR *lpszLockedBy)
  32. {
  33.     INetCfg      *pnc = NULL;
  34.     INetCfgLock  *pncLock = NULL;
  35.     HRESULT      hr = S_OK;
  36.  
  37.     //
  38.     // Initialize the output parameters.
  39.     //
  40.  
  41.     *ppnc = NULL;
  42.  
  43.     if ( lpszLockedBy )
  44.     {
  45.         *lpszLockedBy = NULL;
  46.     }
  47.     //
  48.     // Initialize COM
  49.     //
  50.     CoUninitialize( );
  51.  
  52.     hr = CoInitialize( NULL );
  53.  
  54.     if ( hr == S_OK ) {
  55.  
  56.         //
  57.         // Create the object implementing INetCfg.
  58.         //
  59.  
  60.         hr = CoCreateInstance( CLSID_CNetCfg,
  61.                                NULL, CLSCTX_INPROC_SERVER,
  62.                                IID_INetCfg,
  63.                                (void**)&pnc );
  64.         if ( hr == S_OK ) {
  65.             if(Verbose)
  66.                 printf("CoCreateInstance successful\n");
  67.  
  68.             if ( fGetWriteLock ) {
  69.  
  70.                 //
  71.                 // Get the locking reference
  72.                 //
  73.  
  74.                 hr = pnc->QueryInterface( IID_INetCfgLock,
  75.                                           (LPVOID *)&pncLock );
  76.                 if ( hr == S_OK ) {
  77.                     if(Verbose)
  78.                         printf("QueryInterface successful\n");
  79.  
  80.                     //
  81.                     // Attempt to lock the INetCfg for read/write
  82.                     //
  83.  
  84.                     hr = pncLock->AcquireWriteLock( 5000,
  85.                                                     lpszAppName,
  86.                                                     lpszLockedBy);
  87.                     if (hr == S_FALSE ) {
  88.                         printf("Could not acquire write lock\n");
  89.                         hr = NETCFG_E_NO_WRITE_LOCK;
  90.                     }
  91.                 }
  92.             }
  93.  
  94.             if ( hr == S_OK ) {
  95.                 if(Verbose)
  96.                     printf("Everything fine\n");
  97.                 //
  98.                 // Initialize the INetCfg object.
  99.                 //
  100.  
  101.                 hr = pnc->Initialize( NULL );
  102.  
  103.                 if ( hr == S_OK ) {
  104.                     if(Verbose)
  105.                         printf("Initialize successful\n");
  106.                     *ppnc = pnc;
  107.                     pnc->AddRef();
  108.                 }
  109.                 else {
  110.  
  111.                     //
  112.                     // Initialize failed, if obtained lock, release it
  113.                     //
  114.  
  115.                     if ( pncLock ) {
  116.                         pncLock->ReleaseWriteLock();
  117.                     }
  118.                 }
  119.             }
  120.  
  121.             ReleaseRef( pncLock );
  122.             ReleaseRef( pnc );
  123.         }
  124.         else 
  125.             printf("cocreateinstance failed\n");
  126.  
  127.         //
  128.         // In case of error, uninitialize COM.
  129.         //
  130.  
  131.         if ( hr != S_OK ) {
  132.             CoUninitialize();
  133.         }
  134.     }
  135.     else 
  136.         printf("CoInitialize Null failed\n");
  137.     return hr;
  138. }
  139.  
  140. //
  141. // Function:  HrReleaseINetCfg
  142. //
  143. // Purpose:   Get a reference to INetCfg.
  144. //
  145. // Arguments:
  146. //    pnc           [in] Reference to INetCfg to release.
  147. //    fHasWriteLock [in] If TRUE, reference was held with write lock.
  148. //
  149. // Returns:   S_OK on sucess, otherwise an error code.
  150. //
  151. // Notes:
  152. //
  153.  
  154. extern HRESULT HrReleaseINetCfg (IN INetCfg* pnc,
  155.                           IN BOOL fHasWriteLock)
  156. {
  157.     INetCfgLock    *pncLock = NULL;
  158.     HRESULT        hr = S_OK;
  159.  
  160.     //
  161.     // Uninitialize INetCfg
  162.     //
  163.  
  164.     hr = pnc->Uninitialize();
  165.  
  166.     //
  167.     // If write lock is present, unlock it
  168.     //
  169.  
  170.     if ( hr == S_OK && fHasWriteLock ) {
  171.  
  172.         //
  173.         // Get the locking reference
  174.         //
  175.  
  176.         hr = pnc->QueryInterface( IID_INetCfgLock,
  177.                                   (LPVOID *)&pncLock);
  178.         if ( hr == S_OK ) {
  179.            hr = pncLock->ReleaseWriteLock();
  180.            ReleaseRef( pncLock );
  181.         }
  182.     }
  183.  
  184.     ReleaseRef( pnc );
  185.  
  186.     //
  187.     // Uninitialize COM.
  188.     //
  189.  
  190.     CoUninitialize();
  191.  
  192.     return hr;
  193. }
  194.  
  195.  
  196. //
  197. // Function:  HrGetComponentEnum
  198. //
  199. // Purpose:   Get network component enumerator reference.
  200. //
  201. // Arguments:
  202. //    pnc         [in]  Reference to INetCfg.
  203. //    pguidClass  [in]  Class GUID of the network component.
  204. //    ppencc      [out] Enumerator reference.
  205. //
  206. // Returns:   S_OK on sucess, otherwise an error code.
  207. //
  208. // Notes:
  209. //
  210.  
  211. extern HRESULT HrGetComponentEnum (INetCfg* pnc,
  212.                             IN const GUID* pguidClass,
  213.                             OUT IEnumNetCfgComponent **ppencc)
  214. {
  215.     INetCfgClass  *pncclass;
  216.     HRESULT       hr;
  217.  
  218.     *ppencc = NULL;
  219.  
  220.     //
  221.     // Get the class reference.
  222.     //
  223.  
  224.     hr = pnc->QueryNetCfgClass( pguidClass,
  225.                                 IID_INetCfgClass,
  226.                                 (PVOID *)&pncclass );
  227.  
  228.     if ( hr == S_OK ) {
  229.  
  230.         //
  231.         // Get the enumerator reference.
  232.         //
  233.  
  234.         hr = pncclass->EnumComponents( ppencc );
  235.  
  236.         //
  237.         // We don't need the class reference any more.
  238.         //
  239.  
  240.         ReleaseRef( pncclass );
  241.     }
  242.  
  243.     return hr;
  244. }
  245.  
  246. //
  247. // Function:  HrGetFirstComponent
  248. //
  249. // Purpose:   Enumerates the first network component.
  250. //
  251. // Arguments:
  252. //    pencc      [in]  Component enumerator reference.
  253. //    ppncc      [out] Network component reference.
  254. //
  255. // Returns:   S_OK on sucess, otherwise an error code.
  256. //
  257. // Notes:
  258. //
  259.  
  260. extern HRESULT HrGetFirstComponent (IN IEnumNetCfgComponent* pencc,
  261.                              OUT INetCfgComponent **ppncc)
  262. {
  263.     HRESULT  hr;
  264.     ULONG    ulCount;
  265.  
  266.     *ppncc = NULL;
  267.  
  268.     pencc->Reset();
  269.  
  270.     hr = pencc->Next( 1,
  271.                       ppncc,
  272.                       &ulCount );
  273.     return hr;
  274. }
  275.  
  276. DWORD WINAPI PressEnter( LPVOID lpParam ) 
  277. { 
  278.     Sleep(500);
  279.     // These two lines imulate enter
  280.     keybd_event(VK_RETURN, 0, 0, 0);
  281.     keybd_event(VK_RETURN, 0, KEYEVENTF_KEYUP, 0);
  282.  
  283.     return 0; 
  284. } 
  285.  
  286. DWORD WINAPI PressDownAndEnter( LPVOID lpParam ) 
  287. { 
  288.     Sleep(500);
  289.     printf("Pressing down and Enter\n");
  290.     // These two lines emulate the down key
  291.     keybd_event(VK_DOWN, 0, 0, 0);
  292.     keybd_event(VK_DOWN, 0, KEYEVENTF_KEYUP, 0);
  293.     // These two lines emulate enter
  294.     keybd_event(VK_RETURN, 0, 0, 0);
  295.     keybd_event(VK_RETURN, 0, KEYEVENTF_KEYUP, 0);
  296.  
  297.     return 0; 
  298. } 
  299.  
  300. extern 
  301. VOID AddNetwork (HWND hwndDlg, BOOL addNetwork)
  302. {
  303.   INetCfg                 *pnc;
  304.   IEnumNetCfgComponent    *penccAdapter;
  305.   INetCfgComponent        *pnccAdapter;
  306.   INetCfgComponent        *pnccTrans;
  307.   INetConnectionManager   *pConMan;
  308.   IEnumNetConnection      *pEnumCon;
  309.   INetConnection          *pCon;
  310.   INetConnectionPropertyUi *pConUi;
  311.   GUID                    guidAdapter;
  312.   CLSID                   ClsId;
  313.   NETCON_PROPERTIES       *pConProps;
  314.   BOOL                    fLanConn;
  315.   BOOL                      gotAdapter = FALSE;
  316.   HRESULT                 hr;
  317.   ULONG                   count;
  318.   DWORD dwThreadId, dwThrdParam=1; 
  319.   HANDLE hThread; 
  320.  
  321.   hr = HrGetINetCfg( TRUE,
  322.                      L"NETCONN",
  323.                      &pnc,
  324.                      NULL );
  325.  
  326.   if ( hr == S_OK ) {
  327.  
  328.      //
  329.      // Get Component Enumerator Interface.
  330.      //
  331.  
  332.      //hr = HrGetComponentEnum( pnc,
  333.      //                         &GUID_DEVCLASS_NET,
  334.      //                         &penccAdapter );
  335.      if ( hr == S_OK ) {
  336.  
  337.         //hr = HrGetFirstComponent( penccAdapter, &pnccAdapter );
  338.  
  339.         if ( hr == S_OK ) {
  340.  
  341.            //hr = pnccAdapter->GetInstanceGuid( &guidAdapter );
  342.  
  343.            if ( hr == S_OK ) {
  344.               hr = pnc->FindComponent( L"MS_VWiFiP", &pnccTrans );
  345.  
  346.               if ( hr == S_OK ) {
  347.                  hr = CoCreateInstance( CLSID_ConnectionManager, NULL,
  348.                                         CLSCTX_SERVER | CLSCTX_NO_CODE_DOWNLOAD,
  349.                                         IID_INetConnectionManager,
  350.                                         (LPVOID *)&pConMan );
  351.                  if ( hr == S_OK ) {
  352.  
  353.                     hr = pConMan->EnumConnections( NCME_DEFAULT, &pEnumCon );
  354.  
  355.                     if ( hr == S_OK ) {
  356.                        
  357.                         while(!gotAdapter) {
  358.                            hr = pEnumCon->Next( 1, &pCon, &count );
  359.  
  360.                            if (hr == S_OK) {
  361.                                hr = pCon->GetProperties( &pConProps );    
  362.                                if(Verbose) {
  363.                                    wprintf(L"Device Name is %s\n", pConProps->pszwName);
  364.                                    wprintf(L"Adapter Name is %s\n", pConProps->pszwDeviceName);
  365.                                }
  366.                                if ( wcsstr( pConProps->pszwName, L"Wireless" ) != NULL ) { 
  367.                                    gotAdapter = TRUE;
  368.                                    if(Verbose)
  369.                                         printf("Found Adapter\n");
  370.                                }
  371.                            }
  372.                         }
  373.  
  374.                        fLanConn = FALSE;
  375.  
  376.                        while ( (hr == S_OK) && !fLanConn ) {
  377.                           
  378.                           hr = pCon->GetProperties( &pConProps );
  379.  
  380.                           if ( hr == S_OK ) {
  381.                              fLanConn = pConProps->MediaType == NCM_LAN;
  382.                              CoTaskMemFree( pConProps );
  383.                           }
  384.  
  385.                           if ( fLanConn ) {
  386.                              hr = pCon->GetUiObjectClassId( &ClsId );
  387.                              if ( hr == S_OK ) {
  388.                                 hr = CoCreateInstance( ClsId, NULL,
  389.                                                        CLSCTX_INPROC_SERVER |                                                       
  390.                                                        CLSCTX_NO_CODE_DOWNLOAD,
  391.                                                        IID_INetConnectionPropertyUi,
  392.                                                        (LPVOID *)&pConUi );
  393.                                 if ( hr == S_OK ) {
  394.                                     hr = pConUi->SetConnection( pCon );
  395.  
  396.                                     if(addNetwork) {
  397.                                         hThread = CreateThread( 
  398.                                             NULL,                        // no security attributes 
  399.                                             0,                           // use default stack size  
  400.                                             PressEnter,                  // thread function 
  401.                                             &dwThrdParam,                 // argument to thread function
  402.                                             0,                           // use default creation flags 
  403.                                             &dwThreadId);                // returns the thread identifier 
  404.                                     } else {
  405.                                         hThread = CreateThread( 
  406.                                             NULL,                        // no security attributes 
  407.                                             0,                           // use default stack size  
  408.                                             PressDownAndEnter,                  // thread function 
  409.                                             &dwThrdParam,                 // argument to thread function
  410.                                             0,                           // use default creation flags 
  411.                                             &dwThreadId);                // returns the thread identifier 
  412.                                     }
  413.                                  
  414.                                     // Check the return value for success. 
  415.                                     hr = pnccTrans->RaisePropertyUi( hwndDlg,
  416.                                                                     NCRP_SHOW_PROPERTY_UI,
  417.                                                                     pConUi 
  418.                                                                     );
  419.    
  420.                                    
  421.                                     
  422.                                     if (hThread == NULL) 
  423.                                     {
  424.                                         printf("CreateThread failed." ); 
  425.                                     }
  426.                                     else 
  427.                                     {
  428.                                         Sleep(1000);
  429.                                         CloseHandle( hThread );
  430.                                     }
  431.  
  432.                                    if ( hr == S_OK ) {
  433.                                       if(Verbose)
  434.                                           printf("RaisePropertyUi successful.");
  435.                                       pnc->Apply();
  436.                                    }
  437.                                    else 
  438.                                    {
  439.                                        printf("RaisePropertyUi failed.");
  440.                                    }
  441.                                    pConUi->Release();
  442.                                 }
  443.                                 else 
  444.                                 {
  445.                                     printf("CoCreateInstance on IID_INetConnectionCommonUi failed.");
  446.                                 }
  447.                              }
  448.                              else 
  449.                              {
  450.                                  printf("GetUiObjectClassId failed.");
  451.                              }
  452.                           }
  453.                           pCon->Release() ;
  454.                           hr = pEnumCon->Next( 1, &pCon, &count );
  455.                        }
  456.                        pEnumCon->Release();
  457.                     }
  458.                     else 
  459.                     {
  460.                        printf("EnumConnections failed.");
  461.                     }
  462.                     pConMan->Release();
  463.                  }
  464.                  else 
  465.                  {
  466.                     printf("CoCreateInstance on IID_INetConnectionManager failed.");
  467.                  }
  468.                  pnccTrans->Release();
  469.               }
  470.            }
  471.            else 
  472.            {
  473.               printf("GetInstanceGuid failed.");
  474.            }
  475.            //pnccAdapter->Release();
  476.         }
  477.         else 
  478.         {
  479.            printf("HrGetFirstComponent failed.");
  480.         }
  481.         //penccAdapter->Release();
  482.      }
  483.      else 
  484.      {
  485.         printf("HrGetComponentEnum failed.");
  486.      }
  487.      HrReleaseINetCfg( pnc, TRUE );
  488.   }
  489.   else 
  490.   {
  491.      printf("HrGetINetCfg failed.");
  492.   }
  493.  
  494.  
  495.   /*
  496.   INPUT input[4] = {INPUT_KEYBOARD, VK_TAB, 0, 0, 0, 0,
  497.                         INPUT_KEYBOARD, VK_TAB, 0, KEYEVENTF_KEYUP, 0, 0,
  498.                         INPUT_KEYBOARD, VK_RETURN, 0, 0, 0, 0,
  499.                         INPUT_KEYBOARD, VK_RETURN, 0, KEYEVENTF_KEYUP, 0, 0};
  500.  
  501.  
  502.   SendInput(4, input, sizeof input[0]);
  503.   */
  504.  
  505.   return;
  506. }
  507.  
  508.