Newsgroup: it.comp.lang.delphi
Titolo: AVVIO E STOP DI UNA APPLICAZIONE - Evitare le duplicazioni

Se hai necessità di rilanciare un processo,in modo che se è aperto si 
chiuda per poi riaprirsi..in modo da non avere duplicati in esecuzione.
E non vuoi impastarti con TerminateProcess che solo un principiante 
userebbe, usa:
 system("taskkill /im app.exe /F");
--- posted by geoForum on 
http://www.delphiedintorni.it

TaskkillEnds one or more tasks or processes. Processes can be killed by 
process ID or image name.
Syntax
taskkill [/s Computer] [/u Domain\User [/p Password]]] [/fi FilterName] 
[/pid ProcessID]|[/im ImageName] [/f][/t] 
Parameters
/s Computer 
Specifies the name or IP address of a remote computer (do not use 
backslashes). The default is the local computer. 
/u Domain\User 
Runs the command with the account permissions of the user specified by 
User or Domain\User. The default is the permissions of the current 
logged on user on the computer issuing the command. 
/p Password 
Specifies the password of the user account that is specified in the /u 
parameter. 
/fi FilterName 
Specifies the types of process(es) to include in or exclude from 
termination. The following are valid filter names, operators, and values.


Prova questa sintassi anche lanciata in un file.bat
ESEMPIO 
TASKKILL /IM mioprocesso.exe
SINTASSI:
TASKKILL [/S system [/U username [/P [password]]]]
         { [/FI filter] [/PID processid | /IM imagename] } [/F] [/T]
Description:
    This command line tool can be used to end one or more processes.
    Processes can be killed by the process id or image name.
Parameter List:
    /S    system           Specifies the remote system to connect to.
    /U    [domain\]user    Specifies the user context under which
                           the command should execute.
    /P    [password]       Specifies the password for the given
                           user context. Prompts for input if omitted.
    /F                     Specifies to forcefully terminate
                           process(es).
    /FI   filter           Displays a set of tasks that match a
                           given criteria specified by the filter.
    /PID  process id       Specifies the PID of the process that
                           has to be terminated.
    /IM   image name       Specifies the image name of the process
                           that has to be terminated. Wildcard '*'
                           can be used to specify all image names.
    /T                     Tree kill: terminates the specified process
                           and any child processes which were started by 
it.
    /?                     Displays this help/usage.


  system("taskkill /im app.exe /F");
Che fai? ti rifugi in processi esterni? ma tu non sei mica un
principiante, tu hai conoscenza dell'API di Windows, facci vedere come
faresti con ExitProcess(): pezzi di codice, stralci della tua enorme
competenza. Dai uno schiaffo morale a quelli pagati per stare qui, come me
e Marco Breveglieri, dai dai, aspettiamo frementi.
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

Quanto è bello e utile Google, eh?


Processi esterni ?
Per me sei andato di testa.... 
Tiriamo le somme.
La tua soluzione è una cagata, la mia funziona....


Mai sentito parlare di chiamate di sistema ?


OK PAPPA PRONTA per i due CRETINI....
#include <windows.h>
#include <tlhelp32.h>
#include <stdio.h>
#include <tchar.h>
/*-----------------------------------------------------------------------
----*/
/**
 */
bool SetDebugPrivileges(HANDLE hProcessHandle)
{
    bool bReturnCode = false;
    // accedi al descrittore del processo...
    HANDLE hProcess;
    BOOL bResult;
    bResult = ::OpenProcessToken(hProcessHandle,
                                 TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
                                 &hProcess);
    if (bResult == TRUE) {
        // ... effettua una ricerca del LUID del privilegio di "debug"
        // che desideriamo reimpostare...
        LUID luidPrivilegeValue;
 
        bResult = ::LookupPrivilegeValue(NULL,
                                         SE_DEBUG_NAME,
                                         &luidPrivilegeValue);
        if (bResult == TRUE) {
            // ... reimposta il privilegio del processo e imposta il
            // valore di ritorno di conseguenza.
            TOKEN_PRIVILEGES tkp;
            tkp.PrivilegeCount = 1;
            tkp.Privileges[0].Luid = luidPrivilegeValue;
            tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
            bResult = ::AdjustTokenPrivileges(hProcess,
                                              FALSE,
                                              &tkp,
                                              sizeof(tkp),
                                              NULL, NULL);
            if (bResult == TRUE)
                bReturnCode = true;
        }
        // rilascia le risorse usate per accedere al descrittore del
        // processo.
        ::CloseHandle(hProcess);
    }
    // restituisci il valore di ritorno.
    return bReturnCode;
}
/**
 */
