"" """""""" " " " " """ """"" "
""#$%%%%%%%$$$""" ""$$$$#"" ""#$$%%%(%%%%$#"""
"#%'''''''''''&%#" "#%&''&($" "#$%(&&''''''''&((%$"
$%''('''''''''%#" " #%&'&('&($" ""$%(&''''''''''''''&(%#""
""$%''''&(((((%($"" "$&&'&&''&%#" "#$(&'''''&(%%%%(&'''''&%$"
"$%''''(%$$###""" "$%&'''''''(%# ""%(''''&(%$$##"#$$%(''''&%$""
"$%''''(%$$##"" " "$%&'''&('''&($" "$(&'''&%$#" " ""#$%&'''&%#"
$%''''&(((((%%# #%('''&((&'''&%$"""#$&'''&%%#"""" #%(''''($"
""$%&'&''''''''&$#" "$(&'''&%%(&'''&%$""#%&'''&(%%$$#"""" "$(&'''($"
"$%'&&''''''''&$#""$%&''''((((&'''&($##$%&'''&(&(&((%%$$#""#%(&'''($"
"$%''''&(%%%%$%#""#%(''(''''''''&&'&($$$%&'&'''''''''''&(%%%%(''''($"
"$%''''(%$#"""" "#%(''&&''''''''''''&%$$$(&&&''&&&&&''''''&((&'''&%#
$%&'''(%# " " "$%&'''&(((%((((&''''(%$$%(''''&(((((((&''''''''&($#
" $%&'''($"" "#%&''''(%$####$$%&'''&($$$%(&'''''&(((((&''(&&'&(%%#"
"#%''''($" ""$(''''($#""" "$%&'''&%$##$%(&''''''''''''&''''''&$#
#%&'''(# ""%&'''($#" ""$%&''&($"" "#$((&''''''''&(((&'''&$"
"""#$$#"" "#$$$#" ""#$$$##" "##$%%%%%%%$$$$$$$%%$# "
" "" "" " " """ " """" " " "
B u D u S c R i p t
_______________________________________________________________________________
Questo documento si propone di offrire una risposta alle domande piu'
frequenti poste dagli utenti di BuDuScRiPt, il plugin per XChat.
_______________________________________________________________________________ 001 COME SI INSTALLA BuDuScRiPt ? 002 COME SI DISABILITA IL MESSAGGIO PUBBLICITARIO ? 003 COME ABILITO GLI AVVERTIMENTI ACUSTICI ? 004 COME POSSO ASSOCIARE DEI COMANDI DEL PLUGIN AI TASTI ? 005 COME FUNZIONA L'EVENTS MANAGER ? 006 E' POSSIBILE ESEGUIRE PIU' COMANDI IN SERIE ? 007 BuDuScRipT PUO' FUNZIONARE COME UN BOT ? 008 E' POSSIBILE ESSERE AVVERTITI QUANDO ENTRA UN CERTO UTENTE ? 009 E' POSSIBILE ASSOCIARE DELLE INFORMAZIONI AD UN UTENTE ? 010 E' POSSIBILE METTERSI/TOGLIERSI DALL'AWAY SU TUTTI I SERVER ? 011 E' POSSIBILE ESSERE AVVERTITI QUANDO QUALCUNO SCRIVE IN QUERY ? 012 E' SUPPORTATO XCHAT-TEXT ? 013 HO INSTALLATO IL PLUGIN COME DA ISTRUZIONI, MA QUANDO LO LANCIO
MI COMPARE UN MESSAGGIO DI ERRORE; PRATICAMENTE, SEMBRA NON RIESCA
A TROVARE IL FILE budus_italiano.msg 014 COME EVITO L'INTERPRETAZIONE DI ' CON "/budus pipe" ? 015 E' SUPPORTATO XMMS ? 016 QUANDO LANCIO UN QUALSIASI COMANDO "/budus" NON SUCCEDE NIENTE; PERCHE' ? 017 COME SI DISABILITANO LE RISPOSTE AUTOMATICHE (SPAM) ? 018 LA CHAT DOVE MI COLLEGO E' COMPOSTA DA PIU' LINKS E QUINDI IL
FILE_DOMINI USATO PER IL RICONOSCIMENTO DEGLI UTENTI CAMBIA AD
OGNI CONNESSIONE. COSA POSSO FARE ? 019 COME POSSO LIMITARE IL NUMERO DI DIALOG CHE GLI ALTRI UTENTI MI
POSSONO APRIRE ? 020 PER QUALE MOTIVO IL PLUGIN NON EMETTE NESSUN SUONO DI
AVVERTIMENTO ? 021 USANDO ALSA DRIVER CON XMMS ATTIVO IL PLUGIN SI BLOCCA QUANDO
DEVE EMETTERE I SUONI DI AVVERTIMENTO, COME RISOLVO ? 022 HO INSTALLATO BUDUSCRIPT, MA QUANDO LANCIO XCHAT E MI CONNETTO AL
SERVER IRC SI CHIUDE IMMEDIATAMENTE, CON UN "SEGMENTATION
FAULT"; COSA DEVO FARE ? 023 QUANDO IL PLUGIN FA PER CARICARSI, MI DA UN ERRORE TIPO
"budus.so: cannot open shared object file: No such file or
directory". PERCHE' NON SI CARICA ? 024 QUANDO TORNO DALLO STATO DI AWAY IL PLUGIN ESEGUE
L'IDENTIFICAZIONE TROPPO PRESTO, IL SERVER "NON LA VEDE" E DI
FATTO MI CAMBIA FORZATAMENTE NICKNAME. COME RISOLVO ? 025 NEL MIRC PER WINDOWS, QUANDO FACCIO DOPPIO CLICK SU UN NICKNAME,
MI VIENE AUTOMATICAMENTE INSERITO NEL PROMPT, COSI' CHE NON
DEVO SCRIVERLO (SBAGLIANDO); SI PUOI FARE LA STESSA COSA IN
XCHAT ? 026 OGNI TANTO VENGONO EMESSI DEI STRANI "SUONI", TUTTI DISTORTI, CHE
ROBA E' ? 027 E' POSSIBILE ESEGUIRE COMANDI MULTIPLI CON UN UNICO COMANDO ? 028 E' POSSIBILE CONVERTIRE I FILE .INI DEGLI SCRIPT mIRC PER XCHAT ? 029 VOGLIO SPEDIRE UN MESSAGGIO NEL CANALE OGNI TOT SECONDI, COME FACCIO ? 030 VOGLIO KICKARE O BANNARE QUELLI CHE USANO PAROLACCE, SI PUO' ? 031 HO CREATO UNA SENTINELLA, MA QUANDO SCRIVO QUALCOSA NON FA NULLA,
PERCHE' ? 032 PERCHE' SE DISABILITO IL CLONE DETECTOR POI ME LO RITROVO ? 033 VORREI CHE XCHAT ESEGUISSE DEI COMANDI QUANDO SCRIVO UNA PAROLA CHIAVE;
COME FACCIO ? 034 E' POSSIBILE CREARE UNA BLACKLIST DEI NICKNAME ? 035 E' POSSIBILE CREARE VARIABILI ED ESEGUIRE SCELTE ? 036 POSSO IGNORARE I MESSAGGI PRIVATI DA PARTE DI QUALCUNO IN AUTOMATICO ? 037 POSSO FILTRARE I MESSAGGI INDESIDERATI ? 038 POSSO FARE BANKICK IN AUTOMATICO SU UTENTI CHE "SPAMMANO ALTRI CANALI" ? 039 POSSO FARE BANKICK IN AUTOMATICO SU UTENTI PROVENIENTI DA CANALI SGRADITI ? 040 POSSO COLLEGARMI, CON IL MEDESIMO XCHAT, AL MEDESIMO SERVER CON NICKNAME
DIVERSI ? 041 PER QUALE MOTIVO, SE SUO "/BUDUS IGNORE" SU CERTI UTENTI, POCO
DOPO VIENE RIMOSSO LO STATO DI IGNORE ? 042 E' POSSIBILE PERSONALIZZARE L'ANNUNCIO DELLA CANZONE IN ASCOLTO ? 043 E' SUPPORTATO TWITTER ? 044 E' POSSIBILE DISABILITARE IL "WHOIS REDIRECT" ? 045 SI PUO' DISABILITARE IL MESSAGGIO DI "NUOVO POST SUL FORUM" ? 046 POSSO APRIRE I LINK IRC:// IN XCHAT DIRETTAMENTE DA BROWSER ? 047 COS'E' L'XDCC MANAGER ?
_______________________________________________________________________________
_______________________________________________________________________________ 001____________________________________________________________________________
DOMANDA: COME SI INSTALLA BuDuScRiPt ?
RISPOSTA:
XChat, quando lanciato, carica in automatico tutti i file che hanno
estensione .so contenuti nella directory $HOME/.xchat2 (viene creata
dal client automaticamente al primo lancio).
I files .so sono dei Moduli creati in linguaggio C (se proprio si
vuole, anche C++ penso sia supportato) che, una volta caricati in
memoria dal client, diventano parte integrante di quest'ultimo; nel
caso di BuDuScRiPt vengono aggiunti comandi come "/budus" ed "/event",
nonche' modificati certi "comportamenti".
Per installare il plugin e' quindi necessario che nella directory
.xchat2 sia presente il file budus.so; l'installazione di BuDuScRiPt
prevede che si decomprima il file buduscript_xxxx_yyyy.tar.gz con una
sintassi come la seguente:
tar xvzf buduscript_xxxx_yyyy.tar.gz -C $HOME/.xchat2
Questo comando va a creare la directory .xchat2/buduscript dentro la
quale e' presente il file script install.sh che va lanciato come
segue:
cd .xchat2/buduscript
./install.sh
Tutto qui, l'installazione dovrebbe essere funzionante; per
verificarlo si puo' lanciare XChat, oppure, se e' gia attivo,
digitare il seguente comando:
/LOAD .xchat2/budus.so
Per rimuovere il plugin dalla memoria del client si puo' usare il
seguente comando:
/UNLOAD budus.so
Se anziche' usare XChat 2.x si utilizza la vecchia versione 1.x,
l'unica differenza sta nel fatto che la directory di default dove il
client salva la configurazione e comunque dove va installato il
plugin e' .xchat anziche' .xchat2 .
Sul sito di BuDuScRiPt
http://digilander.libero.it/udasoft/Software/Linux/buduscript
e' anche presente una completa guida su come installare il plugin dai
sorgenti, quelli di XChat compresi.
_______________________________________________________________________________ 002____________________________________________________________________________
DOMANDA: COME SI DISABILITA IL MESSAGGIO PUBBLICITARIO ?
RISPOSTA:
Per default, il plugin tenta di auto-pubblicizzarsi "quando puo'",
cercando di farlo con la massima discrezione (in modo da non risultare
fastidioso); tuttavia, se si desidera eliminare completamente questo
comportamento, e' possibile agire sulla variabile 'iFlagBudusMessage'
utilizzando questo comando:
/budus budusmsg 0
Al fine di rendere definitiva questa modifica, e' opportuno salvare il
file di configurazione utilizzando il comando:
/budus save
_______________________________________________________________________________ 003____________________________________________________________________________
DOMANDA: COME ABILITO GLI AVVERTIMENTI ACUSTICI ?
RISPOSTA:
Il plugin riproduce i file sonori affidandosi ad un apposito programma,
distribuito insieme a BuDuScRiPt, di nome 'udaplaysound' e che si trova nella
directory $HOME/.xchat2/buduscript .
Per default, il plugin da per scontato che il file del device audio
(cioe' il file di dispositivo che consente l'accesso diretto alla
periferica audio) sia in /dev/audio ; e' molto probabile che questo
percorso sia errato (varia a seconda della Distribuzione Linux e,
addirittura, tra una versione e l'altra della stessa
Distribuzione). Ne consegue che l'utente deve preoccuparsi di
configurare opportunamente il plugin, agendo sulla variabile
'psAudioDevice' tramite il comando:
/budus audiodevice [percorso]
Dove [percorso] rappresenta il path del device audio; se non viene
specificato (lasciando quindi la variabile citata con un valore
nullo), il plugin evitera' di effettuare il controllo; in questo modo
e' possibile evitare il messaggio di errore:
Impossibile generare suoni di avvertimento; Device Audio occupato (vedi: /budus help audiodevice).
Ma perche' e' importante questo controllo ?
Quando il plugin avvisa l'utente attraverso un suono deve accertarsi
di riuscire a farlo; se verifica che cio' non e' possibile (device
audio occupato) andra' a produrre un "beep" usando l'altoparlante del
PC (se presente) ed emettendo un messaggio testuale, in modo da
riuscire comunque ad avvertire l'utente.
Se il controllo viene disabilitato e il plugin non riesce a "suonare
nulla", di fatto l'utente non sara' avvertito in nessun modo se il
canale audio e' occupato (cio' normalmente accade quando si ascoltano
mp3, si guarda un film, ecc...).
Puo' essere utile, al fine di risolvere problemi, lanciare XChat da un
terminale (xterm) e verificare eventuali messaggi emessi nel terminale stesso.
Il programma 'udaplaysound' , nel caso in cui non riesca ad aprire il
device audio, verifica la presenza di un file con nome
"udaplaysound.sh" nella sua stessa directory
($HOME/.xchat2/buduscript) e, se lo trova, lo esegue; questo consente,
ad esempio, di eseguire qualsiasi operazione si desideri per essere
avvertiti. Allo script viene passato, come primo parametro, il nome
del file audio che sarebbe stato riprodotto (ex: warning.au). A titolo
dimostrativo, si potrebbe avere un file "udaplaysound.sh" come il
seguente:
#!/bin/bash
xmessage -timeout 1 "Avvertimento: ${1}"
ricordarsi che, per essere eseguito, bisogna impostare opportunamente
i permessi (ex: chmod +x udaplaysound.sh ).
Nel caso in cui nel sistema non sia installato il supporto ad OSS
(alsa-oss) e' necessario, come Device Audio, specificare la stringa
"ALSA" (senza virgolette e in MAIUSCOLO); "udaplaysound", anziche'
inviare esso stesso i dati, si affidera' al programma esterno "aplay",
fornito insieme alla libreria ALSA (e' probabile occorra installare il
pacchetto alsa-utils o similare).
_______________________________________________________________________________ 004____________________________________________________________________________
DOMANDA: COME POSSO ASSOCIARE DEI COMANDI DEL PLUGIN AI TASTI ?
RISPOSTA:
E' stata una precisa scelta implementativa quella di non associare in
automatico delle Key-bindings a comandi di BuDuScRiPt, preferendo che
sia l'utente a farlo liberamente, come preferisce, utilizzando le
possibilita' offerte da client (che in merito sono numerose, semplici
e potenti).
Consultare quindi la guida di XChat e dare un'occhiata al menu
Impostazioni.
_______________________________________________________________________________ 005____________________________________________________________________________
DOMANDA: COME FUNZIONA L'EVENTS MANAGER ?
RISPOSTA:
XChat e' un IRC Client, ovvero, un programma che si collega ad un IRC
Server e, con il quale, instaura una comunicazione bidirezionale. Si
puo' immaginare che ogni messaggio che l'IRC Server spedisce al nostro
Client sia un Evento; ad esempio: un utente entra in un canale, un
altro dice qualcosa, un altro ancora esce, ecc....
Il plugin offre la possibilita' all'utente di creare delle Sentinelle
che hanno il compito di svolgere una o piu' operazioni quando, al
verificarsi di un ben determinato evento, viene soddisfatta una
Condizione.
Una Sentinella e' composta dai seguenti attributi:
o) Numero di ripetizioni
Rappresenta il numero di volte che la Sentinella dovra'
"attivarsi" nel caso in cui venga soddisfatta; cio' permette
all'utente di creare Sentinelle con non agiscono sempre, ma
solo un certo numero di volte. Ad esempio potremmo volere che
una Sentinella saluti un utente al suo JOIN, in un certo
canale, una sola volta e non ad ogni join di quest'ultimo
(potrebbe infatti uscire e rientrare piu' volte).
o) Evento
Ogni Sentinella e' sensibile ad un unico Evento, ovvero,
verifica se la sua Condizione e' soddisfatta, solo nel caso in
cui l'Evento generato sia identico a quello per il quale e'
stata creata. Ad esempio, potremmo volere che una Sentinella
verifichi la sua condizione ogni volta che in un canale viene
scritto qualcosa da altri utenti.
o) Condizione
La Sentinella ha il compito di eseguire un'Azione nel caso in
cui la sua Condizione venga soddisfatta. Ad esempio se la
Sentinella e' stata creata per agire quando si verifica
l'evento JCHANNEL (cioe' quando un utente entra in un canale),
si potrebbe controllare che il nickname dell'utente remoto,
che e' entrato nel canale, corrisponda ad uno desiderato; se
cio' si verifica, ecco che la Sentinella deve eseguire la sua
Azione.
o) Azione
Puo' essere uno o piu' comandi IRC/BuDuScRiPt (separati da \;
); ad esempio un'Azione potrebbe essere un comando che
"Saluta" un utente, che esegue un kick, che crea un'altra
sentinella, ecc... .
In genere, le prime sentinelle che si desidera creare, sono le seguenti:
- Salutare quando si entra in un canale
- Rispondere al saluto di un altro utente
Potremmo quindi aggiungere le seguenti sentinelle:
/event add 0 jchannel '$lu'='$ru' /ACTION saluta tutti
/event add 0 text 'Ciao$_$lu'='$data' /ACTION saluta $ru
Le quali hanno il seguente significato:
- OGNI VOLTA che qualcuno ENTRA NEL CANALE ed il NICKNAME
dell'utente locale ($lu sta per LocalUser) corrisponde al
NICKNAME dell'utente entrato ($ru sta per RemoteUser) esegui
il comando "/ACTION saluta tutti".
- OGNI VOLTA che qualcuno SCRIVE NEL CANALE e la stringa "Ciao
$lu" (se '$lu' vale "mionick" si ottiene "Ciao mionick",
considerando che $_ rappresenta lo spazio) corrisponde al
MESSAGGIO scritto nel canale, esegui il comando "/ACTION
saluta $ru" (se '$ru' vale "suonick" si ottiene "/ACTION
saluta suonick").
Le due Sentinelle di esempio hanno pero' un grave difetto: la prima
agisce ogni volta che si entra in un canale (quindi se si entra nello
stesso canale piu' volte, il saluto viene ripetuto), mentre la seconda
saluta l'utente "che ci ha salutato" ogni volta che questo lo fa
(facendo capire che si tratta di un "evento automatico" ... qualcosa
di "squallido", insomma). Per ovviare a questo inconveniente e'
necessario studiare qualcosa di piu' articolato, perche' non e'
sufficiente modificare le sentinelle come segue:
/event add 1 jchannel '$lu'='$ru' /ACTION saluta tutti
/event add 1 text 'Ciao$_$lu'='$data' /ACTION saluta $ru
Con la prima istruzione il saluto viene fatto solo la prima volta che
si entra in un canale qualsiasi (ogni successivo join e' praticamente
ignorato), mentre con la seconda si risponde al saluto solo del primo
utente "che ci saluta", ignorando tutti gli altri.
Per risolvere il problema e' quindi necessario affidarsi ad alcune
proprieta' dell'Events Manager:
- NON E' POSSIBILE INSERIRE PIU' SENTINELLE IDENTICHE
- E' POSSIBILE CREARE SENTINELLE CHE RISPONDO AD "EVENTI
SPECIALI".
- E' POSSIBILE GENERARE EVENTI NORMALI E SPECIALI
- NON E' POSSIBILE PER UNA SENTINELLA INVOCARE SE STESSA,
ANCHE TRAMITE IL COMANDO TIMER.
Tentiamo ora di risolvere un problema alla volta, partendo da quello
del "saluto canale"; prendiamo in esame le seguenti Sentinelle:
/event add 0 jchannel '$lu'='$ru' /event add 1 spcl_jchannel_$channel * /ACTION saluta tutti\;/event event spcl_jchannel_$channel
Il comando sopra ha lo scopo di inserire una Sentinella che agisce in
questo modo:
- OGNI VOLTA (0) che qualcuno ENTRA NEL CANALE (jchannel) ed
il NICKNAME ($lu) dell'utente locale ($lu = LocalUser)
corrisponde (=) al NICKNAME ($ru) dell'utente entrato ($ru =
RemoteUser) esegui questo comando:
/event add 1 spcl_jchannel_$channel * /ACTION saluta tutti
e, successivamente, esegui questo:
/event event spcl_jchannel_$channel
Vengono eseguiti 2 comandi consecutivi perche' l'AZIONE della
Sentinella inserita utilizzava il separatore '\;' per dividerli.
Praticamente la Sentinella che viene inserita (/event add 1
spcl_jchannel_$channel....) dipende dal canale per il quale e' stato
generato l'evento, tante' che il plugin provvede, supponendo che
il canale sia #miocanale, a risolverla in questo modo:
/event add 1 spcl_jchannel_#miocanale * /ACTION saluta tutti
Cio' e' possibile perche' l'Events Manager consente l'utilizzo di
VARIABILI (ricordo che le variabili sono: $lu, $ru, $rhost, $channel,
$hostname, $server, $data, $nick, $address, $all, $_) anche nel nome
dell'EVENTO (ricordo che gli eventi sono: jserver, jchannel, pchannel,
pserver, kick, who, chgnick, text, query, ctcp, mode, flood, notify,
all e quelli speciali creati dall'utente) monitorato.
Notare che "1" sta a significare: prendi in considerazione questa
sentinella una sola volta.
Se ci fosse stato 2, 3, ecc.., la sentinella sarebbe stata
considerata rispettivamente, 2, 3, ecc.. volte; mettendo 0 (zero), la
sentinella viene presa in considerazione SEMPRE, mentre usando il
carattere ? questa viene considerata una sola volta e poi eliminata
automaticamente.
Facendo affidamento sulla prima proprieta' dell'Events Manager,
citata sopra, anche entrando piu' volte nel canale #miocanale la
sentinella non verra' aggiunta, rimanendo quindi quella gia' inserita
(senza variarne "lo stato", cioe', se e' gia' stata eseguita ed era
programmata per funzionare una sola volta, rimarra' in questa
condizione).
Anche il secondo comando, eseguito dalla prima Sentinella (/event event
spcl_jchannel_$channel), viene risolto, secondo l'esempio citato prima,
come segue:
/event event spcl_jchannel_#miocanale
Gli eventi vengono normalmente generati da cio' che "succede nel
server/canale", ma con il comando sopra l'utente ha la possibilita' di
generarne uno "forzatamente" (in particolare l'EVENTO e'
"spcl_jchannel_#miocanale", che e' speciale perche' anch'esso creato
dall'utente, non fa parte di jchannel, jserver, ecc...).
Riassumendo abbiamo che:
1) Viene creata "al volo" una Sentinella che ha come scopo
quello di crearne un'altra che:
a) Monitorera' un EVENTO speciale, avente il nome
personalizzato in base a quello del Canale.
b) Nella CONDIZIONE avra' l'equazione "*" che significa
"sempre vero" (e' come se la condizione non ci fosse).
c) Nell'AZIONE avra' il comando "/ACTION saluta tutti", che
e' un comando IRC.
2) Viene lanciato un comando che genera forzatamente l'evento
"a" (che si chiama "spcl_jchannel_#miocanale").
3) La sentinella creata al punto "1" viene valutata - perche'
l'EVENTO generato e' proprio il suo - ed essendo la sua
CONDIZIONE sempre vera, fa eseguire il comando del punto
"1c" ("/ACTION saluta tutti").
Quello che probabilmente e' piu' ostico da capire nel meccanismo delle
Sentinelle e' il funzionamento della Condizione; quest'ultima e'
sempre formata da un'equazione di questo tipo:
costante=variabile
oppure
costante!variabile
Nel primo caso abbiamo che la costante deve essere contenuta nella
variabile o viceversa - non e' una reale uguaglianza, trattandosi di
parole, il solo fatto che una parola sia contenuta in una frase puo'
soddisfare la Condizione - , mentre nel secondo caso l'esatto
contrario.
Ad esempio immaginiamo una Condizione come questa:
parola=$data
spontaneamente si potrebbe pensare che l'equazione sara' vera solo
quando $data contiene esattamente "parola", ma non e' cosi' !
E' infatti sufficiente che $data contenga anche una semplice 'p' - o
comunque una qualsiasi lettera appartenente a "parola" (p a r o l) -
affinche' la Condizione venga soddisfatta, perche' il programma si
limita a verificare che "parola" sia contenuta in $data o che $data
sia contenuta in "parola".
Per evitare questo "inconveniente" (dipende dal contesto, non sempre
e' un comportamento "sgradito"), dobbiamo fare in modo che "parola" o
$data o anche entrambe, siano delimitate; se ad esempio scriviamo:
'parola'='$data'
nel momento in cui $data vale 'p', otteniamo:
'parola'='p'
Il programma ora dovra' verificare che sia contenuto anche il
carattere ' , nella medesima sequenza, e cio' non si potra' verificare
fino a quando non avremo che $data vale "parola".
In realta' avremmo potuto utilizzare qualsiasi altro carattere al
posto dell'apice e il comportamento non sarebbe cambiato, ovvero:
%parola%=%$data%
tuttavia l'utilizzo dell'apice ' ha uno scopo particolare: nel momento
in cui viene utilizzato per delimitare la COSTANTE, viene inibito il
controllo delle Espressioni Regolari.
Ovvero, se si scrive:
'parola='$data'
la costante "parola" non sara' utilizzata come Espressione Regolare
per verificare se $data la soddisfa; l'apice ' sara' anche
automaticamente rimosso, nel caso in cui non sia usato anche alla fine
della costante, cioe' cosi':
'parola'='$data'
scrivere:
'parola='$data'
equivale a:
parola='$data'
con la differenza che "parola" NON sara' usata come Espressione
Regolare.
Per fare in modo che l'apice non sia rimosso, bisogna anteporre il
carattere backslash \ , in questo modo:
\'parola='$data'
Il sistema capira' che, non essendoci apice ' a fine costante, dovra'
sostituire \' con un semplice ' e NON dovra' fare la verifica
dell'Espressione Regolare.
Piu' avanti e' brevemente spiegato cosa sono le Espressioni Regolari;
ora proviamo a ragionare ancora un po' su quanto detto sopra, ad
esempio se abbiamo:
%parola=%$data%
(notare che e' stato tolto un % alla fine della COSTANTE "parola")
otteniamo che la Condizione sara' soddisfatta solo se la variabile
$data e' uguale o inizia con "parola"; se ad esempio $data contiene la
frase "parola da cercare", l'equazione si risolverebbe cosi':
%parola=%parola da cercare%
Ebbene, la VARIABILE contiene la COSTANTE "%parola" ed ecco che viene
soddisfatta !
Se avessimo scritto:
parola%=%$data%
la Condizione veniva soddisfatta solo se $data conteneva "parola%".
Da sottolineare che la ricerca della costante nella variabile e della
variabile nella costante (cioe' i primi 2 controlli effettuati dal
sistema), NON SONO case-sensitive, ovvero, non fa differenza che le
lettere siano MAIUSCOLE o minuscole.
Invece il controllo per Espressione Regolare e' case-sensitive,
quindi scrivere:
parola='$data'
non e' la stessa cosa di scrivere:
'parola='$data'
perche' nel caso in cui $data valga "PAROLA" la prima sintassi NON
funzionera' mentre la seconda si' !
Proviamo ora a risolvere il problema del "saluto utente"
creando una Sentinella che risponde solo ad un Evento Speciale (che ad
esempio potrebbe contenere il nickname dell'utente remoto, in modo da
essere univoca), come ad esempio:
/event add 0 text ciao='$data' /event add 1 spcl_text_saluto_$ru '$data'=$lu /SAY Ciao $ru\;/event event spcl_text_saluto_$ru
Particolare attenzione va dedicata alla CONDIZIONE; ad esempio
"ciao='$data'" significa che la Condizione viene soddisfatta se
all'interno del testo, rappresentato dalla variabile $data, e'
presente la stringa "ciao" (in qualsiasi posizione).
Se ad esempio $data contiene "Ciao Andrea" e $lu vale "Andrea",
otteniamo che le 2 Condizioni da soddisfare saranno cosi' risolte:
ciao='Ciao Andrea'
'Ciao Andrea'=Andrea
Quando la prima Condizione viene soddisfatta, l'azione prevede la
creazione di una Sentinella con la seconda Condizione e la generazione
di un Evento che la faccia valutare; essendo soddisfatta anche la
seconda Condizione, otterremo l'esecuzione del comando:
/SAY Ciao $ru
dove, chiaramente, $ru sara' sostituito dal nickname dell'utente
remoto che ha generato l'Evento.
Potremmo aspettarci che una sentinella cosi' realizzata vada sempre
bene, ed effettivamente e' ragionevolmente robusta da funzionare nel
99% dei casi, tuttavia, proviamo a prendere in considerazione che
l'utente remoto abbia scritto una frase come questa:
"sai Andrea, oggi ho detto ciao a Massimo e non mi ha risposto !"
essendo questa il valore della VARIABILE $data, ecco che comunque le
Condizioni citate sopra sarebbero soddisfatte, andando cosi' a
realizzare un "comportamento non previsto" (di fatto salutiamo un
utente che non ci ha salutato).
Ecco quindi che, per realizzare soluzioni piu' sofisticate, e'
possibile l'utilizzo delle ESPRESSIONI REGOLARI POSIX (
http://it.wikipedia.org/wiki/Espressione_regolare ), uno strumento
profusamente usato in vari programmi UNIX (grep, sed, ecc...).
Le ESPRESSIONI REGOLARI sono uno strumento che consente, attraverso
l'utilizzo di appositi "pattern" (cioe' sequenze di caratteri e
simboli appositi), la definizione di un insieme o non insieme di
stringhe (le stringhe sono sequenze alfanumeriche - alfa = caratteri,
numeriche = numeri).
I principali caratteri usati nei pattern sono (qui si mostrano solo
quelli piu' usati e nelle soluzioni piu' semplici):
. ? * + | ( ) [ ] { , } ^ $ \
dove:
. identifica qualsiasi carattere
? nessuno o uno volte l'espressione precedente
* qualsiasi volte l'espressione precedente
+ una o qualsiasi volte l'espressione precedente
| Espressione logica OR
( apre un'espressione raggruppata
) chiude un'espressione raggruppata
[ apre un'espressione per definire un insieme di caratteri
] chiude un'espressione per definire un insieme di caratteri
{ apre un'espressione per il numero min. di ripetizioni
, separa il min. dal max. di ripetizioni
} chiude un'espressione per specificare le ripetizioni
^ identifica l'inizio della stringa
$ identifica la fine della stringa
\ carattere di escape per togliere significato al successivo
Ad esempio supponiamo di avere le seguenti frasi:
"ciao nico"
"ciao nico, come stai ?"
"giorno nico, tutto ok ?"
Vogliamo creare un pattern che identifichi almeno questo insieme di
stringhe; potremmo usare:
^(ciao|giorno).* (nico[ ,]|nico$)
Proviamo a scomporlo:
^(ciao|giorno)
Qui abbiamo un 'espressione che viene soddisfatta solo se
all'inizio della frase (^) viene trovata la parola "ciao"
oppure (|) "giorno"; se le parole dovevano essere piu' di
due, avremmo potuto usare piu' volte il carattere | per
separarle, come ad esempio: (parola1|parola2|parola3)
E' da sottolineare come il pattern ( | ) non funzioni solo
con parole ma anche con espressioni (vedi piu' avanti).
.*
significa "qualsiasi cosa"; cio' e' dovuto al fatto che il
carattere "." identifica "qualsiasi carattere" e "*"
identifica "in qualsiasi numero", il che sommato produce:
"qualsiasi carattere in qualsiasi numero".
(nico[ ,]|nico$)
Questa e' un'altra espressione logica OR dove pero' vengono
usate sottoespressioni, che andiamo a valutare singolarmente:
nico[ ,]
significa che il sistema dovra' riconoscere la parola nico
seguita o da uno spazio o da una virgola. Cio' che sta tra
parentesi quadre sono i caratteri che il sistema si deve
attendere; ad esempio se avessimo voluto accettare altri
simboli di punteggiatura, bisognava usare:
[ ,;:!]
Prendendo in esame l'altra alternativa:
nico$
abbiamo che il sistema dovra' aspettarsi che la frase termini
($) con la parola nico.
Se dovessimo dare una descrizione del pattern potremmo dire: "una
frase che cominci con ciao o giorno, continui con qualsiasi cosa, poi
abbia la parola nico seguita da uno spazio o una virgola, oppure, la
parola nico che termina la frase".
Fin qui abbiamo trattato le ESPRESSIONI REGOLARI (regexp) standard,
ora vediamo nell'implementazione del BuDuScRiPt come utilizzare lo
stesso pattern:
^(ciao|giorno).*$_(nico[$_,]|nico$)
Che inserito in una Condizione si ottiene:
^(ciao|giorno).*$_(nico[$_,]|nico$)='$data'
Per capire come BuDuScRiPt controllera' questa condizione, andiamo a
fare le "sostituzioni"; ad esempio la variabile $data sara' sostituita
da cio' che viene, ad esempio, scritto nel canale, supponiamo: "ciao
nico".
Quindi abbiamo:
^(ciao|giorno).*$_(nico[$_,]|nico$)=ciao nico
NB: Il sistema prima verifica che la COSTANTE sia contenuta
nella VARIABILE, quindi che la VARIABILE sia contenuta nella
COSTANTE e, se entrambe falliscono, verifica che la VARIABILE
soddisfi l'Espressione Regolare contenuta nella COSTANTE, a
patto che quest'ultima non inizi con il carattere ' .
Quando viene valutata l'Espressione Regolare, gli apici
eventualmente presenti ad inizio e fine della VARIABILE
vengono automaticamente tolti.
La variabile $_ identifica gli spazi in BuDuScRiPt, quindi abbiamo:
^(ciao|giorno).* (nico[ ,]|nico$)=ciao nico
Questa espressione e' abbastanza semplice, quindi possiamo produrne
le relative "combinazioni semplificate possibili", cioe' e' come se
noi avessimo avuto 6 sentinelle con CONDIZIONI fatte cosi':
'ciao nico '='ciao nico'
'ciao nico,='ciao nico'
'ciao nico'='ciao nico'
'giorno nico '='ciao nico'
'giorno nico,='ciao nico'
'giorno nico'='ciao nico'
La terza CONDIZIONE sarebbe stata soddisfatta; tuttavia, anziche'
inserire ben 6 sentinelle diverse - e non e' neanche detto che sarebbe
bastato -, con le regexp ne abbiamo inserita una sola !
Purtroppo non e' un meccanismo molto banale da apprendere ed e' molto
facile "cadere in buca", ad esempio, la sentinella sopra risponderebbe
anche se uno scrive: "ciao a tutti quanti, come va nico ?"
E' magari cio' che si vuole, ma e' giusto per far notare come, se non
si pone attenzione, l'espressione regolare venga soddisfatta anche a
"frasi non previste".
Se anziche' consentire "qualsiasi cosa" tra il "ciao/giorno" e il
nickname avessimo semplicemente preferito un qualsiasi numero di
spazi, potevamo scrivere cosi':
^(ciao|giorno)[$_]*(nico[$_,]|nico$)='$data'
Dato che l'Events Manager non risponde alle frasi scritte dall'utente
locale ma solo dagli altri, diventa difficile fare dei "test" per
verificare la robustezza delle sentinelle e delle eventuali regexp
usate; per controllarle si consiglia di procedere in 2 modi:
1) Provarle da terminale
Si' e' possibile provare le espressioni nel terminale linux
usando i comandi echo e grep in questo modo:
echo "'ciao nico'" | grep "'\(ciao\|giorno\).* \(nico[,]\|nico'\)='ciao nico'"
L'unica differenza sta nel fatto che le variabili $_ diventano
effettivamente spazi e per alcuni caratteri dei pattern
bisogna usare il carattere di escape \ .
Questo consente di prendere anche familiarita' (se gia' non la
si ha) con i comandi BASH echo e grep , tuttavia, in
BuDuScRiPt e' incluso un programma di nome "udaregexp" che
consente di controllare una Condizione come quella
dell'esempio sopra in questo modo:
./udaregexp '^(ciao|giorno)[$_]*(nico[$_,]|nico$)' 'ciao nico'
ottenendo come risultato:
regexp ^(ciao|giorno)[ ]*(nico[ ,]|nico$) on: ciao nico = 1
Pattern find from char 1 to 9 = 'ciao nico'
2) Controllare le sentinelle, prima di inserirle, con il
comando:
/event chk
ad esempio
/event chk 0 text '(ciao|giorno).*$_(nico[$_,]|nico')='$data' /SAY Ciao $ru
Data una CONDIZIONE di questo tipo:
costante=variabile
BuDuScRiPt prima controlla che "costante" sia contenuta in
"variabile" (non importa dove e non fa distinzione di maiuscole e
minuscole) poi, se fallisce, controlla che "variabile" sia contenuta
in "costante" e, se fallisce ancora, controlla se "costante" e'
un'espressione regolare che viene soddisfatta dal contenuto di
"variabile".
Cio' significa che se uno ha questa equazione:
(ciao|giorno).*$_(nico[$_,]|nico)=$data
e' sufficiente che $data contenga la parola "ciao" affinche'
l'equazione sia soddisfatta perche' quando lui va a verificare che
"ciao" sia presente in "(ciao|giorno).*$_(nico[$_,]|nico)" trova
corrispondenza gia' a partire dal secondo carattere, ignorando il
fatto che sia una regexp; e' per questo motivo che si usa il carattere
' per deliminare la VARIABILE dell'espressione, perche' con:
^(ciao|giorno).*$_(nico[$_,]|nico$)='$data'
lui prima cerchera' se trova "'ciao'" in
"^(ciao|giorno).*$_(nico[$_,]|nico$)", poi il contrario e
successivamente prendera' in esame il controllo regexp.
Dato che puo' capitare la possibilita' che una costante contenga dei
caratteri appartenenti a quelli delle Espressioni Regolari, per fare
in modo che questi non vengano interpretati come tali e' necessario
anteporre il carattere di escape '\'; ad esempio, prendiamo in
considerazione questa condizione:
|-Nickname-|='$ru'
Essendo '|' un carattere speciale per le Espressioni Regolari, il
comportamento di questa espressione sara' molto diverso da quello che
ci si aspetta, perche' rappresenta una sorta di "espressione
incompleta" il cui risultato e' sempre vero.
Per fare in modo che funzioni come ci si aspetta e' necessario
scrivere la condizione in questo modo:
\|-Nickname-\|='$ru'
Passiamo ora a trattare meglio il campo dell'Azione. L'azione, come
detto in precedenza, rappresenta uno o piu' comandi IRC e/o
BuDuScRiPt. Tralasciando momentaneamente la risoluzione delle
variabili, l'azione non e' altro che un comando che l'utente potrebbe
digitare a mano al verificarsi di una certa condizione (la stessa che
deve rispettare la sentinella desiderata).
Per separare piu' comandi si e' gia' detto di usare la sequenza \;
ma, caso in cui si abbia necessita' che l'Azione debba essere a sua
volta la creazione di una sentinella - la quale dovra', come Azione,
avere "comandi multipli" - si potra' utilizzare la parola chiave
speciale _BUDUS_SEPARATOR_ al posto di \; (chiaramente solo
nell'azione della "sentinella che sara' creata da quella che si sta
realizzando"). Cio' e' necessario perche', se si usa sempre \; ,
sostanzialmente si va a determinare solo "comandi multipli" per la
"sentinella principale", non per quelle che saranno create da essa. Ad
esempio:
/event add 0 jchannel '$lu'='$ru' /event add ? text '$ru:ciao'='^ru:^data' /ACTION da il benvenuto a ^ru_BUDUS_SEPARATOR_/VOICE ^ru
significa: ogni volta che nel canale entra un utente (per l'evento
'jchannel' le variabili $lu e $ru corrispondono al nickname
dell'utente remoto che e' entrato; volendo verificare che si tratta
dell'utente locale, bisogna usare la variabile $nick, che rappresente
SEMPRE quello locale), inserisci una sentinella che dovra' reagire nel
momento in cui il medesimo scrive nel canale la sola parola "ciao" e,
come azione, dovra' prima "dare un benvenuto" (/ACTION da il benvenuto
a ^ru) e poi dargli la modalita' "VOICE" (/VOICE ^ru).
Fare attenzione all'uso diverso della variabile ^ru e $ru; che
differenza c'e' ?
Per spiegarlo facciamo un passo indietro; supponiamo di utilizzare la
sentinella sopra sempre solo con $ru, in questo modo:
/event add 0 jchannel '$lu'='$ru' /event add ? text '$ru:ciao'='$ru:^data' /ACTION da il benvenuto a $ru_BUDUS_SEPARATOR_/VOICE $ru
e di "risolverla", andando a sostituire il valore di $ru, ad esempio
con il nickname "pippo", ottenendo:
0 jchannel 'pippo'='pippo' /event add ? text 'pippo:ciao'='pippo:^data' /ACTION da il benvenuto a pippo_BUDUS_SEPARATOR_/VOICE pippo
(anche $lu, per il motivo citato sopra, e' stata risolta usando sempre
"pippo")
Ora, apparentemente, sembra che il comando sia corretto e faccia cio'
che ci aspettiamo; ma supponiamo che, anziche' entrare l'utente
"pippo", entri uno che si chiama "pluto", ecco come si risolve:
0 jchannel 'pluto'='pluto' /event add ? text 'pippo:ciao'='pippo:^data' /ACTION da il benvenuto a pippo_BUDUS_SEPARATOR_/VOICE pippo
Notare che la condizione della prima sentinella (jchannel) viene
soddisfatta, quindi aggiungera' una sentinella che avra' questa
condizione:
'pippo:ciao'='pippo:^data'
che sta a significare: ogni volta che "pippo" scrive "ciao", esegui
l'azione. Ebbene, anche se ad entrare e' stato "pluto", comunque viene
creata - anzi, tentato di creare - una sentinella per "pippo" !
Perche' questo ?
Perche' quando la sentinella principale esegue la sua AZIONE risolve
tutte le variabili e queste prendono i valori che hanno in quel
preciso momento.
Per evitare questo comportamento, al posto di $ si usa il carattere ^
e questo fa si che, anziche' risolvere la variabile con un valore, lo
script risolva la variabile con il nome corrispondente della variabile
stessa, quindi abbiamo che:
0 jchannel '$lu'='$ru' /event add ? text '$ru:ciao'='^ru:^data' /ACTION da il benvenuto a ^ru_BUDUS_SEPARATOR_/VOICE ^ru
quando esegue l'azione, lo fa risolvendola in questo modo:
/event add ? text 'pippo:ciao'='$ru:$data' /ACTION da il benvenuto a pippo\;/VOICE $ru
Nell'azione e' possibile usare qualsiasi variabile dell'Events
Manager e aggiungere o generare qualsiasi evento, compresi quelli
speciali.
Solo nel campo Azione e' possibile usare la variabile $database
(leggi piu' avanti per la lista delle variabili); questa conterra' il
percorso ad un file (che viene aggiornato nel momento stesso in cui
viene valutata la variabile) contenente la lista di tutti gli utenti
memorizzati nel Database del plugin (cioe' quelli presenti nei vari
servers/canali o con i quali si sta dialogando privatamente).
Per conoscere in dettaglio la lista degli Eventi gestiti e i nomi
delle variabili utilizzate (nonche' ottenere numerosi esempi), usare
il comando:
/event help
Porre attenzione al fatto che l'Events Manager non funziona, per
default, sui "dati in uscita", ovvero, l'evento "text" non reagisce a
cio' che scrive l'utente locale, ma solo a quello che scrivono "gli
altri" (in canale, in privato, ecc...), quindi non e' possibile fare
dei tentativi con sentinelle come:
/event add 0 text prova=$data /SAY $ru ha scritto $data
e poi sperare che venga eseguita l'azione scrivendo "in proprio";
dovra' essere un altro utente (o comunque un clone) a scrivere "prova"
affinche' succeda qualcosa. Per modificare questo comportamento vedi
la risposta 031.
Infine una piccola considerazione sulla generazione di eventi
attraverso il comando "/event event": esso prevede che, in sequenza,
siano fornite le variabili $lu, $ru, $rhost, $channel, $server e $data
, in questo preciso ordine.
Se le variabili vengono omesse usando un comando come "/event add" o
"/event mod", lo script aggiunge in automatico quelle eventualmente
mancanti.
E' da sottolineare anche come l'Events Manager (ma anche altre parti
del plugin) vengano "inibite" da situazioni come:
- Disabilitazione del Database interno di BuDuScRiPt
- Disabilitazione dell'Events Manager
- Applicazione di "maschere di IGNORE" piu' o meno generiche
In particolare, se si aggiunge una maschera di ignore con uno dei
flags PRIV, NOTI, CHAN attivo, di fatto non verranno generati eventi
per l'utente il cui host soddisfa la maschera.
_______________________________________________________________________________ 006____________________________________________________________________________
DOMANDA: E' POSSIBILE ESEGUIRE PIU' COMANDI IN SERIE ?
RISPOSTA:
Certo, usando le Macro di BuDuScRiPt !
NB: Se quello che si desidera e' lanciare piu' comandi,
digitandone uno solo, separati da un carattere speciale,
leggere la risposta numero 027.
Il plugin permette di eseguire dei files che contengono comandi
IRC/BuDuScRiPt; e' sufficiente, con un qualsiasi editor (emacs, vi,
ecc...) creare un file con estensione .mcr nella directory
.xchat2/buduscript contenente, in ogni riga, il comando che si
desidera eseguire.
E' offerta anche la possibilita' di passare dei parametri ai file
macro.
Ad esempio supponiamo di voler creare una macro che esegue una
ricerca (utilizzando grep) sui file di LOG salvati dal plugin (vedi:
/budus help log); potremmo quindi creare un file macro come il
segunte:
/ECHO %C7,1-- INIZIO RICERCA --------------------------------------------------
/budus pipe grep -i -h $1 $mxchat_path/buduscript/*.log $2 $3 $4 $5 $6 $7 $8 $9
/budus InsertCommandInQueue(0) /ECHO %C7,1-- FINE RICERCA ----------------------------------------------------
Per usare il file macro sopra (che potrebbe chiamarsi grep.mcr)
useremo il comando:
/budus macro grep
Nei Files macro (.mcr) si possono utilizzare ulteriori parole chiave
che sono:
- $mchannel : Nome del canale corrente
- $mhostname : Hostname del server corrente
- $mservername : Nome del server corrente
- $mpassword : Password di identificazione dell'utente al server
- $mnick_prefixes : Prefisso del nickname (@, %, +)
- $mnick_modes : Modalita' dell'utente locale (aoq ...)
- $mnick_host : Host dell'utente locale
- $mnick : Nickname dell'utente locale
- $mlast_away_reason : Ultimo motivo utilizzato per l'AWAY
- $mxchat_path : Path di xchat (.xchat o .xchat2)
- $mdatabase : Path del Database del plugin (*)
Queste parole chiave vengono sostituite con i valori della sessione
che ha lanciato la macro (e non quella corrente).
(*) Il Database del plugin rappresenta la lista degli utenti presenti
nei vari servers/canali nei quali si e' presenti o comunque
dei quali il plugin tiene traccia (ex: utenti non presenti in
nessun canale ma con i quali si sta comunque dialogando in
QUERY privata). La variabile $mdatabase contiene il percorso
al file contenente una lista degli utenti dove, per ogni riga,
sono separati da una tabulazione rispettivamente il
servername, channelname, usernick, useraddress, userhost,
userdomain, messagedata. Affinche' questo file venga
generato/aggiornato dal plugin e' necessario che,
precedentemente, sia presente una riga con la direttiva
'#savedb'.
(*) Se non si desidera risolvere le variabili e' necessario anteporre
il carattere '\' a '$', ad esempio: \$mnick
Per velocizzare l'esecuzione delle macro, ignorando quindi i parametri
anti-flood, e' possibile utilizzare la direttiva '#fastflush'.
Ecco un esempio di macro (file: $HOME/.xchat2/buduscript/test.mcr) :
_INIZIO_MACRO__________________________________________________________________
#fastflush
/ECHO Questo e' un esempio di MACRO
/ECHO XChat si trova nella directory $mxchat_path
#savedb
/ECHO Il Database degli utenti si trova in $mdatabase e questo e' il contenuto:
/budus pipe cat $mdatabase
/ECHO _________________________________________________________________________
/ECHO Ecco i parametri passati: $1-
_FINE_MACRO____________________________________________________________________
La MACRO di esempio puo' essere lanciata con: /budus macro test
_______________________________________________________________________________ 007____________________________________________________________________________
DOMANDA: BuDuScRipT PUO' FUNZIONARE COME UN BOT ?
RISPOSTA:
I BOT sono speciali client IRC che, normalmente, hanno il compito di
gestire un canale in modo "autonomo", al fine di svolgere le attivita'
piu' svariate.
Nonostante ne' il client (XChat) ne' il plugin sia stato pensato per
funzionare come un BOT, grazie alle features introdotte di recente, e'
possibile crearsi un IRCBOT sfruttando la seguente equazione:
BOT = XChat + BuDuScRiPt + Shell Script
dove BuDuScRiPt rappresenta a sua volta:
BuDuScRiPt = Events'Manager + Macro + Commands'Queue + pipe_script
Ad esempio, e' possibile fare in modo che, quando un utente scrive una
parola chiave, magari seguita da qualche parametro, venga eseguita una
macro (a seconda dei casi, si puo' anche evitare l'uso delle macro),
la quale, esegue un qualche processo esterno tramite il comando
"/budus pipe_script" (che ha la facolta' di catturare l'output dei
processi che esegue ed utilizzarli come "comandi IRC").
A titolo dimostrativo e' gia' stato creato un pacchetto contenente
files di configurazione, macro, shell script e documentazione
necessari per convertire XChat in un BOT (utilizzando il plugin,
ovviamente); si puo' trovarlo a questo indirizzo:
http://digilander.libero.it/udasoft/Software/Linux/buduscript/download.html
_______________________________________________________________________________ 008____________________________________________________________________________
DOMANDA: E' POSSIBILE ESSERE AVVERTITI QUANDO ENTRA UN CERTO UTENTE ?
RISPOSTA:
Il plugin e' in grado di emettere avvertimento acustico/testuale
quando in un canale entra un utente avente un nickname specifico; la
lista dei nickname che si desidera monitorare va salvata nel file
./xchat2/buduscript/budus.nik.
Ad ogni riga del file deve corrispondere un nickname; il monitoring
non e' case-sensitive e non si basa sulla sola word (nel senso che, il
nickname dell'utente che entra, deve, in qualche modo, contenere la
stringa specificata in budus.nik e non essere necessariamente l'esatto
match).
A partire dalla versione 2.6.14 e' stato aggiunto anche l'Evento
NOTIFY, con il quale, e' possibile generare delle Sentinelle (vedi
l'Events Manager: 005) che possono avvertire anche acusticamente
(dipende da come si crea la sentinella, potenzialmente si puo' fare di
tutto) quando un certo utente si collega al Server.
_______________________________________________________________________________ 009____________________________________________________________________________
DOMANDA: E' POSSIBILE ASSOCIARE DELLE INFORMAZIONI AD UN UTENTE ?
RISPOSTA:
E' possibile associare ad un indirizzo (host@dominio) o ad un nickname
qualsiasi tipo di informazione; salvando all'interno di un file,
avente il medesimo nome del server che si desidera monitorare (ex:
irc.mioserver.org), un record di questo tipo:
host@dominio nickname dati...
il plugin e' in grado di avvertire quando intercetta un utente che
soddisfa l'indirizzo o il nickname; ad esempio, supponendo di essere
collegati al server irc.mioserver.net potremmo avere nella directory
./xchat2/buduscript un file (irc.mioserver.net) contenente queste
righe:
#
gibbo@212.125.24.5 gibbo Milano 321546548 ecc...
@dominio_anonimo fede Bologna 321546549 ecc...
birba@ birba^ Trieste 871323465 ecc...
Quando entra un utente avente nick 'fede' ecco che il plugin ci
avverte, mostrandoci i dati "associati" (nel nostro caso: Bologna
321546549 ecc...); il '#' presente all'inizio serve per "spezzare" il
file dati in due parti. E' infatti possibile elencare all'inizio del
file, prima del '#', una serie di record aventi questa formattazione:
@dominio dati...
#
Tutti gli utenti che hanno il dominio che appartiene ad uno di quelli
elencati, vengono segnalati (il perche' di questo ? ... gli scopi
possono essere diversi, ognuno lo usi come vuole).
_______________________________________________________________________________ 010____________________________________________________________________________
DOMANDA: E' POSSIBILE METTERSI/TOGLIERSI DALL'AWAY SU TUTTI I SERVER ?
RISPOSTA:
Il comando "/budus away" consente di mettersi/togliersi dallo stato di
away generale; il comando e' in grado di rilevare dove lo stato in cui
si vuole passare e' gia' presente e quindi evita cambiamenti laddove
non necessario.
Per default viene usata la "ragione" configurata in XChat, ma e'
possibile specificarne una.
L'utente ha facolta' di usare, in ogni signolo canale, i comando
"/AWAY" e "/BACK", tuttavia, il comando "/budus away" lavora comunque
in modo "globale" e si ricorda l'ultimo stato impostato, ovvero: se e'
andato in AWAY, al suo successivo utilizzo, eseguira' il BACK laddove
serve e viceversa, salvo non sia stata specificata una "ragione", in
quel caso, da per scontato che deve comunque convertire in AWAY.
Cio' significa che se si e' presenti in 2 server, si va in AWAY con
"/budus away", poi su uno si uno dei 2 si fa un BACK manuale, nel
momento in cui si tornera' ad usare "/budus AWAY" questi eseguira' il
BACK anche sull'altro canale; se pero' viene specificata una
"ragione", ad esempio "/budus away vado a pranzo", ecco che comunque
convertira' in AWAY tutti i servers che lo necessitano, lasciando
inalterati gli altri.
_______________________________________________________________________________ 011____________________________________________________________________________
DOMANDA: E' POSSIBILE ESSERE AVVERTITI QUANDO QUALCUNO SCRIVE IN QUERY ?
RISPOSTA:
Gia' di default lo script emette avvertimento quando viene aperta per
la prima volta una query; tuttavia, se si desidera essere avvertiti
quando una query "non attiva" viene modificata, e' possibile usare il
comando "/budus qm" nella finestra che si intende monitorare. Il
comando non funziona se la tipologia della finestra e' diversa dalla
QUERY e cmq "funziona male" nel caso in cui sia "fluttuante".
_______________________________________________________________________________ 012____________________________________________________________________________
DOMANDA: E' SUPPORTATO XCHAT-TEXT ?
RISPOSTA:
I moduli precompilati del plugin, non sono in grado di girare se
caricati da xchat-text, tuttavia, e' possibile compilare BuDuScRiPt in
modo da renderlo compatibile con il client testuale, ovvero, lanciando
lo script di compilazione in questo modo:
./makescript.sh xchat-text
come ad esempio:
./makescript.sh 1.8.10 xchat-text
Il plugin, compilato in questo modo, non e' piu' in grado di
verificare se la versione di XChat e' compatibile a livello binario,
quindi, usandolo con una situazione diversa da quella per la quale e'
stato creato, potrebbero verificarsi malfunzionamenti.
XChat 2 Text non e' stato testato e quindi potrebbero verificarsi
malfunzionamenti.
_______________________________________________________________________________ 013____________________________________________________________________________
DOMANDA: HO INSTALLATO IL PLUGIN COME DA ISTRUZIONI, MA QUANDO LO
LANCIO MI COMPARE UN MESSAGGIO DI ERRORE; PRATICAMENTE,
SEMBRA NON RIESCA A TROVARE IL FILE budus_italiano.msg
RISPOSTA:
Quando il plugin viene caricato in memoria da XChat, si aspetta che
alcuni files siano contenuti nella directory ./xchat2/buduscript .
Cio' significa che il programma li va a cercare in suddetto percorso,
partendo dalla *Directory Corrente*; ne consegue che se, nella
directory corrente, non c'e' almeno un link a .xchat2 , il software
non e' in grado di caricare i files, di cui necessita per funzionare
(tra cui 'budus_italiano.msg', che rappresenta i messaggi utilizzati
dallo script).
Per risolvere il problema e' necessario creare un link alla
directory .xchat2 che, normalmente, si trova nella directory $HOME ;
se, ad esempio, XChat viene lanciato dalla directory
/home/user/.gnome-desktop e' necessario procedere come segue:
1) Aprire un terminale.
2) cd /home/user/.gnome-desktop
3) ln -s $HOME/.xchat2
L'alternativa, e' quella di cambiare la directory dalla quale si fa
partire XChat, modificando il link dell'icona o quant'altro.
_______________________________________________________________________________ 014____________________________________________________________________________
DOMANDA: COME EVITO L'INTERPRETAZIONE DI ' CON "/budus pipe" ?
RISPOSTA:
Quando si rende necessario eseguire un comando alla shell del sistema
usando i comando "/budus pipe" e "/budus pipe_script", e' possibile
evitare l'interpretazione del carattere apostrofo ('), usando il
metacarattere \( all'inizio e \) alla fine, come ad esempio:
/budus pipe echo \(prova dell'apostrofo\)
_______________________________________________________________________________ 015____________________________________________________________________________
DOMANDA: E' SUPPORTATO XMMS ?
RISPOSTA:
No. Attualmente, ritengo esistano ottimi scripts che svolgono le
funzioni relative al controllo di XMMS, e quindi e' stato
appositamente evitato di introdurre funzioni che gia' altri hanno
realizzato ottimamente.
NB: A partire da XChat 2.8.4 e' stato introdotto un menu per la
gestione di Audacious che consente di governare molte delle
funzionalita' del player.
NB: E' stato aggiunto il supporto per numerosi player audio, come
Amarok, Rhythmbox ed Exaile; sono tutti gestibili da menu, come
Audacious.
Comunque, a livello di macro, e' presente il comando xmms, mpg e
mpgk, usabili in questo modo:
/budus macro xmms
/budus macro mpg
/budus macro mpgk
/budus macro mplayer
/budus macro as
che rispettivamente:
- Visualizza il file attualmente riprodotto da XMMS
- " " " " " " mpg123
- Killa il processo mpg123
- Visualizza il file attualmente riprodotto da MPlayer
- Visualizza il file attualmente riprodotto da Audacious
Affinche' lo script sia in grado di visualizzare il file riprodotto
da XMMS e' necessario che sia installato e attivo il relativo plugin
InfoPipe (e' un pacchetto debian a parte: xmms-infopipe).
Se si desidera "automatizzare" la scritta in modo che, cambiando
brano, automaticamente lo script scriva nel canale il titolo della
nuova canzone, e' necessario aggiungere il parametro "auto", ad
esempio:
/budus macro xmms auto
Per fermarlo e' necessario chiudere XMMS e attendere che lo script
scriva che si e' disattivato l'Auto-Spam di XMMS, oppure, utilizzare
la seguente sintassi:
/budus macro xmms noauto
e attendere che appaia il messaggio "Auto-Spam XMMS Deactivated".
L'automatizzazione funziona con tutti i player supportati (solo XMMS
richiede l'installazione di un plugin apposito, Audacious consente di
ottenre info sui brani in ascolto tramite audtool).
Per fare in modo che il messaggio appaia contemporaneamente in piu'
canali - solo quando si usa la modalita' auto - e' necessario
specificare, oltre al nome del player utilizzato, anche quello del
canale; quest'ultimo viene aggiunto ad una lista che rimane attiva
fino a quando non viene usato "noauto", oppure, fino a quando non si
chiude il player (e' consentita solo l'aggiunta), dopodiche', si
azzera completamente.
_______________________________________________________________________________ 016____________________________________________________________________________
DOMANDA: QUANDO LANCIO UN QUALSIASI COMANDO "/budus" NON SUCCEDE
NIENTE; PERCHE' ?
RISPOSTA:
Semplice: il plugin non e' stato caricato in memoria !
I motivi per i quali lo script non e' stato caricato in memoria
possono essere 3, ovvero:
1) Lo script non e' stato correttamente installato seguendo la
procedura descritta nel file README.
2) Si sta tentando di caricare il plugin con una versione di XChat
che non supporta SSL; in questo caso, anche se lo script viene
caricato, appena si accorge della situazione anomala, si
auto-scarica emettendo opportuno messaggio di errore. La soluzione
e' quella di ottenere una versione del plugin adeguata (se
esiste), oppure, ricompilare XChat (o anche il plugin, ma sono
comunque necessari i sorgenti del client).
3) Si sta tentando di caricare il plugin su un sistema hardware
incompatibile (ad esempio un binario per x86_32 su una macchina
x86_64 o viceversa) o comunque una versione di XChat non
corrispondente; la procedura di installazione dovrebbe controllare
la compatibilita' e, teoricamente, questa evenienza non sarebbe
possibile.
_______________________________________________________________________________ 017____________________________________________________________________________
DOMANDA: COME SI DISABILITANO LE RISPOSTE AUTOMATICHE (SPAM) ?
RISPOSTA:
In alcune occasioni, il plugin si "auto pubblicizza" tramite un
semplice messaggio, oppure, ringrazia un Operatore che ha cambiato la
Modalita' dell'utente locale.
Per disabilitare lo "spam" e' sufficiente impostare la variabile
'iFlagBudusMessage' con il comando:
/budus budusmsg 0
Per evitare che il plugin risponda, quando la propria modalita' viene
cambiata, e' necessario agire sulla variabile 'iFlagLocalUserModeChg'
tramite il comando:
/budus mode 0
_______________________________________________________________________________ 018____________________________________________________________________________
DOMANDA: LA CHAT DOVE MI COLLEGO E' COMPOSTA DA PIU' LINKS E QUINDI IL
FILE_DOMINI USATO PER IL RICONOSCIMENTO DEGLI UTENTI CAMBIA AD
OGNI CONNESSIONE. COSA POSSO FARE ?
RISPOSTA:
*****************************************************************************
Questo problema si verificava nelle versioni precedenti alla 3.1.00
Attualmente il problema puo' esserci nel caso in cui, a prescindere
dal network al quale ci si collega, comunque si desidera avere un file
domini unico.
*****************************************************************************
E' sufficiente fare un semplice Link Simbolico al "file_domini
principale"; in effetti non e' necessario avere un file dati per ogni
server o comunque ogni chat che si frequenta. Si puo' tranquillamente
creare un file avente qualsiasi nome (ex: file_domini.txt) e poi
creare tanti links simbolici a quest'ultimo per ogni server/linkserv
che si utilizza.
Ad esempio se lo script cerca un file_domini dal nome
"irc.miachat.net" si puo' adoperare una sintassi di questo tipo:
cd .xchat2/buduscript
ln -s file_domini.txt irc.miachat.net
Non e' necessario fare nient'altro perche' lo script andra' a leggersi
il nuovo file in automatico.
Per sapere il nome del file domini attualmente cercato dallo script
e' necessario lanciare il comando:
/budus var
_______________________________________________________________________________ 019____________________________________________________________________________
DOMANDA: COME POSSO LIMITARE IL NUMERO DI DIALOG CHE GLI ALTRI UTENTI
MI POSSONO APRIRE ?
RISPOSTA:
BuDuScRiPt non ha un meccanismo per impedire che si aprano troppi
Dialog (le QUERY PRIVATE), se non nel caso in cui cio' avvenga in un
lasso di tempo troppo breve; infatti, per evitare un DoS flood, il
plugin offre la possibilita', attraverso il comando:
/budus maxquery
di stabilire il numero massimo di messaggi che si possono ricevere in
QUERY nell'arco di un secondo.
Tuttavia puo' capitare che altri utenti aprano una QUERY privata
"rispettando questo limite" ma che, alla fine, sia il numero di
dialoghi aperti ad essere improponibile (ex: si fa fatica gia' a
parlare con 2-3 persone contemporaneamente); in questo caso non e'
disponibile nessun meccanismo all'interno del plugin.
Solo per XChat 2 e' pero' disponibile un apposito Add-on che
permette di risolvere il problema; consultare il sito ufficiale di
BuDuScRiPt per ottenere ulteriori informazioni, oppure, contattare la
UDA'Software.
_______________________________________________________________________________ 020____________________________________________________________________________
DOMANDA: PER QUALE MOTIVO IL PLUGIN NON EMETTE NESSUN SUONO DI
AVVERTIMENTO ?
RISPOSTA:
Affinche' il plugin sia in grado di riprodurre avvertimenti acustici
e' necessario che siano presenti i seguenti requisiti:
1) La Scheda Audio deve essere correttamente, installata, configurata
o comunque riconosciuta dal sistema operativo; in linea generale,
programmi multimediali (come aplay, di alsa-utils) devono essere
in grado di riprodurre file wav.
2) Il device audio non deve essere occupato; il plugin effettua un
controllo sul device audio configurato (vedi: /budus help
audiodevice ) prima di riprodurre suoni; se risulta occupato
(cioe', acquisito per uso esclusivo da un'altra applicazione) non
sara' in grado di riprodurre nulla e, dopo averlo comunicato (solo
la prima volta), si limitera' ad emettere un "beep"
(dall'altoparlante del PC) o un messaggio di avvertimento.
Se i requisiti elencati sopra sono soddisfatti e' necessario
verificare che tutte le variabili coinvolte nella riproduzione dei
suoni, del monitoring e del database interno del plugin siano
opportunamente configurate.
Di seguito sono riportate le variabili, i valori di default e i
comandi per fare in modo che il plugin sia in grado di emettere suoni
di avvertimento.
iFlagQueryBeep = 1 : /budus query 1
iFlagNickBeep = 1 : /budus nick 1
iFlagDomainMonitoring = 1 : /budus dm 1
iFlagNickJoinMonitoring = 1 : /budus jm 1
iFlagBeep = 1 : /budus alert 1
tSoundCommandTimer = 6 : /budus soundtime 6
psAudioDevice = ALSA : /budus audiodevice ALSA
iFlagEnableDatabase = 1 : /budus database 1
Per verificare lo stato delle variabili e' possibile usare il comando
"/budus var"; per resettare le variabili ai valori di default, usare
il comando "/budus var reset".
Puo' anche essere utile aprire un terminale (xterm) e dare un comando
come il seguente:
$HOME/.xchat2/buduscript/udaplaysound $HOME/.xchat2/buduscript/alert.au ALSA
Se non si sente nulla e' sintomo che i requisiti non sono
rispettati. Il consiglio e' quello di verificare che il mixer audio
sia configurato correttamente (vedere: alsamixer), ad esempio non in
stato di MUTE e che, nel sistema, sia disponibile il comando "aplay"
(fornito con "alsa-utils"), il quale, deve essere autonomamente in
grado di riprodurre suoni (se non lo e', il problema e' a monte di
BuDuScRiPt).
_______________________________________________________________________________ 021____________________________________________________________________________
DOMANDA: USANDO ALSA DRIVER CON XMMS ATTIVO IL PLUGIN SI BLOCCA QUANDO
DEVE EMETTERE I SUONI DI AVVERTIMENTO, COME RISOLVO ?
RISPOSTA:
Dall'introduzione di 'udaplaysound' questo problema non dovrebbe piu'
manifestarsi perche' il software crea un processo separato e non
bloccante per inviare i dati al device audio, proprio per evitare
questo problema.
_______________________________________________________________________________ 022____________________________________________________________________________
DOMANDA: HO INSTALLATO BUDUSCRIPT, MA QUANDO LANCIO XCHAT E MI CONNETTO
AL SERVER IRC SI CHIUDE IMMEDIATAMENTE, CON UN "SEGMENTATION
FAULT"; COSA DEVO FARE ?
RISPOSTA:
Nel 90% dei casi si tratta di una "incompatibilita' binaria", ovvero,
il plugin e' stato compilato per una versione di XChat diversa e,
per versione, non si intende semplicemente quella del client ma anche
di quali moduli sono effettivamente presenti.
Ad esempio e' possibile che alcune distribuzioni Linux includano degli
XChat che non supportano PERL, piuttosto che SSL, anziche' TCL/Tk,
ecc..., nonostante la versione di XChat sia comunque la piu' recente
possibile.
In linea di massima si puo' affermare che l'incompatibilita' e' quasi
sempre determinata dalla mancanza in XChat del supporto a SSL (quando
invece il plugin viene sempre compilato con la possibilita' di
sfruttarlo, anche se comunque non e' necessario abilitarlo affinche'
funzioni perfettamente e completamente).
E' possibile verificare cio' semplicemente andando nella "Server List"
e constatando se si ha la possibilita' di abilitare l'opzione
"Utilizza SSL per tutti i server di questo network" (l'opzione puo'
cambiare di posizione e dicitura a seconda della versione XChat
utilizzata, ma fondamentalmente identifica sempre la medesima cosa).
Se l'XChat installato non supporta SSL, anche la versione di
BuDuScRiPt che ci si procura deve essere stata compilata senza
supporto SSL, altrimenti potra' provocare un crash del client.
Se non e' disponibile una versione dello script, in forma
precompilata, compatibile con il proprio XChat e' necessario
scaricarsi i sorgenti sia dello script che di XChat e compilare il
plugin dopo aver configurato opportunamente i sorgenti del client IRC
(ovvero: vanno configurati come la versione installata ... ovviamente
puo' darsi convenga ricompilarsi pure XChat ed essere cosi' sicuri
del risultato).
Sul sito di BuDuScRiPt
http://digilander.libero.it/udasoft/Software/Linux/buduscript
e' presente una completa guida su come installare il plugin dai
sorgenti, quelli di XChat compresi.
_______________________________________________________________________________ 023____________________________________________________________________________
DOMANDA: QUANDO IL PLUGIN FA PER CARICARSI, MI DA UN ERRORE TIPO
"budus.so: cannot open shared object file: No such file or
directory". PERCHE' NON SI CARICA ?
RISPOSTA:
Si tratta di una "incompatibilita' binaria" dovuta al fatto che lo
script installato e' stato "compilato" per una piattaforma diversa e
incompatibile.
Purtroppo l'unica soluzione e' quella di ricompilare lo script insieme
al client XChat. Non e' un'operazione particolarmente complicata,
pero' richiede che sul sistema siano installate le librerie necessarie
per il "development" (sviluppo del software) e puo' risultare una
richiesta particolarmente impegnativa. Se gia' sono installate le
librerie necessarie, l'unico accorgimento e' quello di compilare
XChat con la medesima configurazione di quello normalmente utilizzato
(salvo non si disinstalli quest'ultimo e si installi quello che si va
a compilare, che e' la scelta consigliata per evitare problemi di
compatibilita').
Sul sito di BuDuScRiPt
http://digilander.libero.it/udasoft/Software/Linux/buduscript
e' presente una completa guida su come installare il plugin dai
sorgenti, quelli di XChat compresi.
_______________________________________________________________________________ 024____________________________________________________________________________
DOMANDA: QUANDO TORNO DALLO STATO DI AWAY IL PLUGIN ESEGUE
L'IDENTIFICAZIONE TROPPO PRESTO, IL SERVER "NON LA VEDE" E DI
FATTO MI CAMBIA FORZATAMENTE NICKNAME. COME RISOLVO ?
RISPOSTA:
Normalmente, quando si fa il "/BACK" da un AWAY il plugin lancia in
automatico questo comando:
/MSG NickServ Identify
dove rappresenta la parola chiave per identificare il
relativo nickname, presa direttamente da cio' che l'utente stesso ha
configurato nelle impostazioni del server IRC specifico, e che viene
aggiunta in automatico dal plugin, indipendentemente dal comando
specificato.
Il comando viene eseguito immediatamente e cio' puo' determinare, su
alcuni server "lenti", che di fatto venga sostanzialmente ignorato.
Per risolvere il problema e' sufficiente modificare il comando sopra in:
/TIMER 3 MSG NickServ Identify
Il "3" rappresenta i secondi di ritardo (il comando funziona su
XChat2, altrimenti occorre un "/" prima di MSG, cioe': /MSG); per
settare il BuDuScRiPt e' quindi necessario dare il comando:
/budus identifycmd /TIMER 3 MSG NickServ Identify
Per rendere permanente la cosa bisogna anche salvare il file di
configurazione con:
/budus save
_______________________________________________________________________________ 025____________________________________________________________________________
DOMANDA: NEL MIRC PER WINDOWS, QUANDO FACCIO DOPPIO CLICK SU UN
NICKNAME, MI VIENE AUTOMATICAMENTE INSERITO NEL PROMPT,
COSI' CHE NON DEVO SCRIVERLO (SBAGLIANDO); SI PUOI FARE LA
STESSA COSA IN XCHAT ?
RISPOSTA:
Con BuDuScRiPt si' !
E' sufficiente andare nel menu di XChat:
"Impostazioni->Preferenze->Lista utenti"
e nel campo "Esegui Comando:" mettere quanto segue SENZA le virgolette ("):
"budus InsertInBuffer() %s "
Essendo un "Comando Avanzato" di BuDuScRiPt (cioe' esegue chiamate a
funzioni interne del programma) e' necessario rispettare le lettere
maiuscole e minuscole.
Quando si fara' doppio click nella lista utenti del canale,
automaticamente verra' lanciato il comando BUDUS invocandolo con il
sottocomando InsertInBuffer() e %s sara' sostituito con il nickname;
BuDuScRiPt inserira' quindi il "nickname" nel prompt dei comandi e si
potra' direttamente scrivere perche' il focus sara' gia' attivo.
_______________________________________________________________________________ 026____________________________________________________________________________
DOMANDA: OGNI TANTO VENGONO EMESSI DEI STRANI "SUONI", TUTTI DISTORTI,
CHE ROBA E' ?
RISPOSTA:
Quei "rumori distorti", probabilmente sono il tentativo, da parte del
plugin, di emettere avvisi acustici.
Tuttavia, se il Device Audio non e' stato configurato correttamente,
ecco che essi vengono inviati al dispositivo sbagliato e, anziche'
riprodurre quanto previsto, escono rumori distorti.
Per default il plugin da per scontato che il device audio sia in /dev/audio ;
purtroppo pero' si tratta di un file di dispositivo che cambia da distribuzione
Linux a distribuzione, se non addirittura da una versione all'altra della
medesima, quindi e' difficile stabilirlo a priori e, necessariamente, ogni
utente deve preoccuparsi di individuarlo.
Nella directory /dev del sistema e' possibile ci sia una cartella
sound e solo all'interno della stessa si trovi effettivamente il file
da usare; tra quelli disponibili, bisogna capire, magari attraverso
delle prove, quale usare.
Per fare delle prove si puo' procedere in questo modo:
1) Settare il device audio con questo comando:
/budus audiodevice /dev/percorso/audio/device
dove chiaramente "percorso/audio/device" sara' da personalizzare
opportunamente.
2) Verificare se il suono emesso sia "accettabile" usando:
/budus PlaySound() d
NB: Il plugin non e' in grado di emettere un avviso acustico
prima che sia terminato il precedente, quindi bisogna lasciar
trascorrere almeno 6-7 secondi tra un comando e l'altro,
quando si prova.
In tutti i casi, se non riesce ad aprire il device audio,
cerchera' almeno di emettere un beep del PC.
Quando si intercetta il device corretto (chiaramente si da per
scontato che il sistema sia in grado di "suonare", e cio' e' possibile
verificarlo con un qualsiasi player multimediale, tipo Audacious,
MPlayer, ecc...), e' sufficiente dare il comando:
/budus save
al fine di salvare la configurazione e trovarsi con l'impostazione
gia' corretta al successivo riavvio di XChat.
Al fine di risolvere il problema di individuare il device corretto,
puo' essere opportuno avviare XChat da terminale (da xterm, dovrebbe
essere sufficiente scrivere xchat), in modo che alcuni messaggi di
errore del sistema operativo siano visibili e aiutino a capire cosa
non va.
_______________________________________________________________________________ 027____________________________________________________________________________
DOMANDA: E' POSSIBILE ESEGUIRE COMANDI MULTIPLI CON UN UNICO COMANDO ?
RISPOSTA:
Si, tramite il comando condizionale "/budus cmd". Per ulteriori info
su questo comando digitare "/budus help cmd" o leggere la guida sul
forum.
Esiste anche un'altra soluzione: la MACRO (MultiCommand), che
consente l'esecuzione di comandi multipli separandoli dal carattere |
(pipe), come avviene nei file .ini di mIRC.
Ad esempio:
/budus macro MC echo comando1 | echo comando2 | echo comand3
La medesima MACRO, di fatto, invoca un opportuno file script
(buduscript_script__multicommand.sh) che, oltre a separare i vari
comandi, offre la possibilita' di richiedere l'input dell'utente,
tramite questa sintassi:
$$?="Domanda da porre all'utente"
esempio:
/budus macro MC echo $$?="Inserisci la frase:"
Nel caso in cui sia necessario utilizzare piu' volte il medesimo
input inserito dall'utente e' sufficiente ripetere la stessa identica
domanda: lo script capira' che non deve porre la domanda 2 o piu'
volte, ma lo fara' una sola volta e le altre istanze saranno
automaticamente sostituite con cio' che l'utente ha risposto, esempio:
/budus macro MC echo $$?="frase:" | echo frase prec.: "$$?="frase:""
Il numero massimo di input e' limitato a 10, in modo che, se per
qualche motivo, si innesca un loop infinito, la procedura possa
comunque terminare dopo quale input nullo (altrimenti sarebbe
necessario un difficoltoso kill di sistema).
Nei comandi e' possibile usare le variabili mIRC $1 ($2, $3,
... saranno tutte sostituite con il nickname selezionato dalla Lista
Utenti di XChat), $me e $nickname (sostituite con il nickname
dell'utente locale), # e $chan e $mychan (sostituite dal nome del
canale corrente), $server (nome del Server IRC corrente) e $network
(nome del Network IRC corrente).
Ogni ricorrenza di '/run' sara' sostituita da '/exec' (chiaramente,
cio' che poi viene eseguito, non e' detto possa funzionare); se viene
intercettata la parola explorer.exe viene automaticamente sostituita
da firefox.
NB: Quando si esegue un input (ovvero, quando viene usata la
sintassi $$?="domanda") e' necessario porre attenzione che il
carattere \, essendo speciale (e' un escape) potrebbe richiedere di
essere inserito "doppio", cioe' anziche' scrivere una cosa coma \;
e' necessario scrivere \\; .
Se dovesse trovarsi problematico l'inserimento del carattere @ in un
qualche contesto, si puo' utilizzare la parola speciale
_BUDUS_CHIOCCIOLA_ .
Allo stesso modo, se ci si trova a dover utilizzare il comando "budus
pipe" o derivati e si ha la necessita' di utilizzare le sequenze di
escape \( e \), puo' essere necessario usare rispettivamente
_BUDUS_PIPE_ESCAPE_START_ e _BUDUS_PIPE_ESCAPE_END_ .
Nel caso in cui sia il carattere pipe "|" ad essere necessario per un
contesto diverso dal previsto e' prevista la parola chiave
"_BUDUS_PIPE_" mentre, analogamente, per il carattere "$" si puo'
utilizzare "_BUDUS_MC_US_DOLLAR_".
Porre attenzione al fatto che, quando si utilizza il comando XChat
"/TIMER" tramite la MACRO MC e' necessario specificare SEMPRE sia il
numero di ripetizioni che i secondi, ovvero, questa e' la sintassi:
/budus macro MC /TIMER ripetizioni secondi comando
ad esempio:
/budus macro MC /TIMER 1 5 SAY Prova del comando MC
ripetera' dopo 5 secondi il comando "SAY Prova del comando MC", mentre:
/budus macro MC /TIMER 5 1 SAY Prova del comando MC
ripetera' 5 volte ogni secondo il comando "SAY Prova del comando MC".
_______________________________________________________________________________ 028____________________________________________________________________________
DOMANDA: E' POSSIBILE CONVERTIRE I FILE .INI DEGLI SCRIPT mIRC PER
XCHAT ?
RISPOSTA:
Quasi.
Uno script per mIRC, trattandosi di una personalizzazione piuttosto
complessa, difficilmente puo' essere adattato per XChat, anzi, e'
sostanzialmente impossibile, tuttavia, se lo scopo e' quello di
importare alcuni comandi di menu che realizzano semplici azioni, ecco
che invece si puo' fare molto.
Ad esempio una delle cose che maggiormente vengono richieste da chi
cerca uno "script per linux" e' trovare un ambiente nel quale siano
presenti i vari "disegnini" (asci-art), messaggi di vario tipo, piu' o
meno colorati, da dedicare o comunque il cui scopo e' quello di
"animare il canale", oppure, i comandi per IRCOperator (ChanServ,
NickServ, BotServ, MemoServ, ecc...).
Per soddisfare questa esigenza e' stato introdotto uno script - e
qui, per script, si intende uno script bash linux - il cui scopo e'
quello di convertire quante piu' informazioni possibili, partendo da
un file .INI di mIRC, in un qualcosa di compatibile con
XChat/BuDuScRiPt.
Ad esempio tipiche righe di un file .ini di mIRC potrebbe essere
come le seguenti 3:
n100= .Salutoni
n101= ..Entrata
n102= ...* Amico:/say 1 $$1 9,1AMICO MIO! Da quanto
1TEMPO! | .timer 1 3 /say 1,7SEI SEMPRE DEI NOSTRI!!
Le righe iniziano con "n...=", un identificativo che indicizza il
numero di riga, seguite o da un nome di menu (nel caso dell'esempio,
il menu "Salutoni", al quale si aggiunge un sub-menu "Entrata") o dal
nome della voce di menu (nell'esempio "Amico"), il carattere ':' che
funge da separatore e quindi la lista dei comandi separati da un '|'.
Quando l'utente lancia "Salutoni->Entrata->Amico", di fatto vengono
eseguiti i seguenti 2 comandi:
/say 1 $$1 9,1AMICO MIO! Da quanto1TEMPO!
.timer 3 0 /say 1,7SEI SEMPRE DEI NOSTRI!!
dove "/say" rappresenta il comando IRC, $$1 e' una VARIABILE che sara'
sostituita con il nickname dell'interessato e vari caratteri di
codifica per colorare il tutto.
Gia' questi semplici 2 comandi, cosi' come sono, non sarebbero
compatibili con XChat, perche' quest'ultimo ad esempio li vorrebbe
scritti in questo modo:
/say 1 %s 9,1AMICO MIO! Da quanto1TEMPO!
/timer 3 say 1,7SEI SEMPRE DEI NOSTRI!!
la differenza non e' abissale, ma quanto basta per funzionare o
meno. Lo stesso vale per il modo con il quale mIRC e XChat creano i
propri comandi a menu, li' il lavoro e' nettamente maggiore e lo
script di conversione ha proprio lo scopo di eseguirlo.
Come fare quindi per importare questi menu di mIRC in XChat ?
Beh, la prima cosa e' individuare il file .INI, all'interno dello
script mIRC, che contiene il menu che si desidera
importare. Purtroppo, da script a script, il file che contiene il menu
ha nome diverso (menu.ini, popups.ini, ecc...) ed e' proprio
necessario mettersi li' a cercarlo aprendo direttamente i files che
compongono lo Script, sostanzialmente "andando ad intuito", ma non e'
troppo difficile, anzi.
Questo file va preso e spostato nella HOME directory rinominandolo
in 'mirc.ini' .
A questo punto e' sufficiente lanciare il comando di menu XChat:
BuDuScRiPt->Avanzate->Importa file INI di mIRC in un Menu Utente
Si avviera' una procedura guidata che aiutera' a completare i passaggi
necessari.
_______________________________________________________________________________ 028____________________________________________________________________________
DOMANDA: VOGLIO SPEDIRE UN MESSAGGIO NEL CANALE OGNI TOT SECONDI, COME
FACCIO ?
RISPOSTA:
E' possibile risolvere questo problema utilizzando le Sentinelle
dell'Event's Manager.
Ad esempio supponiamo di voler inviare il messaggio: "Prova di un
messaggio" in un canale ogni 3600 secondi (cioe' ogni ora).
Potremmo provare con un comando di questo tipo:
/event add 0 spcl_messaggio * /SAY Prova di un messaggio\;/TIMER 3600 event event spcl_messaggio $lu $ru $rhost $channel $server $data
Per "avviare" la spedizione del messaggio potremmo usare:
/event event spcl_messaggio $lu $ru $rhost $channel $server $data
Ebbene: non funzionera'.
Cio' e' dovuto al fatto che, per evitare loop infiniti, una Sentinella
non puo' essere invocata da se stessa.
Per superare questo "limite" (che in realta' serve a proteggere da
loop infiniti), possiamo creare 2 sentinelle in questo modo:
/event add 0 spcl_messaggio1 * /SAY Prova di un messaggio\;/TIMER 3600 event event spcl_messaggio2 $lu $ru $rhost $channel $server $data
/event add 0 spcl_messaggio2 * /SAY Prova di un messaggio\;/TIMER 3600 event event spcl_messaggio1 $lu $ru $rhost $channel $server $data
Per "avviare" la spedizione del messaggio potremmo usare:
/event event spcl_messaggio1 $lu $ru $rhost $channel $server $data
Quando viene eseguito questo comando, il sistema genere un evento che
fa valutare la Condizione dell'evento spcl_messaggio1 che, essendo
sempre vera, esegue in successione questi 2 comandi:
/SAY Prova di un messaggio /TIMER 3600 event event spcl_messaggio2 $lu $ru $rhost $channel $server $data
Il secondo comando eseguito, fa in modo che a distanza di 3600
secondi (1h) venga generato l'evento spcl_messaggio2 che, operando al
contrario, di fatto innesca un loop infinito.
Per terminare questo "loop infinito" l'unico sistema sara' quello di
ELIMINARE entrambe le sentinelle (vedi: /event help del).
_______________________________________________________________________________ 030____________________________________________________________________________
DOMANDA: VOGLIO KICKARE O BANNARE QUELLI CHE USANO PAROLACCE, SI PUO' ?
RISPOSTA:
Si', e' possibile farlo.
Una "soluzione prefatta" e' gia' disponibile pronta all'uso nel menu:
BuDuScRiPt->Gestione Sentinelle->Crea Sistema KickBan di 60 secondi su 3 BADWORD
In automatico verranno create 3 sentinelle che lavorano in questo modo:
- La prima parolaccia scritta da un utente, riceve un avvertimento
- Alla seconda parolaccia, un ultimatum
- Alla terza parolaccia un kick + ban di 60 secondi
Se si desidera rendere permanente questo sistema, occorre salvare le
sentinelle con il comando "/event save".
Ma quali sono le "parole cattive" che il sistema intercetta ?
Affinche' quanto sopra funzioni e' necessario creare un file in:
$HOME/.xchat2/buduscript/badword.txt
e, per ogni riga, elencare le parole che si desidera "bandire". Non fa
differenza scrivere in MAIUSCOLO o minuscolo, il sistema e'
case-insensitive.
In realta' il sistema funziona in questo modo: quando un utente
scrive qualcosa, la sua frase viene confrontata con tutte le parole (o
Espressioni Regolari POSIX, dato che si possono utilizzare anche
quelle, per soluzioni sofisticate ma, in questo caso, e' necessario
"dichiararle" anteponendo il carattere / ad inizio riga) contenute in
badword.txt e, nel momento in cui ne intercetta una, genere un EVENTO
di tipo "badword" impostando la variabile "$data" al numero di
intercettazioni effettuate sul medesimo utente (il contatore si azzera
se l'utente esce dal canale).
Cio' significa che il "cosa fare di chi scrive parolacce" viene
sostanzialmente demandato alle eventuali Sentinelle che si possono
creare, ad esempio:
/event add 0 badword '1'='$data' /kick $ru Non dire parolacce $ru !
significa: aggiunti un evento (add) che ogni volta (0) che un utente
scrive una parola cattiva (evento badword) e che il suo contatore
($data) raggiunge quota 1 (quindi alla prima parolaccia scritta, nel
nostro esempio), esegui il comando "/kick $ru Non dire parolacce $ru
!" dove '$ru' sara' il nickname dell'interessato.
Dato che, ogni volta che un utente esce, il contatore viene
resettato, qualcuno potrebbe approfittarne per fare il furbo: spara 2
parolacce, esce, ri-entra e ha la "fedina" pulita per altre 2 prima di
ricevere un BanKick.
Nel caso in cui si abbia a che fare con simili guastafeste, una
soluzione come questa, anche se piu' complicata di quella prevista dal
comando di menu, puo' risultare piu' efficace:
/event add 0 spcl_cafone [13]='$data' /budus ban + *!*@$domain 300 $ru\;/KICK $ru Ora basta !
/event add 0 badword '2'='$data' /event add 0 badword '$ru'='^ru' /event event spcl_cafone ^lu ^ru ^rhost ^channel ^server ^data\;/SAY $ru Smettila di dire parolacce, ultimo avvertimento !
La prima sentinella aggiunta reagira' ad un Evento Speciale di nome
"spcl_cafone"; suddetto evento verra' generato "manualmente", ovvero,
dalla seconda sentinella e scattera' quando il numero di
intercettazioni per un dato utente e' 1 o 3 (non e' un 13, e'
un'Espressione Regolare, manca l'apice ').
La seconda sentinella, quando un utente raggiunge quota 2 aggiunge a
sua volta un altra sentinella che ha il compito di invocare la prima
(ecco quindi la "generazione manuale").
Proviamo ad ipotizzare il funzionamento:
- pippo dice una parolaccia: non succede nulla, perche' la
sentinella dell'evento "spcl_cafone" non viene invocata da
nessuno.
- pippo dice una seconda parolaccia: a questo punto viene
avvertito, dopo che e' stata aggiunta una sentinella che, in
base al suo nickname, andra' a generare l'evento
"spcl_cafone".
- pippo dice la terza parolaccia: ora esiste una sentinella
che reagisce alla prima o alla terza parolaccia che dice,
perche' ne esiste un altra (creata quando ha detto la
seconda) che la "invoca"; se anche e' uscito e rientrato,
comunque le sentinelle rimangono e ogni volta che dira' una
parolaccia, si becchera' un KICK + BAN di 5 minuti.
Anzi, con questo sistema, solo alla seconda parolaccia viene
avvertito, dalla terza in poi sara' sempre un KICK+BAN di 5 minuti che
si becca.
Teoricamente, per fregare anche chi si cambiasse nickname per
"schivare" il meccanismo, anziche' basarci sul nickname, potremmo
basarci sul suo "indirizzo", modificando la seconda sentinella in
questo modo:
/event add 0 badword '2'='$data' /event add 0 badword '$rhost'='^rhost' /event event spcl_cafone ^lu ^ru ^rhost ^channel ^server ^data\;/SAY $ru Smettila di dire parolacce, ultimo avvertimento !
tuttavia c'e' il problema che, nel caso in cui ci siano piu' utenti
con il medesimo "indirizzo" (vedi gente che chatta da un Internet
Point oppure chi utilizza VirtualHost, ecc...), si puo' incappare in
"ban ingiusti" (sicuramente uno se lo becca se dice una parolaccia,
pero' magari alla prima anziche' alla terza).
Il sistema esposto sopra e' utile solo per cio' che un utente SCRIVE;
puo' capitare l'esigenza di voler prendere azioni su utenti che le
parolacce le utilizzano nel nickname; in questo caso e' consigliato
consultare la risposta numero 034.
_______________________________________________________________________________ 031____________________________________________________________________________
DOMANDA: HO CREATO UNA SENTINELLA, MA QUANDO SCRIVO QUALCOSA NON FA
NULLA, PERCHE' ?
RISPOSTA:
L'evento TEXT dell'Events Manager viene generato, per default, solo da cio' che
gli altri utenti scrivono, cioe' quelli remoti.
In altri termini, lo script non reagisce a cio' che scrive l'utente
locale, ma solo a quello che scrivono gli altri.
Per modificare questo comportamento e' stata introdotta la variabile
iFlagEventsManagerDebug, comandabile tramite il comando:
/budus eventdebug
Cio' consente di fare dei test con l'Events Manager e verificare le
proprie sentinelle (solo quelle che reagiscono all'evento TEXT, per le
altre e' possibile ricorrere alla generazione di un evento tramite il
comando "/event event", vedi "/event help event").
Inoltre, attivando questa variabile, il plugin andra' ad emettere
una serie di messaggi ogni volta che l'Events Manager entra in
funzione (al verificarsi di un evento, alla valutazione di una
sentinella, alla sua esecuzione, ecc...), in modo da aiutare l'utente
a capire se le proprie sentinelle funzionano.
_______________________________________________________________________________ 032____________________________________________________________________________
DOMANDA: PERCHE' SE DISABILITO IL CLONE DETECTOR POI ME LO RITROVO ?
RISPOSTA:
Non e' un problema del clone detector, semplicemente e' probabilmente
l'unica cosa che si e' tentato di disabilitare .... prima di riavviare
XChat (magari il giorno successivo).
Quando sia cambia una qualsiasi variabile di BuDuScRiPt, la modifica
influisce solo ed esclusivamente sulla CONFIGURAZIONE ATTIVA.
Cio' significa che, riavviando XChat, se NON SI E' SALVATA LA
CONFIGURAZIONE,, il plugin ritornera' alle impostazioni di default o
comunque alla configurazione salvata precedentemente.
Per salvare una configurazione usare:
/budus save
Per caricare quella salvata:
/budus read
In tutti i casi e' possibile configurare, caricare, salvare e mostrare
la configurazione attiva tramite i comandi a menu, sotto la voce
"BuDuScRiPt » Preferenze".
_______________________________________________________________________________ 033____________________________________________________________________________
DOMANDA: VORREI CHE XCHAT ESEGUISSE DEI COMANDI QUANDO SCRIVO UNA PAROLA
CHIAVE; COME FACCIO ?
RISPOSTA:
Normalmente l'Events Manager non reagisce a cio' che scrive l'utente
locale, ma solo a quello che scrivono gli utenti remoti (cioe' gli
altri).
Per modificare questo comportamento e' possibile sfruttare la
variabile iFlagEventsManagerDebug, tramite il comando:
/budus eventdebug 2
Il valore "2" e' necessario per indicare al plugin che non si vuole
la modalita' di debug standard - cioe' quella che prevede l'emissione
di messaggi di aiuto per verificare la valutazione delle sentinelle -
ma si desidera comunque che l'evento "text" sia gestito anche per
tutto quello che viene prodotto dall'utente locale.
Una volta che si e' effettuata questa impostazione sara' possibile
aggiungere una sentinella che reagisca a cio' che si desidera scrivere
e che esegua il relativo comando.
Se ad esempio volessimo lanciare un comando come "/chanserv op
#miocanale mionickname" quando scriviamo "opme", potremmo creare una
sentinella come la seguente:
/event add 0 text '$nick:opme'='$ru:$data' /chanserv OP $channel $nick
Ricordarsi che le variabili configurate sono valide solo per la
sessione corrente, vanno salvate con "/budus save" per rendere la
configurazione permanente.
_______________________________________________________________________________ 034____________________________________________________________________________
DOMANDA: E' POSSIBILE CREARE UNA BLACKLIST DEI NICKNAME ?
RISPOSTA:
In modo analogo a quanto avviene per le BADWORD (vedi risposta 030)
e' possibile creare un file in:
$HOME/.xchat2/buduscript/badnick.txt
ed inserire, per ogni riga, un nickname che si desidera proibire.
Se si desidera, anziche' specificare un nickname, utilizzare
un'espressione regolare POSIX e' necessario anteporre (quindi ad
inizio riga) il carattere / , in modo che il sistema la riconosca in
automatico.
Ad esempio possiamo avere nickname come questi:
paperino
pluto
o espressioni regolari come queste:
/cavolat
Nel caso di "paperino" e "pluto", il sistema reagira' solo se il
nickname dell'utente combacia perfettamente (indipendentemente da
maiuscole e minuscole), mentre nel secondo caso sara' sufficiente che
nel nickname sia presente la parola "cavolat", in qualsiasi posizione.
Come per le BADWORD, anche i BADNICK vanno a generare un evento, che
pero' in questo caso si chiama "badnick".
Se, ad esempio, volessimo eseguire un kick su ogni utente che usa un
nickname proibito, potremmo utilizzare una sentinella come questa:
/event add 0 badnick '$nick'!'$ru' /KICK $ru Il tuo nickname e' proibito
Il sistema, per ogni utente, mantiene un contatore di parolacce usate
che e' condiviso tra le BADWORD e le BADNICK. Gli eventi "badword" e
"badnick" ritornano questo "contatore" attraverso l'uso della
variabile $data .
Volendo condividere il file badword.txt anche per gli eventi "badnick"
e' possibile creare un link simbolico in questo modo:
ln -s badword.txt badnick.txt
così da dover modificare un solo file per inserire parole e nickname
proibiti.
_______________________________________________________________________________ 035____________________________________________________________________________
DOMANDA: E' POSSIBILE CREARE VARIABILI ED ESEGUIRE SCELTE ?
RISPOSTA:
Si, a partire dalla versione 3.1.00 di BuDuScRiPt, sono stati
introdotti una serie di comandi che consentono di manipolare variabili
definite dall'utente, accedere in lettura a quelle interne del plugin
(che ne cambiano il comportamento) e soprattutto di eseguire delle
scelte basate su condizione.
Per definire una variabile definita dall'utente, usare il comando
"/budus set"; ad esempio supponiamo di voler definire la variabile
"prova" il cui valore debba essere "una stringa di esempio", dovremo
usare:
/budus set prova una stringa di esempio
Uniche limitazioni nel nome della variabile:
- non puo' iniziare con il carattere '$'.
- non puo' contenere spazi.
- puo' essere solo minuscolo (in tutti i casi, viene convertito
tutto in minuscolo).
- non si possono usare variabili "di sistema"; anche
definendole (il sistema comunque lo permette, ad esempio
"output", "nick", ecc...) comunque quelle di sistema vengono
risolte per prime.
All'interno dei comandi "/budus if", "/budus else", "/budus else if"
e "/budus cmd" sara' possibile usare le variabili cosi' definite
anteponendo il carattere '$', ad esempio:
/budus cmd /SAY $prova
dara' come output:
una stringa di esempio
Allo stesso modo è possibile accedere a tutte le variabili di
BuDuScRiPt (e alcune anche di XChat); le variabili dello script si
ottengono tramite il comando "/budus var"; ad esempio:
/budus cmd /SAY Il sistema antiflood e' impostato ad: $iFlagTextFloodOutgoing
oppure, nel caso delle "variabili multiple" (psFlagChanJoinBeep,
psFlagChanModBeep, psFlagChanWordBeep), in questo modo:
/budus cmd /SAY Monitoraggio del canale $psFlagChanModBeep[0] sul server $psFlagChanModBeep[1]
le altre variabili predefinite sono elencate da "/budus help if".
Una volta definite le variabili è possibile sfruttarle sia per
l'esecuzione di comandi, sia per effettuare delle scelte.
I comandi "/budus if", "/budus else" e "/budus else if" servono per
verificare queste scelte: valutano una condizione e, se soddisfatta,
eseguono un comando.
Il comando "/budus if" e' il principale "della famiglia"; "/budus
else" esegue un comando solo se il precedente "/budus if" non ha
soddisfatto la condizione, mentre "/budus else if" e' analogo ma
aggiunge un ulteriore condizione da soddisfare.
La condizione puo' essere definita in due modi:
- il primo prevede l'uso di sole variabili.
- il secondo prevede l'uso di "comandi eseguiti dal sistema
operativo" e variabili.
Prendiamo in considerazione il primo caso con un esempio, supponiamo
di dare questo comando:
/budus if budus.mode = @ /SAY budus e' un operatore
In questo caso abbiamo utilizzato l'attributo ".mode" per ottenere la
modalita' dell'utente avente nickname "budus". Quindi, abbiamo
confrontato il risultato ottenuto con il carattere @. Quando un utente
è OP, il carattere restituito e' '@', di conseguenza se "budus"
risulta essere un OP viene eseguito il comando "/SAY budus e' un
operatore" (per un elenco delle modalita': /budus help if ).
La condizione e' formata da due espressioni e da un operatore di
confronto. Nel caso sopra l'espressione base e' "budus.mode" e quella
di confronto e' "@", mentre l'operatore e' rappresentato da "=".
Non c'e' il solo carattere uguale, gli operatori sono:
= < > : !
I caratteri '<' e '>' servono per determinare se l'espressione base
e' rispettivamente minore o maggiore di quella da confronto.
Il carattere ':' lavora in modo simile a '=', con la differenza che
l'espressione base deve essere contenuta in quella di confronto o
viceversa, quindi non e' una vera uguaglianza.
Infine, il carattere '!' lavora all'opposto di '='.
E' da sottolineare come questo confronto tra espressioni sia sempre
ALFANUMERICO e non puramente numerico, in altri termini: e' un
confronto tra stringhe.
Il confronto e' sempre di tipo "case insensitive" - cioe' non
sensibile a MAIUSCOLE/minuscole - salvo non si utilizzino espressioni
regolari; le espressioni regolari si possono usare solo
nell'espressione di confronto, esclusivamente con gli operatori '=' o
'!' e devono essere precedute dal carattere '/', esempio:
/budus if budus.say = "/^!addserver" /EXEC echo \($server\) > miofile.txt
Se si rende necessario proteggere il comando di esecuzione con gli
apici e' opportuno usare le sequenze '\(' e '\)'.
Nel caso in cui l'espressione debba contenere degli spazi e'
possibile usare la variabile speciale '$_' oppure "proteggerla" con
l'uso del carattere '"'; ad esempio questi due comandi sono
equivalenti:
/budus if budus.say = "buongiorno a tutti" /ECHO OK
/budus if budus.say = buongiorno$_a$_tutti /ECHO OK
L'uso di questo tipo di comandi e' stato pensato per aumentare le
potenzialita' di altri strumenti offerti dallo script, come ad esempio
le MACRO o le sentinelle. In questa prospettiva e' facile immaginare
come si possa notevolmente migliorare la creazione di comandi
personalizzati sofisticati; ad esempio, supponiamo di voler realizzare
una sentinella che reagisce solo agli OP del canale, perche' magari si
vuole creare un comando "!nickdata" che memorizza delle informazioni
su un file, relative ad un nickname specificato. Esempio:
/event add 0 text ^!nickdata$_.*$_='$data' /budus if $ru.mode = @ /EXEC echo \($data\) | awk \({print $2":"substr($0, index($0,$3))}\) >> miofile.txt
Non spaventarsi di tutto quello che viene dopo "/EXEC ...", si tratta
di comandi "UNIX" (vedi: man echo, man awk e man bash); "/EXEC" e' un
comando XChat per eseguire comandi del sistema operativo sottostante.
Quello che ha importanza è cio' che viene prima:
/event add 0 text ^!nickdata$_.*$_='$data' /budus if $ru.mode = @ ...
In pratica viene aggiunta una sentinella che reagisce sempre
all'evento text ed esegue il comando:
/budus if $ru.mode = @ ...
quando nel canale viene scritta una frase che soddisfa la seguente
espressione regolare:
^!nickdata$_.*$_
dato che '$_' viene risolto come uno spazio, l'espressione diventa:
^!nickdata .*
il che significa che la condizione sara' soddisfatta se la frase
scritta inizia (^) con "!nickdata", ha uno spazio, qualsiasi cosa e un
altro spazio. Cio' determina, ad esempio, che reagira' se viene
scritto:
!nickdata budus associamo un po' di info
ma non in questo caso:
!nickdata budus
Ora passiamo all'azione della sentinella:
/budus if $ru.mode = @ ...
Nelle sentinelle la variabile $ru sta per "Remote User" e rappresenta
chi subisce l'evento (salvo non si tratti degli eventi mode o kick);
nel nostro caso $ru diventera' il nickname di chi ha scritto il
comando, immaginiamo sia "budus", quindi si risolve cosi':
/budus if budus.mode = @ ...
A questo punto subentra il comando if che risolve quello che per lui
e' un attributo applicato ad un nickname, cioe' ".mode"; "budus.mode"
viene convertito nel carattere che identifica la modalita'
dell'utente. Se questi risulta un OP, viene sostituito con il
carattere '@'.
Un'altra possibilita' importante offerta dal comando "/budus if" e'
quella di utilizzare il risultato di comandi eseguiti dal sistema
operativo come espressione di confronto. Esempio:
/budus if "$(uname -a)" : linux /SAY $nickname sta usando: $output
La sintassi "$(...)" e' quella che permette di lanciare un comando al
sistema operativo e catturarne l'output - che viene poi memorizzato
nell'omonima variabile $output - e usarlo come espressione (solo in
quella base e' consentito).
L'operatore ':' significa che nel risultato dell'espressione base,
viene cercata la *presenza* - case insensitive - della stringa
"linux"; se cio' viene soddisfatto, esegue il comando:
/SAY $nickname sta usando: $output
Qui abbiamo che $nickname e' il nickname dell'utente locale e $output
e', appunto, cio' che e' ha prodotto il comando "uname -a" (provarlo
su un terminale, per capire cosa fa).
_______________________________________________________________________________ 036____________________________________________________________________________
DOMANDA: POSSO IGNORARE I MESSAGGI PRIVATI DA PARTE DI QUALCUNO IN
AUTOMATICO ?
RISPOSTA:
Si, lo script e' dotato di un sistema che si chiama "Private Killer"
e che consente di determinare quali utenti possono aprire dialoghi
privati (QUERY), inviare NOTICE o INVITI.
Alla ricezione di un "messaggio privato" (QUERY, NOTICE o INVITE) in
automatico - se il sistema e' attivo - viene chiesto all'utente di
effettuare una delle seguenti quattro scelte:
1- Accettare il messaggio
2- Accettare il messaggio in modo permanente
3- Negare il messaggio
4- Negare il messaggio in modo permanente
Se si Accetta o Nega in modo permanente, nickname ed hostname
dell'utente vengono salvati in un apposito file (
$HOME/.xchat2/buduscript/private_killer.txt ) e, in automatico, tutti
i messaggi provenienti dal medesimo nickname o hostname saranno,
rispettivamente, accettati o negati anche in future sessioni di
XChat.
Nel menu "Comandi Utente" c'e' un apposito sub-menu che consente di
amministrare suddetto file.
Il messaggio di richiesta citato prima, rimane in attesa per un
numero di secondi limitato dalla variabile "iPrivateKillerAlert"
(vedi: /budus help pktime). Se si imposta suddetto tempo a zero (0),
di fatto si disabilita il sistema "Private Killer".
_______________________________________________________________________________ 037____________________________________________________________________________
DOMANDA: POSSO FILTRARE I MESSAGGI INDESIDERATI ?
RISPOSTA:
Esiste la possibilita' di censurare sistematicamente i messaggi che
soddisfano almeno un filtro di quelli salvati nel file
$HOME/.xchat2/filter.txt
Per filtro si intende una stringa che determina cosa lo script deve
censurare; il filtro, a seconda di come e' composto, puo' agire su un
intero network, su un canale o su un singolo utente.
Ad esempio:
irc.budus.net,#miocanale,budus,
e' un filtro che censura tutto quello che scrive "budus" nel canale
"#miocanale" del network "irc.budus.net"; se si vuole censurare il
solo canale si puo' usare:
irc.budus.net,#miocanale,
in modo che lo sia solo sul network "irc.budus.net", oppure:
#miocanale,
in modo che lo sia su qualsiasi network.
NB: Il sistema non e' case-sensitive, quindi non importa fare
distinzione di minuscole e maiuscole.
Oltre a censurare "in modo indiscriminato" (cioe' qualsiasi cosa
venga scritta) e' possibile filtrare solo specifiche parole; ad
esempio da fastidio che un BOT ci scriva il solito "ciao" appena si
entra in un canale e il BOT ha nickname "Bottolo", usare:
Bottolo,ciao
come sopra, e' sempre possibile specificare canale e nome del network:
#miocanale,Bottolo,ciao
irc.budus.org,#miocanale,Bottolo,ciao
Se la parola da censurare "non e' la prima cosa che viene scritta" e'
anche possibile usare le espressioni regolari anteponendo il carattere
'/', ad esempio:
/irc.budus.org,#miocanale,.*leggi il regolamento
Anziche' censurare e' possibile anche solo rimuovere i codici colore
da tutti i messaggi che soddisfano il filtro, aggiungendo la parola
chiave "removecolors(); ad esempio per rimuovere i colori da tutto
quello che scrive "budus":
budus,removecolors()
se si vuole che agisca sul solo canale "#buduscript":
#buduscript,budus,removecolors()
se si vuole specificare anche il server:
irc.budus.org,#buduscript,budus,removecolors()
se si vuole l'intero canale senza colori (quindi qualsiasi utente):
irc.budus.org,#buduscript,removecolors()
_______________________________________________________________________________ 038____________________________________________________________________________
DOMANDA: POSSO FARE BANKICK IN AUTOMATICO SU UTENTI CHE "SPAMMANO ALTRI
CANALI" ?
RISPOSTA:
Si, e' possibile creare una sentinella che, facendo uso dei "comandi
condizionali" ("/budus if", "/budus else", "/budus else if" e "/budus
cmd") e delle relative "funzioni avanzate" ("filter( +-regexp,string
)"), individua gli utenti che "sponsorizzano canali diversi da quello
corrente" e ne esegue il BANKICK.
Risolviamo il problema per gradi, iniziando da questo: come individuo
un utente che, in quello che scrive, inserisce il nome di un canale ?
Possiamo iniziare con l'immaginare che dovremo creare una sentinella
che reagisce all'evento TEXT ed esegue la sua azione nel momento in
cui vada ad individuare il carattere "#" (i nomi dei canali,
solitamente, iniziano con #); ecco che un inizio puo' essere:
/event add 0 text '#='$data'
Con "'#" stabiliamo che la COSTANTE non deve essere un'espressione
regolare (dato che la facciamo precedere dall'apice) e che, affinche'
la condizione sia soddisfatta, la variabile "$data" dovra' contenere
il carattere #.
In questo modo scartiamo tutte le frase che sicuramente non
contengono il nome di un canale (o comunque non lo contengono in "modo
che sia cliccabile per il join").
A questo punto sappiamo che, quando la sentinella eseguira' la sua
azione, molto probabilmente la variabile "$data" conterra' il nome di
un canale.
Ora il problema diventa: estrapolare dalla variabile "$data" il nome
del canale.
Supponiamo di avere la frase: "Ciao a tutti, entrate in #buduscript !"
Attraverso la funzione avanzata "filter" possiamo, da questa frase,
estrapolare il nome del canale sapendo che:
1) Il nome del canale inizia con #
2) Puo' essere formato da qualsiasi carattere che non sia una virgola
o uno spazio
L'espressione regolare che risponde a questi due requisiti e' la
seguente: #[^ ,]*
(per info: Espressione Regolare )
Dato che il carattere virgola viene usato dalle funzioni avanzate per
separare i parametri, dobbiamo necessariamente sostituirlo - nella
nostra espressione regolare - con un'apposita parola chiave:
_BUDUSCRIPT_COMMA_
Quindi l'espressione diventa: #[^ _BUDUSCRIPT_COMMA_]*
Proviamo a fare un test:
/budus cmd /ECHO filter( +#[^ _BUDUSCRIPT_COMMA_]*,Ciao a tutti, entrate in #buduscript ! )
otterremo proprio quello che cerchiamo: #buduscript
N.B.: Il carattere "+" usato nella funzione "filter" server
per tagliare tutto quello che non viene intercettato
dall'espressione regolare usata; se avessimo usato il "-" il
risultato sarebbe stato: "Ciao a tutti, entrate in !"
Non rimane altro da fare che completare la sentinella, aggiungendo il
confronto per stabilire se il canale scritto e' diverso da quello
corrente con la conseguente azione di KICKBAN dell'utente che ha
generato l'evento:
/event add 0 text '#='$data' /budus if "filter( +#[^ _BUDUSCRIPT_COMMA_]*,$data )" ! $channel /KICKBAN $ru No Spam, grazie !
E' chiaro che una sentinella di questo tipo puo' reagire anche se un
utente scrive "# ciao a tutti #" ma non se scrive "ciao a tutti quelli
di #buduscript" (chiaramente "#buduscript" deve essere il canale
corrente, contenuto nella variabile "$channel").
Praticamente, qualsiasi "decorazione" che contiene il carattere "#",
verra' interpretata come spam. Se la cosa non risulta tollerabile, si
rende necessario aggiungere ulteriori controlli su quanto scritto.
Per fare ulteriori controlli e' opportuno memorizzare "il nome del
canale intercettato" all'interno di una variabile ed eseguire i
controlli sfruttando quest'ultima; ad esempio la sentinella sopra la
si puo' scrivere anche cosi':
/event add 0 text '#='$data' /budus cmd /budus set spam_channel_name filter( +#[^ _BUDUSCRIPT_COMMA_]*,$data )\;/budus if $spam_channel_name ! $channel /KICKBAN $ru No Spam, grazie !
Prima viene creata la variabile "$spam_channel_name" contenente il
nome del canale intercettato in "$data" e poi viene fatto il
confronto. Giusto per dare un'esempio di aggiunta di un ulteriore
controllo - ad esempio sulla lunghezza del nome del canale - fornisco
questo comando:
/event add 0 text '#='$data' /budus cmd /budus set spam_channel_name filter( +#[^ _BUDUSCRIPT_COMMA_]*,$data )\;/budus if $spam_channel_name ! $channel /budus if "lenght( $spam_channel_name )" > 2 /KICKBAN $ru No Spam, grazie !
_______________________________________________________________________________ 039____________________________________________________________________________
DOMANDA: POSSO FARE BANKICK IN AUTOMATICO SU UTENTI PROVENIENTI DA
CANALI SGRADITI ?
RISPOSTA:
Si, e' possibile creare una sentinella che, facendo uso dei "comandi
condizionali" ("/budus if", "/budus else", "/budus else if" e "/budus
cmd") e delle relative "funzioni avanzate", individua gli utenti che
"provengono da canali non graditi".
Risolviamo il problema per gradi, iniziando da questo: come individuo
un utente che, quando entra nel mio canale, risulta provenire da uno sgradito ?
Il problema lo si risolve effettuando un "/WHOIS" dell'utente che
effettua il join e controllando che la lista dei canali ottenuti in
risposta da quest'ultimo non combaci con una lista di "canali
sgraditi" (ad esempio, contenuta all'interno di un file che potremmo
chiamare "badchannel.txt", dove elencheremo, per ogni riga, un canale
da "BANNARE").
Possiamo iniziare con una sentinella che controlla ogni join
effettuato:
/event add 0 jchannel '$nick'!'$ru' ...
gia' questa controlla tutti i join non effettuati dall'utente locale,
quindi quelli di tutti gli altri. La lista dei canali che l'utente
"joinante" potremmo memorizzarla all'interno di una variabile
(chiamiamola "badchannel_joined_list"); come prima cosa la
"inizializziamo" con:
/budus set badchannel_joined_list _NONE_
l'inserimento della lista all'interno di questa variabile lo facciamo
in un secondo momento, prima ci occupiamo di "intercettare il
risultato del WHOIS". Possiamo farlo con una sentinella come questa:
/event add ? other '$channel:$server$_319$_$lu$_$ru$_:='$channel^data' /event event spcl_badchannel $event_params
la quale e' personalizzata in base al canale, al server, al nick
dell'utente locale e a quello di quello remoto; altra peculiarita' sta
nel fatto che e' di tipo auto-eliminante (il parametro RIPETIZIONI e'
"?"): cio' significa che, una volta che avra' reagito, si
auto-cancellera'. Questo le consente di fare il suo lavoro nel momento
in cui riceve i dati del WHOIS e quindi eliminarsi da sola. La sua
AZIONE consiste nel generare un evento "spcl_badchannel", che e' di
tipo speciale e verra' gestito da una sentinella che vedremo tra poco.
Infine, dobbiamo preoccuparci di fare il WHOIS, quindi:
/whois $ru
Unendo il tutto otteniamo che la prima sentinella da creare e' la
seguente:
/event add 0 jchannel '$nick'!'$ru' /budus set badchannel_joined_list _NONE_\;/event add ? other '$channel:$server$_319$_$lu$_$ru$_:='$channel^data' /event event spcl_badchannel $event_params\;/whois $ru
(notare che i vari comani esposti sopra, sono l'AZIONE della prima
sentinella esposta e sono separati da "\;")
Fino a qui abbiamo stabilito cosa fare quando un utente entra:
eseguirne il "WHOIS", catturare i dati di quest'ultimo e inviarli alla
sentinella che dovra' reagire all'evento "spcl_badchannel".
Ora occupiamoci di elaborare i dati del "WHOIS": dobbiamo memorizzare
la lista dei canali - e quindi estrapolare questa lista dal WHOIS -
dentro la sentinella inizializzata prima e verificare se uno di questi
combacia con il file lista dei canali proibiti.
La sentinella deve semplicemente reagire all'evento
"spcl_badchannel", quindi abbiamo soltanto:
/event add 0 spcl_badchannel *
Ora dobbiamo estrapolare i dati del "WHOIS" ed immagazzinarli nella
variabile "badchannel_joined_list":
/budus cmd /budus set badchannel_joined_list search( :,$data )
Qui abbiamo sfruttato la funzione "search( pattern,string )"; in
particolare abbiamo cercato la prima corrispondenza di " :" nella
variabile "$data", che e' quella contenente i dati del "WHOIS"
(quest'ultimo ritorna diverse linee, ma sopra abbiamo filtrato solo
quella che contiene il codice numerico " 319 ", che e' quella con la
lista dei canali).
Per eseguire il controllo ci avvaliamo della BASH, quindi, sara'
quest'ultima ad eseguire l'elaborazione e decidere il da farsi; il
comando per intero e' il seguente:
/budus cmd /budus pipe_script for chan_join in $(cat "$HOME/$mxchat_path/buduscript/badchannel.txt") ; do find_channel=$(echo \($badchannel_joined_list\) | grep -F "${chan_join} ") ; if test "${find_channel}" != "" ; then echo \(/budus sendsess $server/$channel /budus ban + *!*@$domain init( $badchannel_ban_time,3600 ) $ru\); echo "/budus sendsess $server/$channel /KICK $ru Non sono graditi gli utenti di ${chan_join}"; fi; done
Al fine di comprenderlo, lo formatto su piu' righe:
/budus cmd
/budus pipe_script
for chan_join in $(cat "$HOME/$mxchat_path/buduscript/badchannel.txt") ; do
find_channel=$(echo \($badchannel_joined_list\) | grep -F "${chan_join} ") ;
if test "${find_channel}" != "" ; then
echo \(/budus sendsess $server/$channel /budus ban + *!*@$domain init( $badchannel_ban_time,3600 ) $ru\);
echo "/budus sendsess $server/$channel /KICK $ru Non sono graditi gli utenti di ${chan_join}";
fi;
done
Notare alcune cose:
- La funzione "/budus cmd" ha lo scopo di risolvere la variabile
"$badchannel_joined_list" con la lista dei canali.
- La funzione "/budus pipe_script" ha lo scopo di eseguire i comandi
successivi nel sistema, catturarne l'output ed eseguirlo come
fossero comandi scritti dall'utente.
- La funzione "/budus pipe_script" va a sostituire "\(" e "\)" con
gli apici e protegge i parametri inclusi.
- Il comando:
for chan_join in $(cat "$HOME/$mxchat_path/buduscript/badchannel.txt") ; do
va, per ogni linea del file "badchannel.txt" ad immagazzinarne il
contenuto in "${chan_join}" (che e' una variabile BASH) e ad
eseguire i comandi successivi fino al "done".
- Nel percorso del file viene usato "$mxchat_path"; questa e' una
variabile delle MACRO. Se non si caricano le sentinelle qui esposte
da una MACRO e' necessario usare un valore appropriato (ad ex:
"$HOME/.xchat2/buduscript/badchannel.txt")
- Il comando:
find_channel=$(echo \($badchannel_joined_list\) | grep -F "${chan_join} ") ;
ha lo scopo di eseguire il controllo se, nella lista dei canali
ritornati dal "WHOIS", e' presente il canale proibito in esame
(contenuto in "${chan_join}"); per evitare "intercettazioni
sbagliate" e' necessario fare il controllo post-ponendo uno spazio
al nome del canale (nel "WHOIS" la lista dei canali e' separata da
spazio, anche nell'ultimo elencato).
- Il resto dei comandi viene eseguito se avviene
l'intercettazione. Porre attenzione all'uso della funzione "init(
variabile,valore )" usata in questo modo:
init( $badchannel_ban_time,3600 )
Questo dettaglio consente di poter personalizzare il "tempo di
UNBAN" configurando la variabile "$badchannel_ban_time" (ex:
"/budus set badchannel_ban_time 1800"), oppure, di lasciare il
"valore di default" (3600).
Riassumento, per risolvere il problema proposto, utilizzare queste
due sentinelle:
/event add 0 jchannel '$nick'!'$ru' /budus set badchannel_joined_list _NONE_\;/event add ? other '$channel:$server$_319$_$lu$_$ru$_:='$channel^data' /event event spcl_badchannel $event_params\;/whois $ru
/event add 0 spcl_badchannel * /budus cmd /budus set badchannel_joined_list search( :,$data )\;/budus cmd /budus pipe_script for chan_join in $(cat "$HOME/$mxchat_path/buduscript/badchannel.txt") ; do find_channel=$(echo \($badchannel_joined_list\) | grep -F "${chan_join} ") ; if test "${find_channel}" != "" ; then echo \(/budus sendsess $server/$channel /budus ban + *!*@$domain init( $badchannel_ban_time,3600 ) $ru\); echo "/budus sendsess $server/$channel /KICK $ru Non sono graditi gli utenti di ${chan_join}"; fi; done
(possibilmente dentro una MACRO) e creare il file "badchannel.txt"
nella cartella "buduscript".
_______________________________________________________________________________ 040____________________________________________________________________________
DOMANDA: POSSO COLLEGARMI, CON IL MEDESIMO XCHAT, AL MEDESIMO SERVER CON
NICKNAME DIVERSI ?
RISPOSTA:
Praticamente no.
Il plugin non supporta la modalita' multi-utente, ovvero, collegarsi
con il medesimo XChat (cioe' la stessa istanza del programma), allo
stesso identico server/network (chiaramente con nickname diversi).
Nonostante sia poi praticamente possibile farlo e il plugin possa
anche funzionare senza troppi problemi (e' comunque possibile che vada
in crash in circostanze particolari), mi sento di sconsigliare questo
utilizzo di XChat/BuDuScRiPt; l'opzione migliore e' sicuramente quella
di lanciare piu' istanze di XChat.
Al limite si puo' operare in questo modo:
- si lancia una istanza di XChat e la si usa per "chattare".
- si lancia una seconda istanza di XChat, si scarica il
plugin ( "/unload budus.so" ) e ci si collega dove e come
si vuole.
cosi' facendo si ottiene una copia con tutte le funzionalita' e
un'altra che serve esclusivamente alla creazione dei cloni.
_______________________________________________________________________________ 041____________________________________________________________________________
DOMANDA: PER QUALE MOTIVO, SE SUO "/BUDUS IGNORE" SU CERTI UTENTI, POCO
DOPO VIENE RIMOSSO LO STATO DI IGNORE ?
RISPOSTA:
Per default il plugin utilizza come maschera di ignore l'hostname di
un utente in modo che, anche se cambia nickname, comunque continuera'
ad essere ignorato.
Puo' tuttavia succedere che, procedendo con questo tipo di maschera,
gli utenti che vengono ad essere ignorati in un canale risultino ben
piu' di uno; cio' accade, ad esempio, quando si e' in presenza di
hostname virtuali (amministratori, ecc...). Il plugin si accorge di
questa situazione e opera una maschera di tipo diverso, basata anche
sul nickname, oltre che l'hostname, tuttavia, puo' succedere che, con
questo tipo di maschera, non risultando ignorati da XChat alcuni
utenti (il motivo non e' ben chiaro) e, di conseguenza, il plugin
procede a rimuoverli dallo stato di ignore (e' comunque XChat a
stabilire chi e' ignorato in base al suo database).
La soluzione, in questi casi, e' quella di utilizzare il comando di
ignore fornito da XChat stesso e basato sul nickname. Successivamente,
si puo' tentare l'uso anche di "/budus ignore" sul medesimo utente, in
modo che venga ignorato anche in base all'hostname; sembra che, dopo
aver usato l'ignore di XChat, anche quello di BuDuScRiPt si
"stabilizzi" eliminando il problema di cui sopra.
_______________________________________________________________________________ 042____________________________________________________________________________
DOMANDA: E' POSSIBILE PERSONALIZZARE L'ANNUNCIO DELLA CANZONE IN
ASCOLTO ?
RISPOSTA:
Si, e' possibile creare un file di personalizzazione che dica in che
modo le canzoni in ascolto (mp3, mid, o quant'altro) con i vari player
audio supportati (mpg123, xmms, mplayer, timidity, Rhythmbox,
Audacious, Amarok, Exaile) devono essere annunciate.
Non solo: dato che esistono 4 tipoligie di annuncio (DEFAULT, FILE,
FTP e VIDEO), si possono avere altrettante personalizzazioni.
Per informazioni circa la sintassi usata dal manager degli annunci,
consultare la domanda: 015 E' SUPPORTATO XMMS ?
Per personalizzare gli annunci e' necessario creare un file di nome
"budus_mp3_command.txt" nella cartella ".xchat2/buduscript/"; il file
deve contenere 4 righe la cui sintassi e' la seguente:
DEFAULT:
FILE:
FTP:
VIDEO:
Al posto di "" bisogna mettere il comando IRC incaricato
di eseguire l'annuncio; solitamente si tratta di "/SAY" o "/ACTION",
ma si possono usare anche altri comandi XChat o BuDuScRiPt per
situazioni piu' sofisticate.
Al posto di "" bisogna mettere quello che effettivamente si
vuole che appaia; ad esempio un possibile annuncio potrebbe essere:
/SAY Sto ascoltando una canzone
dove "/SAY " rappresenta "" e "Sto ascoltando una
canzone" equivale a "".
Chiaramente, cosi' facendo, non si ha modo di personalizzare la cosa
indipendentemente dalla canzone ascoltata. Ecco quindi che in il
parametro "" puo' contenere delle VARIABILI che assumono un
valore a seconda della situazione.
Le variabili disponibili sono:
PLAYER_NAME -> Player usato per riprodurre il media
DEFAULT_DATA -> Equivale a: [ MEDIA_TIME ][ MEDIA_BITRATE ][ MEDIA_SIZE ]
MEDIA_FULLPATH -> Percorso completo del media
MEDIA_TIME -> Durata del media
MEDIA_BITRATE -> Bitrate del media
MEDIA_SIZE -> Dimensione del media
MEDIA_NAME -> Nome del media (senza percorso ed estensione)
MEDIA_FILENAME -> Nome del file del media
MEDIA_FILEPATH -> Percorso del media, senza nome del file
MEDIA_PARSED_NAME -> Nome del media con la formattazione di default
MEDIA_AUTHOR_NAME -> Autore del media
MEDIA_TITLE_NAME -> Titolo del media
MEDIA_VIDEO_URL -> URL ad un video collegato al media
MP3_FULLPATH -> Eventuale percorso completo al file MP3
FTP_CURRENT_IP -> IP del Server FTP locale
OUTPUT_TYPE -> Tipoligia di output
Se il media in ascolto e' un file mp3 (e non uno streaming) e risulta
installato il software che fornisce il comando "id3info" e' possibile
utilizzare questi ulteriori TAG (che vengono prelevati direttamente
dal file):
TAG_TITLE -> Titolo
TAG_ARTIST -> Artista
TAG_ALBUM -> Album
TAG_YEAR -> Anno
TAG_TRACK -> Numero della Traccia
TAG_COMMENT -> Commento
TAG_GENDER -> Genere
TAG_CODEC -> Codec del file
TAG_BITRATE -> Bitrate
TAG_FREQUENCY -> Frequenza
Affinche' "id3info" riesca a catturare le informazioni e' necessario
che il player utilizzato fornisca il path completo al file; in caso di
problemi e' possibile verificare se il path completo e' corretto
facendo un test con la variabile "MEDIA_FULLPATH".
Ad esempio un file di personalizzazione potrebbe essere come il
seguente:
DEFAULT:/ACTION ascolta con PLAYER_NAME: MEDIA_PARSED_NAME%O DEFAULT_DATA
FILE:/ACTION ascolta con PLAYER_NAME: TAG_ARTIST - TAG_TITLE (TAG_ALBUM - TAG_YEAR) [TAG_BITRATE:TAG_FREQUENCY]
FTP:/ACTION ascolta con PLAYER_NAME: MEDIA_PARSED_NAME%O (OUTPUT_TYPE: FTP_CURRENT_IP/MEDIA_FULLPATH)
VIDEO:/ACTION ascolta con PLAYER_NAME: MEDIA_PARSED_NAME%O (OUTPUT_TYPE: MEDIA_VIDEO_URL)
Facendo prove non dovrebbe essere difficile capire il
meccanismo. Notare che se non viene rispettata perfettamente la
sintassi prevista, la personalizzazione viene completamente ignorata e
si procede con la visualizzazione di default.
_______________________________________________________________________________ 043____________________________________________________________________________
DOMANDA: E' SUPPORTATO TWITTER ?
RISPOSTA:
Si', e' supportato.
Il plugin consente di scaricare i "tweets" dal Social Network
"Twitter" e di pubblicarli in forma privata (che vede solo l'utente,
localmente) che pubblica (in un specifico network/canale IRC).
Per default il servizio è attivo e scarica i tweets provenienti da
"budus_it"; è possibile personalizzare lo script modificando
manualmente il file "$HOME/.xchat2/buduscript/twitter.cfg" (tramite il
comando di menu: BuDuScRiPt -> Twitter -> Modifica File di
Configurazione ... ).
Il file di configurazione è internamente commentato e fornisce le
informazioni necessarie alla sua modifica, con tanto di esempi.
Nel caso in cui non sia presente è sintomo che "qualcosa è andato
storto in fase di installazione" ed è necessario procedere con il
comando:
/EXEC $HOME/.xchat2/buduscript && ./install.sh
e riavviare XChat, in modo che la procedura di installazione sia
completata.
Se il problema persiste, forse è il caso di re-installare il plugin.
_______________________________________________________________________________ 044____________________________________________________________________________
DOMANDA: E' POSSIBILE DISABILITARE IL "WHOIS REDIRECT" ?
RISPOSTA:
Si, e' possibile farlo.
Bisogna aggiungere nei comandi dell'Esecuzione Automatica (vedi menu:
"BuDuScRiPt -> Esecuzione Automatica") il seguente comando:
/budus set buduscript_macro__disable_whois_redirect 1
Al successivo avvio di XChat il "WHOIS REDIRECT" sara' comunque
disabilitato.
_______________________________________________________________________________ 045____________________________________________________________________________
DOMANDA: SI PUO' DISABILITARE IL MESSAGGIO DI "NUOVO POST SUL FORUM" ?
RISPOSTA:
Si, e' possibile farlo.
Bisogna aggiungere nei comandi dell'Esecuzione Automatica (vedi menu:
"BuDuScRiPt -> Esecuzione Automatica") il seguente comando:
/budus set buduscript_macro__onload_forum 0
Al successivo avvio di XChat non verranno piu' controllati nuovi post
sul Forum.
_______________________________________________________________________________ 046____________________________________________________________________________
DOMANDA: POSSO APRIRE I LINK IRC:// IN XCHAT DIRETTAMENTE DA BROWSER ?
RISPOSTA:
Si, e' presente uno script in
"$HOME/.xchat2/buduscript/buduscript_xchat_url.sh" che puo' essere
utilizzato per automatizzare l'apertura dei link di tipo
"irc://server:port/channel" direttamente in XChat (si collega in
automatico al Server ed entra nel canale specificato).
Per chi utilizza Firefox, procedere come segue:
- Nella barra degli indirizzi inserire: about:config
- Confermare l'operazione cliccando "Faro' attenzione, prometto"
- Nella finestra che si apre, cliccare con il tasto destro del mouse
su una riga qualsiasi e scegliere la voce di menu: Nuovo > Booleano
- Inserire il valore: network.protocol-handler.external.irc
- Impostarlo a: true
- Nella medesima finestra, cliccare nuovamente con il tasto destro del
mouse su una riga qualsiasi e scegliere la voce di menu: Nuovo >
Stringa
- Inserire il valore: network.protocol-handler.app.irc
- Inserire il valore: ~/.xchat2/buduscript/buduscript_xchat_url.sh
Questo dovrebbe bastare; se non funziona e' possibile che, cliccando
su un link della citata tipologia, si apra una finestra che chiede
cosa fare e, tramite la quale, e' comunque possibile selezionare lo
script in oggetto (non confondersi con un'eventuale opzione "xchat"
gia' presente, la quale, si limita ad aprire un'altra sessione del
client e non sfrutta quella eventualmente attiva).
_______________________________________________________________________________ 047____________________________________________________________________________
DOMANDA: COS'E' L'XDCC MANAGER ?
RISPOSTA:
E' un sistema con il quale cercare e scaricare file tramite IRC.
Ci tengo a sottolineare una cosa: Il materiale che viene individuato
dalla ricerca o comunque scaricato dal sistema non e' in nessun caso
gestito da UDA'Software; in altri termini, si tratta di files messi a
disposizione da persone o comunque organizzazioni che non conosco e
con le quali non ho nessun rapporto, semplicemente, ho trovato le
fonti cercando su Internet e le ho selezionate a caso (chiaramente tra
quello che sono risultate "stabili" in termini di fornitura del
servizio).
Detto questo, il sistema XDCC MANAGER si compone di 2 parti:
- Motore di Ricerca File
- Manager dei Download XDCC
Tramite il "Motore di Ricerca File" e' possibile cercare i file che si
desidera scaricare in base al nome. E' a sua volta composto da quelli
che ho definito XBSPSE (XDCC Bash Script Plugin Search Engine).
Sul Forum BuDuScRiPt e' presente un post che spiega in dettaglio cosa
sono gli XBSPSE e come si possono creare e addirittura distribuire:
http://budus.ilbello.com/Forum/viewtopic.php?f=6&t=118
Il sistema e' in grado di creare un database permanente dei files che
e' possibile scaricare e ne permette la consultazione in modi
diversi. Tra questi e' possibile utilizzare un software di
visualizzazione testuale apposito: UDA DATA COPY
E' un software che va scaricato ed installato separatamente da
BuDuScRiPt, va abilitata opportuna opzione (XDCC -> Configurazione ->
Utilizza UDA DATA COPY come Visualizzatore Esterno) - altrimenti viene
utilizzato un visualizzatore interno dello script - e lo si puo'
trovare a questo indirizzo:
http://digilander.libero.it/udasoft/multiplatform.html
Una volta individuato il nome del file che si desidera scaricare e'
possibile utilizzare il "Manager dei Download XDCC" in 3 modi:
1) Effettuata una ricerca (XDCC -> Cerca ...) vengono, per ogni
risultato, associati degli appositi links che e' possibile
inviare, cliccandoci sopra con il tasto destro del mouse, alla
voce "Download-XDCC". Tramite il menu XDCC e' quindi possibile
forzare gli item aggiunti alla coda dei download o
cancellarli.
2) E' possibile effettuare il download manualmente (anche qui, sono
possibili diverse modalita').
3) E' possibile effettuare il download in base ad un File Elenco,
opportunamente realizzato.
Sul Forum di BuDuScRiPt e' presente un post che spiega molto
dettagliatamente ogni funzionalita' dell'XDCC MANAGER, consiglio di
consultarlo per approfondire il funzionamento:
http://budus.ilbello.com/Forum/viewtopic.php?f=6&t=82
_______________________________________________________________________________
_______________________________________________________________________________
25/07/2012