No more maintained.
Now just a test in a lab.
Introduzione alla gestione dei programmi e dei processi
Informazioni sulla gestione dei pacchetti software su Linux. Overview sui processi e gli strumenti per visualizzarli.
Strumenti di aggiornamento del software su Linux
Tipo Infobox: DESCRIPTION - Skill: 2- JUNIOR
L'aggiornamento di un sistema operativo è un operazione fondamentale per la sua sicurezza, sia in ambito aziendale che domestico, sia su server che su desktop.
L'unica differenza sostanziale saranno i mezzi, le necessità e le modalità ma l'obbiettivo è comune: proteggere i propri sistemi aggiornandone il software regolarmente per eliminare possibili vie di intrusione tramite vulnerabilità note.
Esistono molteplici vie per eseguire l'update di sistemi Linux:
- utilizzare tool automatici o semi-automatici per il download e l'installazione di pacchetti rpm o deb,
- installare manualmente nuovi pacchetti binari per l'aggiornamento dei programmi installati,
- compilare i sorgenti con le patch del software da aggiornare.
L'uso di strumenti (semi)automatici, generalmente consigliabile quando si deve gestire un parco macchine considerevole, può basarsi su mirror distribuiti nel mondo o su un servizio, generalmente a pagamento, offerto dal produttore della distribuzione che si usa.
Ogni distribuzione Linux ha i propri metodi preferenziali per l'aggiornamento del software.
REDHAT
La versione commerciale di RedHat (Enterprise edition) si aggiorna tramite il RedHat Network (RHN) che permette di gestire e aggiornare facilmente anche via Web una moltitudine di sistemi. up2date, utilizzabile sia via command line che tramite interfaccia grafica, è il programma utilizzato per aggiornarsi tramite RHN.
Fedora, la distribuzione free di RedHat, aperta alla community, si aggiorna tramite yum (tool di aggiornamento derivato da Yellow Dog Linux) che si appoggia a svariti mirror worldwide.
Sono disponibili, ma non inclusi dei CD ufficiali, altri strumenti di aggiornamento come autorpm o la versione per rpm di apt.
DEBIAN
I pacchetti .dep di Debian vengono gestiti e aggiornati tramite il potente apt che appoggiandosi ad un elenco di mirror distribuiti permette di scaricare e aggiornare software sia del ramo "stable" che quello "testing". Con il comando apt-get di fatto si gestisce ogni attività.
MANDRIVA
L'aggiornamento e la gestione dei pacchetti rpm avviene tramite l'interfaccia grafica rpmdrake o il tool testuale urpmi. Entrambi si appoggiano a dei mirror configurabili e sono presenti di default sul sistema.
NOVELL - SUSE
Tramite il tool grafico di configurazione Yast2, strettamente integrato in ogni distribuzione Suse, è possibile gestire e automatizzare gli aggiornamenti dai mirror selezionati.
SLACKWARE
I pacchetti tgz di Slackware possono essere aggiornati dai mirror ufficiali tramite tool come swaret e slapt-get, che vanno scaricate a parte.
GENTOO
E' fortemente radicato nel sistema di gestione dei portage di Gentoo l'aggiornamento (tramite scaricamento dei sorgenti e ricompilazione automatica degli stessi) e l'installazione del software. Il comando emerge provvede a tutto.
Patching dei Sorgenti
Tramite utility come patch o diff, o semplicemente ricompilando i sorgenti presenti nel tar.gz (./configure ; make ; make install), è possibile applicare o creare patch (file contenenti modifiche da apportare ai file originari) al software installato sul sistema senza l'utilizzo di pacchetti. Questa operazione viene eseguita principalmente quando si lavora direttamente dai sorgenti, ricompilandoli una volta applicata la patch e può applicarsi a qualsiasi distribuzione.
Non essendo legata ad uno specifico sistema di packaging, va fatta manualmente.
Usare pacchetti (rpm) per l'installazione di programmi su Linux
Tipo Infobox: DESCRIPTION - Skill: 2- JUNIOR
Per installare dei programmi su Linux esistono vari modi:
- compilare il sorgente, pratica che può essere complessa ma è utile in casi particolari;
- utilizzare pacchetti (packages) che contengono i programmi già compilati e pronti per l'uso, facilitando e standardizzando la gestione del software sul sistema.
I sistemi di package più comuni su Linux sono RPM e DEB.
I pacchetti .deb vengono usati nelle distribuzioni derivate da Debian, gli .rpm sono stati definiti da RedHat e risultano essere i più diffusi.
Slackware pacchettizza il suoi programmi con normali tar gzippati: .tgz.
Affrontiamo qui l'uso di RPM, Red Hat Package Manager, sottolineando che file .deb e, in parte, .tgz vengono gestiti con comandi diversi ma hanno una logica simile.
Un package costruito con RPM è un archivio di file e informazioni che può essere installato, rimosso, interrogato sul sistema.
RPM permette di installare programmi, già compilati, con una facilità e rapidità estrema sul proprio Linux (è paragonabile ad un unico setup.exe su Windows).
Si sottolinea che ogni distribuzione e anche ogni versione della stessa distribuzione richiede pacchetti dedicati, adatti per il proprio sistema: un RPM realizzato per RedHat 6.2, per esempio, difficilmente funzionerà su RedHat 7.2.
RPM gestisce automaticamente le "dependencies": se si prova ad installare un RPM che richiede librerie o programmi non presenti o non abbastanza aggiornati sul sistema, l'installazione fallisce e viene indicato quali file mancano.
Analogamente, se si prova a rimuovere un package che contiene file utilizzati da altri programmi, viene dato un messaggio di errore.
Gli RPM automaticamente distribuiscono i file di un pacchetto nelle directory giuste (logs in /var/log, file di configurazione in /etc/, binari in /usr/bin o /usr/sbin, script di startup in /etc/rc.d/init.d/ ecc.) e verificano la presenza di conflitti o installazioni più recenti.
La rimozione di un RPM non cancella mai nulla che non abbia installato. Se deve sostituire o cancellare un file di configurazione, per esempio, viene mantenuto il file esistente con il suffisso .rpmsave.
Le opzioni più comuni per usare il comando rpm per gestire file .rpm sono:
rpm -i [opzioni] pacchetto Installa il pacchetto .rpm specificato.
rpm -U [opzioni] pacchetto Aggiorna il pacchetto con una versione più recente.
rpm -e [opzioni] pacchetto Disinstalla il pacchetto, rimuovendone i file dal sistema.
rpm -q [opzioni] [pacchetto] Visualizza informazioni varie sul pacchetto (descrizione, file contenuti ecc.)
Le comuni distribuzioni Linux offrono svariati tool grafici per una semplice gestione dei pacchetti installati sul sistema. Di fatto questi programmi eseguono le stesse operazioni del comando rpm, ma sono più semplici ed immediate da usare.
La tendenza, sempre più diffusa, è quella di prevedere meccanismi di update automatizzato, per gestire il sempre alto numero di aggiornamenti (per sicurezza e bug fix) di programmi.
E' un principio analogo al Windows Update su sistemi Microsoft, ma si applica a tutti i programmi installati, e non solo al sistema operativo.
Introduzione ai processi sotto Linux/Unix
Tipo Infobox: DESCRIPTION - Skill: 2- JUNIOR
Uno dei principali motivi del successo di Unix è senza dubbio dovuto alla sua capacità di multitasking. Per multitasking si intende la possibilità da parte del sistema operativo di far girare contemporaneamente più di una applicazione.
Ogni programma, ogni comando che si lancia, ogni servizio attivo sul sistema da origine a uno o più processi.
Ad ogni processo viene assegnato un numero che lo identifica univocamente, chiamato PID (Process IDentificator). Ogni processo, tranne init (a cui corrisponde il PID 1), è generato da un'altro processo di cui si definisce il PPID (Parent PID). Si parla quindi di processo padre (parent) e processo figlio (child).
Un processo consta di: codice eseguibile, posizione di esecuzione, dati che gestisce, file aperti, ambiente di esecuzione, credenziali.
Quando lo stesso programma è eseguito più volte nel sistema, anche da parte di utenti diversi, alcune parti dello stesso possono essere condivise (shared) in memoria: il codice in esecuzione e le eventuali librerie di sistema caricate, altre parti come i dati, i file aperti, il PID.
Un processo può generare una copia di se stesso (fork), cha ha PID diverso e PPID uguale al proprio PID.
La Schedulazione da parte del kernel
Nel kernel di un sistema operativo lo schedulatore (dispatcher) è responsabile della coordinazione dei processi in esecuzione per gestire i loro accessi alle risorse e assicurare che abbiano accesso alla CPU per un tempo relativo alla loro priorità assegnata, senza rischiare che alcuni processi intasino completamente il CPU time ed altri non riescano ad utilizzarla minimamente.
La schedulazione è un'operazione del kernel che definisce i seguenti stati di processo:
R - running, il processo è in esecuzione;
S - sleeping, il processo è in attesa (input dell'utente, conclusione di altri processi ecc..);
Z - zombie, il processo è morto ed aspetta che il parent chieda un codice d'uscita.
Ad ogni processo è associata una priorità, un valore che varia fra -20 e 19, che determina quanta CPU time rispetto agli altri il sistema gli deve dedicare.
La priorità pre-impostata di un task è 0 (-20 è considerata la priorità più alta). Solo l'amministratore puo resettare la priorità di un processo per portarla al di sotto di 0, ma i normali utenti possono variare la priorità per i valori positivi (usando il comando 'renice').
I nuovi processi ereditano la priorità dei loro padri.
JOB
La shell Unix è il tipico mezzo con cui vengono lanciati processi sul sistema (oltre ad essere essa stessa un normale processo), la shell assegna ad ogni processo lanciato da un utente un numero di job, e permette di mandare in foreground o background al sua esecuzione.
Gestione Processi
Tipo Infobox: DESCRIPTION - Skill: 2- JUNIOR
Ogni programma eseguito su un sistema è un processo, identificato con un suo PID. Quando un programma viene eseguito da una shell, assume anche un numero di job e può essere gestito all'interno della shell.
Le modalità fondamentali con cui si possono lanciare i job sono due: in foreground e in background.
Nella prima l'utente attende che l'esecuzione del suo processo termini prima di riottenere il prompt della shell.
Nella seconda invece il prompt viene restituito subito e il processo continua l'esecuzione. In questo modo l'utente può continuare a lavorare e quindi, volendo, potrebbe lanciare altri programmi in background.
Il segno & scritto alla fine del comando dice alla shell di eseguirlo in background e ridare subito il prompt.
Con CTRL-C si interrompe un processo.
Con CRTL-Z si mette in “pausa” un processo e si ritorna al prompt della shell.
La shell prevede una serie di comandi interni per gestire i job:
jobs: mostra i processi attivi in background lanciati da un certo utente. Il numero tra parentesi che viene restituito a video è il numero di, il “+” significa che è l’ultimo processo ad essere stato sospeso (fg senza parametri fa ripartire l’ultimo processo sospeso), l’altro numero è il PID.
bg: Esegue in background un processo precedentemente interrotto.
fg: Esegue un processo in primo piano.
Esistono inoltre vari comandi (file autonomi, non incorportati nella shell) utili per gestire i processi:
kill: Invia un segnale ad un processo attivo (normalmente utilizzato per fermare un processo).
nice [priority] [command]: E' un prefisso utilizzato per assegnare un certo livello di priorità al comando che si sta per eseguire. -20 vuol dire massima priorità, 19 è minima priorità.
nohup
ps: Visualizza un elenco dei processi in fase di esecuzione
pstree: Simile a ps ma mostra chiaramente le relazioni tra processi padre e processi figli.
top: Visualizza un elenco dei processi che sfruttano intensamente il processore e consumano molta memoria.
OpenBSD: Ricerca ed installazione pacchetti con OPM
Tipo Infobox: ARTICLES - Skill:
Gestire i pacchetti per OpenBSD in modo semplice.
Descrizione:
OPM (OpenBSD Packages Manager) è un gestore di pacchetti per OpenBSD.
Attualmente è in grado di cercare, installare, rimuovere, mostrare informazioni circa qualsiasi package disponibile sugli ftp OpenBSD.
Downloads:
Possiamo trovare la versione beta del software all'indirizzo: http://www.openbeer.it/codes/projects/OPM-0.1beta.tar.gz
La versione testing-unstable da CVS, invece, la troviamo qui: http://sickfreak.shacknet.nu/cgi-bin/cvsweb/OpenBSD_Packages_Manager/
Installazione:
Per installare OPM è sufficiente scaricare il tarbal ed eseguire lo script install.sh o, qualora si volesse fare a mano, compilare opm.c con gcc opm.c -o opm -L/usr/local/lib -I/usr/local/include -lcurl e copiare l'eseguibile opm nel path dei nostri binari (di solito /usr/bin).
Installare un pacchetto:
OpenBSD Packages Manager ci permette di installare un pacchetto e le relative dipendenze molto semplicemente.
Il software si occuperà di recuperare il pacchetto di nostro interesse dai server FTP del progetto OpenBSD, scaricato il pacchetto lo affiderà ai pkgstools del nostro sistema i quali si occuperanno di cercare ed installare le nostre dipendenze.
Prenderemo in esame la versione testing.
Lo spezzone di codice che si occupa di cercare il nostro pacchetto è il seguente:
char*
pkgname(package)
char *package;
{
FILE *fp;
char line[128];
int count;
char *pkg = NULL;
if ((fp = fopen("/etc/opm/repository.conf", "r")) == NULL)
errx(1, "%s", strerror(errno));
count = 0;
while(fgets(line, sizeof(line), fp) != NULL)
{
char* str = strcasestr(line, package);
if (str != NULL)
{
count++;
if(!pkg)
free(pkg);
if ((pkg = calloc(strlen(str), sizeof(char))) == NULL)
errx(1, "%s", strerror(errno));
strlcpy(pkg, str, strlen(str) +1);
}
}
if (count == 1)
{
return pkg;
}
else if (count == 0)
{
fprintf(stderr,"[E] No packages found !\n");
exit(-1);
}
else
{
fprintf(stderr,"[E] %d packages found !\n", count);
fprintf(stderr,"Use OPM with -s arg to search a package.\n");
exit(-1);
}
}
Il repository usato (/etc/opm/repository) altro non è se non un LIST del server ftp scelto attraverso la costante FTP dichiarata ad inizio sorgente ed ottenuta attraverso la funzione connection() sfruttante le libcurl:
char*
connection(verbose)
int verbose;
{
char *size = NULL;
CURL *get = NULL;
CURLcode code;
/* check OBSDVERS for OpenBSD version */
if(! strcasecmp(got_info(1), "3.9")) {
if ((size = calloc(strlen(FTP) + strlen("/pub/OpenBSD/snapshots/packages/") + strlen(got_info(0)) + strlen("/") + 1, sizeof(char))) == NULL)
errx(1, "%s", strerror(errno));
strlcpy(size, FTP, strlen(FTP) + 1);
strncat(size, "/pub/OpenBSD/snapshots/packages/", strlen("/pub/OpenBSD/snapshots/packages/") + 1);
strncat(size, got_info(0), strlen(got_info(0)) + 1);
strncat(size, "/", strlen("/") + 1);
*(size + (strlen(FTP) + strlen("/pub/OpenBSD/snapshots/packages/") + strlen(got_info(0)) + strlen("/") + 1)) = '\0';
} else {
if ((size = calloc(strlen(FTP) + strlen("/pub/OpenBSD/") + strlen(got_info(1)) + strlen("/packages/") + strlen(got_info(0)) + strlen("/") + 1, sizeof(char))) == NULL)
errx(1, "%s", strerror(errno));
strlcpy(size, FTP, strlen(FTP) + 1);
strncat(size, "/pub/OpenBSD/", strlen("/pub/OpenBSD/") + 1);
strncat(size, got_info(1), strlen(got_info(1)) + 1);
strncat(size, "/packages/", strlen("/packages/") + 1);
strncat(size, got_info(0), strlen(got_info(0)) + 1);
strncat(size, "/", strlen("/") + 1);
*(size + (strlen(FTP) + strlen("/pub/OpenBSD/") + strlen(got_info(1)) + strlen("/packages/") + strlen(got_info(0)) + strlen("/") + 1)) = '\0';
}
/* Inizialize FTP connection */
curl_global_init(CURL_GLOBAL_DEFAULT);
if ((get = curl_easy_init()) != NULL) {
curl_easy_setopt(get, CURLOPT_URL, size);
curl_easy_setopt(get, CURLOPT_WRITEFUNCTION, file_writing);
curl_easy_setopt(get, CURLOPT_WRITEDATA, &ftpfile);
if (verbose == 1) //check for verbose mode
curl_easy_setopt(get, CURLOPT_VERBOSE, 1);
code = curl_easy_perform(get); // FTP connection
curl_easy_cleanup(get);
if (code != CURLE_OK) {
fprintf(stderr, "Connection error\n\n");
exit(EXIT_FAILURE);
}
}
curl_global_cleanup();
return size;
}
OPM provvederà a parsare la lista alla ricerca del pacchetto da noi selezionato nel ciclo while.
Qualora ci fossero più pacchetti, provvederà a stampare a video la lista di tutti pacchetti installabili sfruttando la funzione search_pkg():
void
search_pkg(pkg)
char *pkg;
{
version();
fprintf(stdout, "Searching for packages...\n\n");
FILE *fp;
char line[128];
int count;
if ((fp = fopen("/etc/opm/repository.conf", "r")) == NULL)
errx(1, "%s", strerror(errno));
count = 0;
while(fgets(line, sizeof(line), fp) != NULL)
{
char* str = strcasestr(line, pkg);
if (str != NULL)
{
if (count == 0)
{
fprintf(stdout, "%s",str);
}
if (count > 1)
{
fprintf(stdout, "%s",str);
}
count++;
}
}
exit(EXIT_SUCCESS);
}
Dall'help fornito (-h) appare evidente che per installare un pacchetto l'argomento da utilizzare è "-I".
Vediamo, quindi, come si svolge l'installazione del pacchetto dnstracer:
# opm -I dnstracer
OpenBSD Packages Manager v.0.1beta
Your OpenBSD version: 3.8
Checking repository...
Package that will be installed is dnstracer-1.8.tgz
Are you sure ? [N|y]y
Installing...
parsing dnstracer-1.8
dnstracer-1.8: complete
Per installare un pacchetto OPM richiama la funzione install_pkg() la quale, a sua volta, riceve il pacchetto dal valore di ritorno della funzione pkgname(), descritta prima:
void
install_pkg(pkg)
char *pkg;
{
version();
char choise[2];
fprintf(stdout, "Package that will be installed is %s\nAre you sure ? [N|y]", pkgname(pkg));
scanf("%s", choise);
if ((strcasecmp(choise, "y") == 0))
{
fprintf(stdout, "Installing %s\n", pkgname(pkg));
char *command = NULL;
char *url = connection(0);
if ((command = calloc(strlen(url) + strlen(pkgname(pkg)) + strlen("/usr/sbin/pkg_add -v ") + 1, sizeof(char))) == NULL)
errx(1, "%s", strerror(errno));
strlcpy(command, "/usr/sbin/pkg_add -v ", strlen("/usr/sbin/pkg_add -v ") + 1);
strncat(command, url, strlen(url) + 1);
strncat(command, pkgname(pkg), strlen(pkgname(pkg)) + 1);
*(command + (strlen("/usr/sbin/pkg_add ") + strlen(url) + strlen(pkgname(pkg)) + 1)) = '\0';
system(command);
free(url);
free(command);
}
else
{
fprintf(stdout, "bye !\n");
exit(-1);
}
}
In pieno apt-style avremo il pacchetto comodamente installato sulla nostra OpenBSD box.
Scopriamo le altre possibili opzioni:
# opm -h
OpenBSD Packages Manager v.0.1beta
Your OpenBSD version: 3.8
DESCRIPTION:
OPM is a simple packages manager for OpenBSD.
USAGE:
-h this help
-I Pkg_Name install selected package
-R Pkg_Name remove selected package
-U update the OpenBSD packages repository
-S Pkg_Name show info about selected package
-V show OPM version
L'usabilità del programma è, com'è ben visibile, molto semplice.
Rimozione di un pacchetto:
Per eliminare un software dal nostro sistema il programma si affida all'utility pkg_delete attraverso la funzione remove_pkg():
void
remove_pkg(pkg)
char *pkg;
{
char temp_n[15] = "";
char *t_read;
FILE *temp_p;
int fd = -1;
int count;
char *choise;
char toremove[59 + strlen(pkg)];
version();
strlcpy(temp_n, "/etc/opm/temp", sizeof temp_n);
if ((fd = mkstemp(temp_n)) == -1 || (temp_p = fdopen(fd, "w+")) == NULL)
{
if (fd != -1)
{
unlink(temp_n);
close(fd);
}
fprintf(stderr, "%s: %s\n", temp_n, strerror(errno));
exit(-1);
}
snprintf(toremove, sizeof(toremove), "/bin/ls /var/db/pkg | /usr/bin/grep %s -i > %s", pkg, temp_n);
system(toremove);
if ((t_read = malloc(40 * sizeof(char))) == NULL)
errx(1, "%s", strerror(errno));
count = 0;
while ((fgets(t_read, 40, temp_p)) != NULL)
{
count++;
}
if (count == 0)
{
fprintf(stdout, "No packages found\n");
(int)fclose(temp_p);
(int)remove(temp_n);
exit(-1);
}
if (count > 1)
{
fprintf(stdout, "There are some results for this search: do you want view all pkgs ? [y|N]");
scanf("%s", choise);
if ((strcasecmp(choise, "y") == 0))
{
FILE *fp;
char line[128];
int count;
if ((fp = fopen("/etc/opm/temp", "r")) == NULL)
errx(1, "%s", strerror(errno));
while(fgets(line, sizeof(line), fp) != NULL)
{
fprintf(stdout, "%s",line);
}
fprintf(stdout, "\nChoose 1 file to remove and restart OPM with it for -R arg.\n");
}
else
{
fprintf(stdout, "bye !\n");
}
}
else
{
fprintf(stdout, "Package that will be deleted is %s\nAre you sure ? [N|y]", t_read);
scanf("%s", choise);
if ((strcasecmp(choise, "y") == 0))
{
char *command = NULL;
if ((command = calloc(strlen(t_read) + strlen("/usr/sbin/pkg_delete -v ") + 1, sizeof(char))) == NULL)
errx(1, "%s", strerror(errno));
strlcpy(command, "/usr/sbin/pkg_delete -v ", strlen("/usr/sbin/pkg_delete -v ") + 1);
strncat(command, t_read, strlen(t_read) + 1);
*(command + (strlen("/usr/sbin/pkg_delete -v ") + strlen(t_read) + 1)) = '\0';
system(command);
}
else
{
fprintf(stdout, "bye !\n");
}
}
(int)fclose(temp_p);
(int)remove(temp_n);
exit(EXIT_SUCCESS);
}
/etc/opm/temp farà da transito per la lista dei pacchetti selezionati, anche in questo caso, se la ricerca indicizzasse più pacchetti rispetto quanto da noi richiesto il programma si occuperà di printare il tutto a video lasciando all'utente la scelta del pacchetto effettivo da eliminare.
Rimuoviamo quindi il pacchetto precedentemente installato: dnstracer:
# opm -R dnstracer
OpenBSD Packages Manager v.0.1beta
Your OpenBSD version: 3.8
Package that will be deleted is dnstracer-1.8
Are you sure ? [N|y]y
deleting: /usr/local/bin/dnstracer
deleting: /usr/local/man/man8/dnstracer.8*********************** | 77%
dnstracer-1.8: complete
Info Pacchetto:
Per ricevere informazioni circa un pacchetto, OPM sfrutta la funzione info_pkg(), la quale sfrutta pkg_info:
void
info_pkg(pkg)
char *pkg;
{
char temp_n[15] = "";
char *t_read;
FILE *temp_p;
int fd = -1;
int count;
char *choise;
char getinfo[59 + strlen(pkg)];
version();
strlcpy(temp_n, "/etc/opm/temp", sizeof temp_n);
if ((fd = mkstemp(temp_n)) == -1 || (temp_p = fdopen(fd, "w+")) == NULL) //make a temp file for pkg_reading...
{
if (fd != -1)
{
unlink(temp_n);
close(fd);
}
fprintf(stderr, "%s: %s\n", temp_n, strerror(errno));
exit(-1);
}
snprintf(getinfo, sizeof(getinfo), "/bin/ls /var/db/pkg | /usr/bin/grep %s -i > %s", pkg, temp_n);
system(getinfo);
if ((t_read = malloc(40 * sizeof(char))) == NULL)
errx(1, "%s", strerror(errno));
count = 0;
while ((fgets(t_read, 40, temp_p)) != NULL)
{
count++;
}
if (count == 0)
{
fprintf(stderr, "No packages found\n");
(int)fclose(temp_p);
(int)remove(temp_n);
exit(-1);
}
if (count > 1)
[cut]
else
{
char *command = NULL;
if ((command = calloc(strlen(t_read) + strlen("/usr/sbin/pkg_info ") + 1, sizeof(char))) == NULL)
errx(1, "%s", strerror(errno));
strlcpy(command, "/usr/sbin/pkg_info ", strlen("/usr/sbin/pkg_info ") + 1);
strncat(command, t_read, strlen(t_read) + 1);
*(command + (strlen("/usr/sbin/pkg_info ") + strlen(t_read) + 1)) = '\0';
system(command);
}
(int)fclose(temp_p);
(int)remove(temp_n);
exit(EXIT_SUCCESS);
}
# opm -S irssi-0.8.9
OpenBSD Packages Manager v.0.1beta
Your OpenBSD version: 3.8
Information for irssi-0.8.9
Comment:
modular IRC client with many features (ipv6,socks,proxy)
Required by:
irssi-icb-0.14
Description:
Irssi is a modular IRC client that currently has only text mode user
interface, but 80-90% of the code isn't text mode specific, so other UIs could
be created pretty easily. Also, Irssi isn't really even IRC specific anymore,
there's already a working SILC module available. Support for other protocols
like ICQ could be created some day too.
Flavor: socks support for dante socks firewall implementation
Maintainer: Reinhard J. Sammer <[email protected]>
WWW: http://www.irssi.org/
Concludendo...
OpenBSD Packages Manager ricava le informazioni sulla nostra macchina attraverso la funzione got_info(), tali informazioni vengono usate per scegliere il pacchetto precompilato per la nostra distribuzione e per la nostra architettura:
char*
got_info(opt)
int opt;
{
struct utsname up;
uname(&up);
char *out;
if (opt == 1)
{
if ((out = calloc(strlen(up.release), sizeof(char))) == NULL)
errx(1, "%s", strerror(errno));
strlcpy(out, up.release, strlen(up.release) +1);
*(out + (strlen(up.release) + 1)) = '\0';
return out;
}
else if (opt == 0)
{
if ((out = calloc(strlen(up.machine), sizeof(char))) == NULL)
errx(1, "%s", strerror(errno));
strlcpy(out, up.machine, strlen(up.machine) +1);
*(out + (strlen(up.machine) + 1)) = '\0';
return out;
}
}
L'utilizzo di questo programmino ci semplifica la vita nel momento in cui ci permette di installare un pacchetto in maniera molto agevole, per un prossimo futuro, inoltre, è teorizzabile la comparsa di un'interfaccia GUI, rendendo il tutto ancora più user-friendly.
Buon divertimento!