Newsgroup: it.comp.lang.delphi
Titolo: SOLUZIONE: La tanto attesa BATOSTA FINALE per Andrea Laforgia

TERMINATEPROCESS non VA BENE CAZZO !!!! Quante volte bisogna spiegarlo ??
VOID ExitProcess( UINT uExitCode   // exit code for all threads );
 
LEGGETE attentamente:
uExitCode : Specifies the exit code for the process, and for all threads 
that are terminated as a result of this call. Use the GetExitCodeProcess 
function to retrieve the process's exit value. Use the GetExitCodeThread 
function to retrieve a thread's exit value. 
Remarks:
ExitProcess is the preferred method of ending a process. This function 
provides a clean process shutdown. This includes calling the entry-point 
function of all attached dynamic-link libraries (DLLs) with a value 
indicating that the process is detaching from the DLL. If a process 
terminates by calling TerminateProcess, the DLLs that the process is 
attached to are not notified of the process termination. 
INFINE continuo a battere mano sul BANCO č molto facile usare:
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 which were started by it.
    /?                     Displays this help/usage.
--- posted by geoForum on 
http://www.delphiedintorni.it

Scusa Andrea ma che CAZZO te ne frega di usare TASKKILL.
E perchè dici che non fa chiamate di sistema e non usa le API è assurdo 
quello che dici !!!!
Ma a Microsoft sono così scemi da creare TASKKILL ??
TerminateProcess non VA BENE per i motivi che ti ho detto. Se lo usi una 
due volte OK, ci giochi un po', prova però a lanciarlo 10 volte e dai 
un'occhiata al File di PAGING già li vedi che qualcosa non VA !
Non ho intenzione di proseguire su questa *QUERELLE* tutto quanto è 
stato già discusso.
Scusate ho davvero da *FARE*
CIAO !


 Scusate ho davvero da *FARE*
Non *FARTI* troppe seghe che poi diventi cieco.
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 Scusate ho davvero da *FARE*
Ahahahahah...
Ciao trollino, è stato bello sentire le tue cazzate ancora una volta.
In questo clima estivo, un po' di divertimento ci vuole :-)


Il codice l'ho postato più volte: Leggi sopra attentamente e usa le 
procedure indicate.
SU MS è spiegato tra l'altro molto bene...
http://msdn2.microsoft.com/en-us/library/ms682658.aspx
Fatico a seguire il filo del discorso. Ho letto metà della ROBA che hai 
scritto una riga si e una no !
Il motivo è solo UNO oltre a quello dei PRIVILEGI !
ExitProcess is the preferred method of ending a process. This function 
provides a clean process shutdown. This includes calling the entry-point 
function of all attached dynamic-link libraries (DLLs) with a value 
indicating that the process is detaching from the DLL. If a process 
terminates by calling TerminateProcess, the DLLs that the process is 
attached to are not notified of the process termination.
--- posted by geoForum on 
http://www.delphiedintorni.it

 attached to are not notified of the process termination.
Come ho detto nei miei primi messaggi. Il problema è che per terminare un
processo esterno agevolmente si usa TerminateProcess, non ExitProcess.
La seconda lavora solo sul processo corrente.
Trollino, ritenta: sarai più fortunato.


Scusa Andrea se mi intrometto. Non è proprio come dici.
Il troll ha detto molte cose insensate ma qua ha ragione.
Io consiglio di usare TASKKILL e non TERMINATEPROCESS perchè crea 
davvero molti problemi.
Ciao.


Scusa forse lo saprai...
Mi sembra deleterio soprattutto perchè crea qualche problemino NON 
TRASCURABILE, ad esempio, di notifica alle DLL.
Con TASKKILL invece non si ha alcun problema, infatti usa ExitProcess 
invocando i privilegi correttamente.


Ciao, mi occupo di programmazione in C++ e stavo googlando sui
processi per gestire alcuni TASK di una recente applicazione.
Siete messi davvero bene ... Ha, ha.... Davvero divertente e forse
anche un po' OT.
Il mio parere dopo numerose purghe con alcuni clienti è che
TerminateProcess() è indubbiamente il modo peggiore per terminare un
processo. Io lo prenderei in considerazione solo per situazioni
estreme quando non esistono altre soluzioni.
Detto questo anche taskkill mi ha creato dei problemi con alcuni
clienti che usano W2K perchè è implementato solo per XP e 2003 oltre
che per VISTA credo. Se l'ambiente è XP però lo consiglio vivamente
perchè chiude davvero in modo pulito e non dà problemi.
Aggiungo che TerminateProcess è rischioso soprattutto perchè il
processo terminato (e non killato !!! come qualcuno impropriamente
dice) potrebbe non avere più l'opportunità di eseguire i suoi child e
le DLL e questo crea parecchi problemi per il run-again  o per le
duplicazioni.
Cerchiamo di chiarire un po' questo ExitProcess perchè ho sentito
davvero tante robettine da far accaponire la pelle al mio Prof.
Tanto per chiarire stiamo parlando della vecchia Kernel 32 giusto ?
ci interessa il misterioso
uExitCode
che non è nient'altro che il codice di uscita del processo ma non solo
anche di tutti i suoi thread. Per trovare i valori corretti il sistema
mette a disposizione due funzioni: GetExitCodeProcess e
GetExitCodeThread. La prima per ritrovare i valori diuscita dei
processi e la seconda dei thread.
L'esempio ufficialmente fornito con la maggior parte di manuali delle
API è
Private Declare Sub ExitProcess Lib "kernel32" (ByVal uExitCode As
Long)
Private Declare Function GetExitCodeProcess Lib "kernel32" (ByVal
hProcess As Long, lpExitCode As Long) As Long
Private Declare Function GetCurrentProcess Lib "kernel32" () As Long
Private Sub Form_Load()
    'KPD-Team 1999
    'URL: 
http://www.allapi.net/
    'E-Mail: KPD...@Allapi.net
    'end this process
    ExitProcess GetExitCodeProcess(GetCurrentProcess, 0)
End Sub
Che si trova tra l'altro dappertutto sul WEB.
Domande ?
Ciao

davvero molti problemi.
Caro "Gabriele Magni" (Andrea, se ci sei batti un colpo: ti ha rubato
il cognome :-), mi permetta di contraddirla: il processo esterno
taskkill fa uso esattamente di TerminateProcess. In realtà ha un
comportamento leggermente più complesso, ovvero ricalca quello del
Task Manager, ma quando si agisce sul nome dell'immagine di un
processo o sul pid, l'unico modo che il sistema ha di assolvere al
compito è usare TerminateProcess. La funzione TerminateProcess non
crea alcun problema: killa il processo in modo "brutale", laddove per
"brutale" si intende che non c'è modo, da parte dell'applicazione, di
eseguire codici di clean-up delle risorse (ivi comprese le azioni da
compiere al detach delle DLL). Ma questo non è un grosso problema: se
si è deciso di killare il processo, vuol dire che non ci si preoccupa
molto delle sue operazioni di pulizia.
p.s.: i travestimenti non ti riescono bene, specie se continui a usare
l'indirizzo e-mail del tal "Andrew De Laforge" ahahah :-D

invocando i privilegi correttamente.
Ah ah, e certo, come no :-D







ci interessa il misterioso
uExitCode



    'E-Mail: KPDT...@Allapi.net




API è
L'esempio di cosa, trollino?
Il tuo codice è una semplice invocazione di ExitProcess(), non c'entra
una mazza con la chiusura di un processo esterno.
Ritenta trollino, sarai più fortunato (forse) ;-)