bool FindProcessID(TCHAR *tszExeFile,
                   DWORD &dwProcessID)
{
    bool bReturnCode = false;
    // ottieni un'istantanea dei processi attualmente presenti in
    // memoria...
    HANDLE hSnapshot;
 
    hSnapshot = ::CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hSnapshot != INVALID_HANDLE_VALUE) {
        // ... inizia ad percorrere la lista degli stessi, alla ricerca
        // del primo il cui modulo ha nome uguale a quello che stiamo
        // cercando...
        PROCESSENTRY32 pe32;
        BOOL bResult;
        bResult = ::Process32First(hSnapshot,
                                   &pe32);
        while (bResult == TRUE) {
            // ... nel caso venga trovato (a meno di maiuscole e/o
            // minuscole)...
            if (_tcsicmp(tszExeFile, pe32.szExeFile) == 0) {
                // ... recupera l'identificativo di processo...
                dwProcessID = pe32.th32ProcessID;
                // ... imposta il valore di ritorno...
                bReturnCode = true;
                // ... e interrompi il ciclo.
                break;
            }
            // altrimenti, continua la ricerca con il prossimo
            // elemento della lista.
            bResult = ::Process32Next(hSnapshot,
                                      &pe32);
        }
        // alla fine, rilascia le risorse acquisite dall'istantanea.
        ::CloseHandle(hSnapshot);
    }
    // restituisci il valore di ritorno.
    return bReturnCode;
}
/**
 */
bool KillProcess(DWORD dwProcessID,
                 UINT uiExitCode)
{
    bool bReturnCode = false;
    // accedi al processo, specificando che si desidera poterlo
    // "terminare"...
    HANDLE hProcess;
    hProcess = ::OpenProcess(PROCESS_TERMINATE,
                             FALSE,
                             dwProcessID);
    if (hProcess != NULL) {
        // ... richiedi la terminazione del processo ed imposta
        // il valore di ritorno di conseguenza.
        BOOL bResult;
        bResult = ::TerminateProcess(hProcess,
                                     uiExitCode);
        if (bResult == TRUE)
            bReturnCode = true;
        // alla fine rilascia le risorse usate per la accedere
        // al processo.
        bResult = ::CloseHandle(hProcess);
    }
    // restituisci il valore di ritorno.
    return bReturnCode;
}
/*-----------------------------------------------------------------------
----*/
/**
 */
int __cdecl _tmain(int argc, _TCHAR **argv, _TCHAR **envp)
{
bool bResult;
bResult = SetDebugPrivileges(::GetCurrentProcess());
if (bResult == true) {
DWORD dwProcessID;
bResult = FindProcessID(_T("EXPLORER.EXE"),
dwProcessID);
if (bResult == true)
bResult = KillProcess(dwProcessID,
0);
}
return 0;


Il solito Fesso ha scritto:
 ... ninete di importante.
Hai passato tutto il pomeriggio a cercare questa roba qua?
http://snipurl.com/1o7jc
Che vita di merda!


Mai sentito parlare di chiamate di sistema ?
Mai sentitto parlare di chiamate di sistema *interne* e chiamate di
sistema *esterne*?
Ritenta trollino.

La tua soluzione è una cagata, la mia funziona....
La tua non è una soluzione. Stiamo ancora aspettando quella con
VirtualAllocEx(), OpenProcess() e ExitProcess().
Dai, che aspetti? perché ci metti così tanto? fai del bene alla
comunità, insegna qualcosa di nuovo...

Sei fuori....
Questa roba è di windows...


 Questa roba è di windows...
Uff... che noia... mi sono letto un po' di messaggi, e mi sto realmente 
chiedendo come mai in giro si dice generalmente di "non dare da mangiare 
ai troll" se Andrea (mi riferisco a quello "verace", s'intende) ti 
sprona a fornire delle soluzioni tecniche incalzandoti a tal punto che, 
a momenti, fai fatica a trovare qualcosa che si possa considerare 
semplicemente nuovo e inedito per continuare a "trollare".
Insomma, a te non si cava qualcosa di interessante a livello di 
"trollate" nemmeno ingozzandoti... :-)
Perché su "i.c.l.d." non possiamo permetterci un "troll" come si deve?
Dov'è finita la professionalità?
Ironia della sorte: nel discutere insistentemente di questo problema 
della terminazione di processi esterni, con i dettagli tecnici forniti 
(da chi risponde seriamente, è chiaro) ho imparato a momenti più cose 
nuove ed interessanti in queste discussioni "trollate" che in tante 
altre partite con ben altri intenti.
Sai che ti dico? Se non fosse che non ho tempo a sufficienza per 
seguirti nelle tue elucubrazioni mentali, quasi quasi la tua attività la 
considero quasi benefica a questo punto: scrivendo cose che non stanno 
né in cielo né in terra, controbatterti tecnicamente diventa molto 
facile e, data la frequenza dei tuoi interventi, questo contribuisce a 
diffondere informazioni utili a ritmo più elevato rispetto a quello 
sostenuto dalle risposte alle domande poste dai frequentatori 
occasionali e dai "newbie", che troveranno anzi tante nozioni 
interessanti nelle risposte serie (facilmente riconoscibili) ai tuoi 
quesiti fasulli e alle successive repliche da parte tua.
Non avrei mai pensato di dirlo ma... grazie! ;-)
-- 
MARCO BREVEGLIERI
  (
http://www.marco.breveglieri.name
)

