uname

uname è una versione speciale di uname. Supporta -a, -s, -r, -n, -v, -m opzioni.
USO: uname [opzioni]
-s Stampa il nome del kernel
-v Stampa la versione del kernel
-r Stampa la versione del kernel
-n Stampa il nodo nome host di rete
-m Stampa il nome dell'hardware della macchina
-a stampa tutti i precedenti
Senza opzioni, uname comporta come -s uname
Esempio:
#include
#include
#include
#include
#include
print_usage void (void);
int main (int argc, char * argv [])
{
   int c;
   extern char * OPTARG;
   extern int OPTIND, optopt;
   int a_flag = 0, s_flag = 0, n_flag = 0, r_flag = 0, v_flag = 0,
       m_flag = 0;
   int errflag = 0;
   char host [256];
   uts struct utsname;
   if (gethostname (host, 255)! = 0 || uname (e UTS) <0)
   {
      fprintf (stderr, "Impossibile ottenere Informationn ospite");
      exit (1);
   }
   / * Se nessuna opzione, poi basta stampare sysname * /
   if (argc == 1) {
     s_flag = 1;
   }
   altro
   {
     while ((c = getopt (argc, argv, "asnrvm"))! = -1)
     {
        Interruttore (c) {
         caso 'a':
            a_flag = 1;
            interruzione;
         caso 's':
            s_flag = 1;
            interruzione;
         caso 'n':
            n_flag = 1;
            interruzione;
         caso 'r':
            r_flag = 1;
            interruzione;
         caso 'v':
            v_flag = 1;
            interruzione;
         caso 'm':
            m_flag = 1;
            interruzione;
         caso '?':
            errflag ++;
            interruzione;
       }
      }
    }
    / * Deve essere stata una o più opzioni errati passati -
stampa informazioni sull'utilizzo ed esce * /
    if (errflag! = 0)
    {
        print_usage ();
        exit (1);
    }
    
    char * sysname, * macchina * nodename, * rilascio, * versione;
    sysname = uts.sysname;
    macchina = uts.machine;
    nodename = uts.nodename;
    rilasciare = uts.release;
    version = uts.version;
    if (a_flag == 1) {
      printf ("% s% s% s% s% sn", sysname, nodename, il rilascio, la versione,
              macchina);
    }
    altro
    {
       char * PrintString;
       / * Allocare lo spazio sufficiente per tutte le eventualità .... * /
       PrintString = (char *) malloc (strlen (sysname) +
                                    strlen (versione) +
                                    strlen (release) +
                                    strlen (nodename) +
                                    strlen (macchina) +6);
       strcpy (PrintString, "");
       if (s_flag == 1) {
         strcat (PrintString, sysname);
         strcat (PrintString, "");
       }
       se (== n_flag 1) {
         strcat (PrintString, nodename);
         strcat (PrintString, "");
       }
se (== r_flag 1) {
         strcat (PrintString, rilascio);
         strcat (PrintString, "");
       }
if (v_flag == 1) {
         strcat (PrintString, versione);
         strcat (PrintString, "");
       }
       se (== m_flag 1) {
         strcat (PrintString, macchina);
         strcat (PrintString, "");
       }
       puts (PrintString);
       gratuito (PrintString);
    }
   return 0;
}
print_usage void (void)
{
* uso char [] = {"uname - (C) 2004 Kevin Waldron",
"Distribuito sotto i termini della GNU General Public Licence",
"USO", "uname [opzioni]",
"-s Stampa il nome del kernel",
"-v Stampa la versione del kernel",
"-r Stampa la release del kernel",
"-n Stampa il nodo nome host di rete",
"-m Stampa il nome dell'hardware della macchina",
"-a Stampa tutto quanto sopra",
"", "Senza opzioni, uname agisce come -s uname"};
    int i = 0;
for (i = 0; i <12; i ++)
{
printf ("% sn", * (utilizzo + i));
}
}