Scusa ma chi ti conosce ??
Ho scritto il mio punto di vista se non sei daccordo cerca di
replicare in modo educato.
Altri la pensano come me.
http://www.delphiedintorni.it/geoxml/forumhistorythread?groupname=libero.delphi.winapi&messageid=14ySG4N9...@w1.www1.dms.it

Ciao
[...]
p.s.: che tempo fa a Narni?

Sono molto deluso. Non mi aspettavo che persone che fanno il mio
stesso lavoro si comportassero in questo modo.

Usa pure TerminateProcess. Ti auguro tanta fortuna.

Altri la pensano come me.
E quindi? che fai? cerchi consensi aggrappandoti ai messaggi del primo
che capita? A parte che non la pensano come te, ma dicono cose
diverse, credi che il punto di vista di Bertuccini (che è conosciuto
qui dentro) non sia opinabile?
Considera, poi, che non c'è alcun dubbio che TerminateProcess() sia un
metodo brutale (come ho detto e stradetto in questo thread), ma a
quanto pare non è questo il punto del discorso: fornisci il tuo
codice, spiegando dettagliatamente sul piano tecnico, che consenta di
chiudere un processo esterno, senza usare TerminateProcess() o alcuna
delle tecniche da me suggerite (code-injection, etc.). Dai, forza,
illuminaci. Oggi impariamo qualcosa di nuovo e non sarà un venerdì 13
(brrr) sprecato.