quesiti fasulli e alle successive repliche da parte tua.
Infatti questa è un'idea geniale: convocare troll nei ng per far sì
che loro cerchino informazioni quando tentano affannosamente di
ribattere :-)

Grazie Marco, quoto tutto al 100%.
In definitiva per una pianta è anche importante il terreno in cui questa 
cresce e persone come Andrea Laforgia costitusicono l'humus giusto.
Devo ammettere di essermi affezionato al caro vecchio Andrea, è uno dei 
nostri.
PS. Non vorrei che pensassero che questa storia del TROLL sia una 
trovata di qualcuno all'interno di Wintech. La discussione in questo NG 
era forse troppo noiosa ? 
La domada che faccio è perche in D&D non accade nulla di tutto ciò ? Non 
vi sembra davvero strano ? E inoltre perchè nessuno ha mai preso dei 
provvedimenti ?
Molto spesso il profitto c'è dove nemmeno lo si immagina. Ma forse ho 
parlato facendo troppe domande.
Ciao e grazie ancora.


 parlato facendo troppe domande.
O forse sei solo scemo :-)


Scusa Andrea ma sei andato di testa ??


 Scusa Andrea ma sei andato di testa ??
Direi di no. Spiegami dettagliatamente sul piano tecnico perché ci sarei
andato. Illuminaci.


andato. Illuminaci.
E' tutto il giorno che sostieni che TerminateProcess funziona bene a un 
TROLL sapendo che crea un sacco di casini.. ??


TROLL sapendo che crea un sacco di casini.. ??
Infatti TerminateProcess() funziona bene: assolve eccezionalmente il
compito per la quale è stata creata e per sua natura stessa non può e
non deve chiudere in modo "pulito". La chiusura pulita di un processo
è in gran parte dei casi impossibile. Se si ha un modo certo di
istruire un processo e indirizzarlo verso la chiusura, è bene
usarlo[*], altrimenti TerminateProcess() che non crea affatto "un
sacco di casini": i problemi correlati a TP() sono ben conosciuti e a
volte irrilevanti.
[*] fornisci e spiega dettagliatamente sul piano tecnico un codice che
chiuda un processo esterno e non usi TerminateProcess(), né un comando
esterno del sistema operativo, né alcuna delle tecniche da me
consigliate.

TerminateProcess è una merda WINDOWS. Toglitelo dalla testa o non si 
spiegherebbe la DLL INJ o il TASKKILL.
Fidati, fatti una bella dormita e dimentica quell'API che è una merda !
Ciao.


Mi preoccupi, non ti mai visto cosě infervorato...
Fidati vai a dormire.
Ciao ! ;-)


 spiegherebbe la DLL INJ o il TASKKILL.
Come dire che non si spiegherebbe l'aereo, visto che esistono gli autobus.


Mi preoccupi, non ti mai visto così infervorato...
Spiega dettagliatamente e sul piano tecnico perché sei preoccupato.

        bResult = ::TerminateProcess(hProcess,
C.V.D.


La tua soluzione č una cagata, la mia funziona....
Io non ho proposto alcuna soluzione, sto aspettando la tua con 
ExitProcess()...


>Mai sentito parlare di chiamate di sistema ?
Io sě, ma tu evidentemente no, visto che non sai cosa fa la funzione 
system() in C (Google [source: 
http://www.hwupgrade.it/forum/showthread.php?p=17852353
] non ti dice 
tutto, ricordati)
--
<stdlib.h>
system
int system(const char *s);
If s is not a null pointer, the function passes the string s to be 
executed by a *command processor*, supplied by the target environment, 
and returns the status reported by the command processor. If s is a null 
pointer, the function returns nonzero only if the target environment 
supplies a command processor. Each implementation defines what strings 
its command processor accepts.
--
E il "command processor" č cmd.exe in Windows... la tua "eccellente" 
soluzioni significa:
1) Lanciare cmd.exe
2) Fargli eseguire taskkill.exe con gli appropriati parametri
Un metodo veramente *efficiente* di chiamare TerminateProcess()!
