मैं रनटाइम पर उपयोगकर्ता को उन्नत अनुमतियों के लिए कैसे पूछ सकता हूं?

Question

एक नियमित उपयोगकर्ता के साथ शुरू होने वाले कुछ एप्लिकेशन आवश्यक होने पर उच्च अनुमतियों के लिए पूछेंगे (उदा। फ़ाइल प्रबंधक को ऐसे फ़ोल्डर को लिखने की आवश्यकता है), और फिर ऑपरेशन के साथ आगे बढ़ें।

मैं इस व्यवहार को दोहराने कैसे कर सकता हूं?

Answer 1

जैसा कि तमास ने बताया कि आपको ऊंचे अधिकारों के साथ एक नई प्रक्रिया शुरू करने की आवश्यकता है। मैंने अतीत में बहुत कुछ खोजा लेकिन मुझे वर्तमान प्रक्रिया के अधिकारों को बढ़ाने के लिए कोई रास्ता नहीं मिला।

मान लें कि आपका प्राथमिक ऐप App1.exe है और फिर आप द्वितीयक प्रक्रिया App2.exe को कॉल करते हैं जिसके लिए उच्च अधिकारों की आवश्यकता होती है।

---

ए आप अपने App2.exe में प्रकट एम्बेड कर सकते हैं, लेकिन सरल तरीके से मालसूची फ़ाइल [एक पाठ फ़ाइल] निम्नलिखित सामग्री के साथ App2.exe.manifest नामित बना सकते हैं और इसे डाल करने के लिए है App2.exe के समान निर्देशिका। नोट: !! आश्चर्यजनक रूप से पर्याप्त है, यदि आपके एप्लिकेशन का नाम App2.exe नहीं है, लेकिन App2_install.exe या App2_setup.exe (यानी यदि एप्लिकेशन नाम में "इंस्टॉल" या "सेटअप" होता है) तो एक यूएसी संवाद स्वचालित रूप से विंडोज विस्टा/विंडोज 7 में दिखाई देगा और ऊंचे अधिकारों के लिए पूछेगा यहां तक ​​कि कोई प्रकट फ़ाइल नहीं है !!

<?xml version="1.0" encoding="UTF-8" standalone="yes"?> 
<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0"> 
<trustInfo xmlns="urn:schemas-microsoft-com:asm.v3"> 
<security> 
<requestedPrivileges> 
<requestedExecutionLevel level="requireAdministrator" uiAccess="false" /> 
</requestedPrivileges> 
</security> 
</trustInfo> 
</assembly> 

---

B. आप App2.exe

QString AppToExec = qApp->applicationDirPath() + "/App2.exe"; 
// Put any required parameters of App2.exe to AppParams string 
QString AppParams = ""; 
if (0 != genWin32ShellExecute(AppToExec, 
           "", // default verb: "open" or "exec" 
           AppParams, 
           false, // run hidden 
           true)) // wait to finish 
{ 
    // (...) handle error 
} 

लांच करने के लिए App1.exe में निम्नलिखित की तरह एक कोड का उपयोग कर सकते हैं: इस मैनिफ़ेस्ट फ़ाइल का एक नमूना है। ..

हैडर:

#ifdef Q_OS_WIN // Implement genWin32ShellExecute() especially for UAC 
    #include "qt_windows.h" 
    #include "qwindowdefs_win.h" 
    #include <shellapi.h> 

int genWin32ShellExecute(QString AppFullPath, 
         QString Verb, 
         QString Params, 
         bool ShowAppWindow, 
         bool WaitToFinish); 
#endif 

और अंत में, इस Win32 समारोह genWin32ShellExecute का कोड() मैं एक प्रक्रिया का शुभारंभ या जब एक Win32 हे/एस पर क्यूटी का उपयोग कर एक दस्तावेज़ को खोलने के लिए बनाया है सीपीपी:

// Execute/Open the specified Application/Document with the given command 
// line Parameters 
// (if WaitToFinish == true, wait for the spawn process to finish) 
// 
// Verb parameter values: 
// ""   The degault verb for the associated AppFullPath 
// "edit"  Launches an editor and opens the document for editing. 
// "find"  Initiates a search starting from the specified directory. 
// "open"  Launches an application. If this file is not an executable file, its associated application is launched. 
// "print"  Prints the document file. 
// "properties" Displays the object's properties. 
// 
// Ret: 0 = success 
//  <0 = error 
#ifdef Q_OS_WIN 
int genWin32ShellExecute(QString AppFullPath, 
         QString Verb, 
         QString Params, 
         bool ShowAppWindow, 
         bool WaitToFinish) 
{ 
    int Result = 0; 

    // Setup the required structure 
    SHELLEXECUTEINFO ShExecInfo; 
    memset(&ShExecInfo, 0, sizeof(SHELLEXECUTEINFO)); 
    ShExecInfo.cbSize = sizeof(SHELLEXECUTEINFO); 
    ShExecInfo.fMask = SEE_MASK_NOCLOSEPROCESS; 
    ShExecInfo.hwnd = NULL; 
    ShExecInfo.lpVerb = NULL; 
    if (Verb.length() > 0) 
     ShExecInfo.lpVerb = reinterpret_cast<const WCHAR *>(Verb.utf16()); 
    ShExecInfo.lpFile = NULL; 
    if (AppFullPath.length() > 0) 
     ShExecInfo.lpFile = reinterpret_cast<const WCHAR *>(AppFullPath.utf16()); 
    ShExecInfo.lpParameters = NULL; 
    if (Params.length() > 0) 
     ShExecInfo.lpParameters = reinterpret_cast<const WCHAR *>(Params.utf16()); 
    ShExecInfo.lpDirectory = NULL; 
    ShExecInfo.nShow = (ShowAppWindow ? SW_SHOW : SW_HIDE); 
    ShExecInfo.hInstApp = NULL; 

    // Spawn the process 
    if (ShellExecuteEx(&ShExecInfo) == FALSE) 
    { 
     Result = -1; // Failed to execute process 
    } else if (WaitToFinish) 
    { 
     WaitForSingleObject(ShExecInfo.hProcess, INFINITE); 
    } 

    return Result; 
} 
#endif 

Answer 2

this question on elevating privileges only when required in C# और this article on User Account Control

यह कुल मिलाकर देखें: एक ऊंचा अनुमति के साथ एक नई प्रक्रिया शुरू करने के लिए की जरूरत है। रनटाइम पर ऊंचाई स्तर बदला नहीं जा सकता है। उन्नत अनुमतियों के साथ लॉन्च करना या तो WinAPI के माध्यम से किया जाता है या निष्पादन योग्य में एक सही मैनिफेस्ट एम्बेड किया जाता है।

Answer 3

संक्षेप में: विंडोज़ के लिए दो निष्पादन योग्य फाइलें बनाएं। नियमित निष्पादन योग्य, और एक कार्यकर्ता exe फ़ाइल जिसे आप "उन्नत" संचालन करने के लिए उपयोग करते हैं (कमांड लाइन विकल्प पास करके)।

दूसरी EXE फ़ाइल में आप <requestExecutionLevel level="requireAdministrator"/> नोड के साथ एक एप्लिकेशन मेनिफेस्ट फ़ाइल जोड़ते हैं।

जब कार्यकर्ता एप्लिकेशन को लॉन्च करने, ShellExecute जबकि (एक खोल समारोह होने के नाते), क्यूटी समारोह है कि ShellExecute, नहीं CreateProcess लपेटता के रूप में CreateProcess बस requireAdministrator एप्लिकेशन लॉन्च करने में विफल रहता है का उपयोग सुनिश्चित करें यूएसी ऊंचाई शीघ्र प्रदर्शन कर सकते हैं।

ActiveX नियंत्रणों के साथ ऐसा करना भी संभव है, लेकिन जैसा कि आप क्यूटी को लक्षित कर रहे हैं जो कम उपयुक्त लगता है।

Answer 4

आप एक उन्नत मोड में एक COM ऑब्जेक्ट भी लॉन्च कर सकते हैं। अधिक जानकारी के लिए यह MSDN article देखें।