stesso lavoro si comportassero in questo modo.
Comportarsi come? in quale modo? fornisci del codice che illustri come
chiudere un processo esterno. Dai, forza, illuminaci. Dai, non
perderti in sciocchezze, stiamo aspettando...

 ExitProcess GetExitCodeProcess(GetCurrentProcess, 0)
LOL, questo chiude il processo che chiama la ExitProcess()... la domanda 
originale è come chiudere *un altro* processo.
E - ROTFL - il parametro passato è sbagliato, perché non ha senso 
chiamare GetExitCodeProcess(GetCurrentProcess, 0)!
1) GetExitCodeProcess restituisce 0 se fallisce, mentre ExitProcess di 
solito restituisce 0 se tutto è OK!
2) Il codice di uscita è restituito nel secondo parametro di 
GetExitCodeProcess, non dalla funzione stessa!
Probabilmente il niubbo che ha scritto il codice ha letto male l'help 
delle API: "Use the GetExitCodeProcess function to retrieve the 
process's exit value." Peccato che questo lo debba fare il processo che 
l'ha invocato.
Consiglio: la prossima volta che copi del codice, assicurati almeno che 
sia corretto!


ExitProcess is the preferred method of ending a process. This function 
Vero. Peccato che termini solo il processo che la chiama. Stiamo ancora 
aspettando il codice per chiamarla per terminare *un altro* processo.


Mai SENTITO PARLARE DI CHILD dei processi ? che Andrea dice non esistere 
in Windows ?
Vuoi proprio sapere come si fa o lo sai già ?


Se ti interessa scrivi SI, ti spiego per pezzettini durante la giornata 
perchè sto programmando un po'....


 Vuoi proprio sapere come si fa o lo sai già ?
Io non lo so, spiegamelo tecnicamente e in dettaglio. Spiegami anche la
natura del "child" sotto Windows e cioè che cosa lo rende esattamente un
"child" process.


Inizio.... Stai preparando il caffè ?? :-D
Un processo ha i suoi thread. Un thread lanciato all’interno di un 
processo può creare nuovi thread e anche processi indipendenti e gestire 
le varie comunicazioni e sincronizzazioni


Un thread lanciato all’interno di un processo può creare [...] processi
indipendenti 
E qui ti fermi: "processo indipendente" contrasta con "child process".
Sotto Windows non esistono "child processes", benché il termine sia
normalmente usato per descrivere i processi lanciati da un altro processo.
Sotto altri sistemi, esiste invece la vera natura "child" del processo (v.
UNIX) con legame stretto di dipendenza al "parent".


Scusate il contagoccie, vi assicuro che una volta per tutte facciamo 
chiarezza e abbandoniamo TerminateProcess....
O posto tutto questa sera o pezzettino per pezzettino....
Un processo può ottenere l’identità e l’handle di un nuovo child da 
PROCESS_INFORMATION (Kernel32). Però chiudendo l’handle di un child, si 
ottiene solo di distruggere l’accesso al child da parte del padre.


Ti prego, non facciamo questioni filosofiche :-D.... Sono sotto 
pressione con un cliente ma mentre aspetto i caricamenti di 
ripopolazione del DB (che per me è fottuto) posto... Ciao :-D


Child nel senso che l'ha generato il processo attraverso il thread 
dall'interno. Se poi se ne va a vivere a casa sua mutui suoi :-)


 ripopolazione del DB (che per me è fottuto) posto... Ciao :-D
Seh ...
I tuoi clienti, al massimo, ti trovano lungo qualche viale: e li', si' che
sei fottuto!
Quanto prendi a botta?


 proprio sapere come si fa o lo sai già ?
Sì. Voglio proprio sapere come si fa.


>Mai SENTITO PARLARE DI CHILD dei processi ? che Andrea dice non 
Sempre nella stessa pagina, leggi bene:
"Exiting a process does not cause child processes to be terminated."


 ripopolazione del DB (che per me è fottuto) posto... Ciao :-D
Dai, posta del codice.


 ottiene solo di distruggere l’accesso al child da parte del padre.
Scritta così è un non-sense. Spiega tecnicamente e in dettaglio ciò che
vuoi dire. Un processo "padre" (nel senso inteso sotto Windows, che non
costituisce alcun legame di parentela) non ha "accesso" di alcun tipo al
processo figlio (sempre inteso nel senso di Windows). Specifica
tecnicamente che intendi per "accesso".


 "Exiting a process does not cause child processes to be terminated."
Esatto. Contrariamente a quanto avviene, ad esempio, sotto i vari Unix, in
cui la relazione padre-figlio è reale, nel senso che c'è stretta
dipendenza in questo senso.


Posto la soluzione ma oggi un po' incasinato.... Piano piano ...
Cavolo quelli prendono 100 a botta io prendo 100 a botta sulla testa 
delle 9 ore davanti al PC :-D
posto tra un pochino... fidatevi...


 Posto la soluzione ma oggi un po' incasinato.... Piano piano ...
Non ti preoccupare. Aspettiamo frementi.


tecnicamente che intendi per "accesso".
Tu dici che non ha *accesso* io dico che ha invece possibilità 
di "controllo" !
Innanzitutto devi identificare il processo, l'unica strada percorribile 
è quella di determinare il suo ID con la funzione
DWORD GetCurrentProcessId (VOID)
e creare successivamente un handle di processo con la funzione 
OpenProcess
avendo a disposizione i diritti necessari
L'errore che molti fanno è usare
HANDLE GetCurrentProcess (VOID)
questa funzione passatemi il termine ci dà uno "pseudo" handle che non è 
direttamente utilizzabile ai nostri fini.


 direttamente utilizzabile ai nostri fini.
GetCurrentProcess() non serve a nulla per lo scopo che ci si prefigge.
Non esistono poi "pseudo-handle", l'handle restituito da
GetCurrentProcess() è un regolare handle di un oggetto kernel processo.
Ritenta.
Finora non hai detto nulla di interessante. Attendiamo il codice.


Scusa Andrea o mi lasci parlare o te lo fai da solo.
Non ho tempo da perdere con TE.
Se qualcun'altro interessato c'è si faccia avanti o personalmente mi ha 
davvero rotto questo atteggiamento.
Abbi l'umiltà di ascoltare tutto il discorso e non chiedere pappa pronta 
per ottenere le tue ragioni.
Se si parla di aspetti tecnici lo si fa concretamente e non continuando 
a scavillare su parole e termini.
Se hai la pazienza di ascoltare bene oppure il mio tempo lo uso in altro 
modo.


Posto tutto insieme per chi fosse interessato. Torno al lavoro serio e 
laschio stare il CHILD Andrea ! :-D


 a scavillare su parole e termini.
Io sto discutendo di aspetti tecnici concretamente. Ho ribattuto all'uso
di quelle funzioni dell'interfaccia di programmazione Windows proprio
perché ci tengo alla discussione tecnica concreta.
Attendiamo il tuo codice.
p.s.: si dice "cavillare", non "scavillare".


Scusa Andrea, non volevo essere maleducato. Ti chiedo scusa.
Terminate process è una strada sbagliata. Però io non posso postare 
pappa pronta ma posso spiegare come eseguire correttamente ExitProcess.
Ma sono davvero incasinato o avrei postato tutto subito. Non sto facendo 
copia e incolla di roba e il discorso ha alcuni aspetti importanti da 
precisare o non si capisce una mazza.
Piano piano spiego, non è molto da dire !
Ciao.


>p.s.: si dice "cavillare", non "scavillare".
:-D cavillare č cercare cavilli e scavillare e toglierli.... Perň magari 
mi sbaglio, perchč amici che lavorano nell'ufficio legale della mia 
azienda dicono cosě ma magari č un loro modo....
Su msdn non si trova niente se non roba fumosa e uno dice Exitprocess 
non serve a niente.... :-D


importanti da  precisare o non si capisce una mazza.
Bene, precisali tecnicamente e dettagliatamente.


 non serve a niente.... :-D
Ah ecco. Considerato che MSDN è la fonte ufficiale di informazione per lo
sviluppo di casa Microsoft, direi che la tua affermazione è alquanto
azzardata. Che intendi esattamente per "roba fumosa"?


Lasciami prendere il discorso in modo largo ti prego. Vorrei puntare il 
dito su un aspetto che però è generale. Il discorso è funoso perchè la 
soluzione non risiede in un'unica funzione ma piuttosto in un 
comportamento legato ai così chiamati CHILD.
Se lo dici tu che non esiste nè azienda nè ufficio legale... Fatti tuoi.
Scavillare è giusto, cerca con google !


Solo il fatto che dici che "scavillare" è un termine non usato mi pone 
dei dubbi se il tuo concetto di "giusto" prenda anche in considerazione 
il concetto di "completezza" dell'informazione e non piuttosto quello 
di "disponibilità" dell'informazione.....
Forse per questo ExitProcess è sbagliato e non attuabile ?


>Scavillare č giusto, cerca con google !
Google indicizza anche gli errori, non č mica un correttore ortografico 
o un dizionario.
http://www.garzantilinguistica.it/
 qui ad esempio il termine non c'č...


purtroppo vado in silenzio stampa fino alle 18.30 circa...
Poi possiamo sintetizzare se sei daccordo il discorso e trarre le somme 
da un punto di vista puramente tecnico. Se hai ragione non esiterò a 
darla, ma credo che come dici su MSDN manchi qualcosina di veramente 
importante...
CIAO!


OK allora è un errore dire messaggiare qualcuno ?
O sei dell' Accademia della Crusca oppure accetti l'evoluzione della 
lingua.
Scavillare è usatissimo da tutti gli avvocati chiedi se conosci amici. 
Significa smontare un discorso partendo dai cavilli, trovando i cavilli 
e vedendo che cosa implicano.
Cavillare invece significa trovare storie per ingarbugliare una 
posizione durante un contenzioso.


 Scavillare è giusto, cerca con google !
Fatto:
http://www.geocities.com/andrealaforgia/scavillare.png


 e vedendo che cosa implicano.
"Scavillare" non esiste.


 Forse per questo ExitProcess è sbagliato e non attuabile ?
ExitProcess() non serve a chiudere un processo esterno, ma chiude il
processo che la invoca. L'unico caso in cui ExitProces() può essere usata
per chiudere un processo esterno è via code injection (e come già detto,
anche in quel caso si tratta formalmente di un funzionamento locale al
processo host), ipotesi da me paventata sin dal primo messaggio. Mai
parlato di "giusto" e "sbagliato".
ExitProcess() ha, poi, tutti i problemi di deadlock di cui si è già
parlato, ragion per cui Microsoft stessa consiglia di usare
TerminateProcess().


ma credo che come dici su MSDN manchi qualcosina di veramente importante...
Ok, dimmi secondo te che cosa andrebbe aggiunto. Secondo me se ci si
organizza per bene si può anche fare un reclamo verso Microsoft. Oh, se si
so' scordati qualcosa, è il caso di ricordarglielo. Si tratta di spirito
di collaborazione.


Figurati.... Sei fuori se clicco quel link... Ho il FIREWALL sputtanato 
da una settimana....
Week c'è di mezzo la colombiana... Da lune chiariamo queste cazz di api. 
Buon WeeKend...


colombiana.... Mmmmmm 8P
