开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 系统/网络安全 > 扫描程序 > 查看源码
snmp.c
资源名称：admsnmp-01.tgz　[点击查看]
上传用户：lewson58
上传日期：2007-01-05
资源大小：7k
文件大小：17k
源码类别：

扫描程序

开发平台：

Unix_Linux

snmp.c：源码内容
  1. /*********** ADMsnmp (c) The ADM Crew ***************/
  2. /* snmp audit scanner                               */
  3. /* venus c faite femme et le grand pan est mort     */
  4. /* without libsnmp (that was hard :)                */
  5. /* i wonder why nobody wrote this one before ?      */
  6. /* action of this scanner                           */
  7. /*    {                                             */
  8. /*    guess  community names's                      */
  9. /*            from the hostname                     */
  10. /*            from a list of password               */
  11. /*        test if u have writable access to the MIB */
  12. /*   }                                              */
  13. /* Greets going to: #!ADM,el8.org and ansia my love */
  14. /* ftp://ADM.isp.at/ADM/                            */
  15. /*  we g0t the -1 day'z  :))                        */
  16. /****************************************************/
  17. /* g bien peur que la fin du monde soit bien triste */
  20. #define VERSION "beta 0.1"
  21. /** include :> **/ 
  24. #include <stdio.h>
  25. #include <stdlib.h>
  26. #include <string.h>
  27. #include <unistd.h>
  28. #include <ctype.h>
  29. #include <fcntl.h>
  30. #include <sys/types.h>
  31. #include <sys/time.h>
  32. #include <errno.h>
  33. #include <sys/stat.h>
  34. #include <netdb.h>
  35. #include <netinet/in.h>
  38. struct snmpchex
  39.   {
  40.     char name[16]; /* name of the community */
  41.     int id;        /* id of the request     */
  42.     int ret;       /* return code of the request */
  43.     u_char rw;     /*  writable or no ?          */
  44.   };
  47. struct optionz       /* option of the program's    */
  48.   {                   
  49.     u_long utimeout;
  50.     u_long uwait;
  51.     u_long host;
  52.     char *wordfile;
  53.     char *outputfile;
  54.     u_char guess;
  55.     int manysend;
  56.     u_long inter;
  57.   }
  58. opz;
  60. struct snmpchex sntab[255];
  61. char oldbanner[1024];
  62. char *guess[1024];
  63. int guess_i = 0;
  66. /** functions used make a list of password's from the hostname **/
  67. /** eg. www.toto.com will have toto,TOTO01,www.toto,toto.com etc. **/
  69. void
  70. addguess (char *str)
  71. {
  72.   guess[guess_i] = (char *) calloc (1, strlen (str) + 1);
  73.   strcpy (guess[guess_i], str);
  74.   guess_i++;
  75. }
  77. int
  78. guessname (char *namez)
  79. {
  80.   char *ptrhost[255];
  81.   char *begin;
  82.   char *end;
  83.   char *hostz;
  84.   char *h00st;
  85.   char tmp[255];
  86.   u_char nodot = 2;
  87.   int i;
  88.   int x;
  89.   int a = 0;
  91.   h00st = hostz = namez;
  92.   begin = h00st;
  93.   if (strchr (hostz, (int) '.') == NULL)
  94.     {
  95.       nodot = 1;
  96.       ptrhost[0] = strdup (namez);
  97.     }
  98.   else
  99.     while (1)
  100.       {
  101. end = NULL;
  102. end = (char *) strchr (hostz, (int) '.');
  103. if (end != NULL)
  104.   {
  105.     ptrhost[a] = (char *) calloc (1, 255);
  106.     for (i = 0; begin != end; begin = begin + 1)
  107.       if (*begin != '.')
  108. ptrhost[a][i++] = *begin;
  109.     a++;
  110.     hostz = begin + 1;
  111.   }
  112. else if (strlen (begin) > 0)
  113.   {
  114.     ptrhost[a] = (char *) calloc (1, 255);
  115.     strcpy (ptrhost[a], begin + 1);
  116.     break;
  117.   }
  118. else
  119.   break;
  121.       }
  123.   if (nodot == 2)
  124.     {
  126.       addguess (ptrhost[0]);
  127.       addguess (ptrhost[a - 1]);
  129.       memset (tmp, 0, sizeof (tmp));
  130.       sprintf (tmp, "%s.%s", ptrhost[a - 1], ptrhost[a]);
  131.       addguess (tmp);
  133.       memset (tmp, 0, sizeof (tmp));
  134.       sprintf (tmp, "%s.%s", ptrhost[0], ptrhost[1]);
  135.       addguess (tmp);
  137.       memset (tmp, 0, sizeof (tmp));
  138.       sprintf (tmp, "%s%s", ptrhost[0], ptrhost[1]);
  139.       addguess (tmp);
  141.       memset (tmp, 0, sizeof (tmp));
  142.       sprintf (tmp, "%s%s", ptrhost[a - 1], ptrhost[a]);
  143.       addguess (tmp);
  145.     }
  147.   for (i = 0; i < nodot; i++)
  148.     for (x = 95; x < 100; x++)
  149.       {
  150. memset (tmp, 0, sizeof (tmp));
  151. sprintf (tmp, "%s%i", ptrhost[i], x);
  152. addguess (tmp);
  153.       }
  155.   for (i = 0; i < nodot; i++)
  156.     for (x = 0; x < 11; x++)
  157.       {
  158. memset (tmp, 0, sizeof (tmp));
  159. sprintf (tmp, "%s%i", ptrhost[i], x);
  160. addguess (tmp);
  161.       }
  163.   for (i = 0; i < nodot; i++)
  164.     for (x = 0; x < 11; x++)
  165.       {
  166. memset (tmp, 0, sizeof (tmp));
  167. sprintf (tmp, "%s%02i", ptrhost[i], x);
  168. addguess (tmp);
  169.       }
  171.   a = guess_i;
  173.   for (x = 0; x != a; x++)
  174.     {
  175.       memset (tmp, 0, sizeof (tmp));
  176.       strcpy (tmp, guess[x]);
  178.       for (i = 0; i < strlen (tmp); i++)
  179. tmp[i] = (char) toupper ((int) tmp[i]);
  180.       addguess (tmp);
  181.     }
  182.   return (0);
  183. }
  185. /** resolve a hostname to an ip  **/
  187. unsigned long
  188. host2ip (char *serv)
  189. {
  190.   struct sockaddr_in sinn;
  191.   struct hostent *hent;
  193.   hent = gethostbyname (serv);
  194.   if (hent == NULL)
  195.     return 0;
  196.   bzero ((char *) &sinn, sizeof (sinn));
  197.   memcpy ((char *) &sinn.sin_addr, hent->h_addr, hent->h_length);
  198.   return sinn.sin_addr.s_addr;
  199. }
  201. /** look into the snmpd packet and get the return code the ID and the **/
  202. /** community name and return an offset to the end  return code of the paket **/
  203. /** in ASN.1 language 0x4 [sizeof the string] = string
  204.       0x2 [sizeof of the interger] = integer
  205. **/          
  206.           
  207. int
  208. getret (u_char * buf, int size, struct snmpchex *sn)
  209. {
  210.   int i;
  211.   for (i = 0; i < size; i++)
  212.     if (buf[i] == 'x04')
  213.       {
  214. /** Search the comunity name **/
  216. memset ((char *) &sn->name, 0, sizeof (sn->name));
  218. if (buf[i + 1] < (sizeof (sn->name) - 1))
  219.   memcpy ((char *) &sn->name, (char *) &buf[i + 2], buf[i + 1]);
  220. else
  221.   return (-1);
  223. i = i + (buf[i + 1] + 1);
  224. for (; i < size && i + 2 < size; i++)
  225.   if (buf[i] == 0xa2)
  226.     { 
  227.     /** ok we enter into the PDU **/
  228.       for (; i < size && i + 2 < size; i++)
  229. if (buf[i] == 'x02')
  230.   {
  231.    /** get the ID **/
  232.     sn->id = buf[i + 2];
  233.     for (i = i + (buf[i + 1] + 2); i < size && i + 2 < size; i++)
  234.       if (buf[i] == 'x02')
  235. if (buf[i + 1] == 'x01')
  236.   {
  237.     /** return code **/
  238.     sn->ret = buf[i + 2];
  240.     return (i + 2);
  241.   }
  242. else
  243.   return (-1);
  244.   }
  245.     }
  246.       }
  247.   return (-1);
  248. }
  250. /** here we make a GERREQ and SETREQ paket */
  251. /** read a good book about snmp protocol or rfc for the meaning :) */
  252. int
  253. getreq (u_char * buf, char *name, int longid, u_char id, int set_req)
  254. {
  255.   int i = 0;
  256.   buf[0] = 0x30;
  257.   buf[1] = 0x82;
  258.   buf[2] = 0x00;
  259.   buf[3] = 16 + longid + strlen (name);
  260.   /* printf ("buf[1]=%in", 19 + longid + strlen (name)); */
  261.   buf[4] = 0x02;
  262.   buf[5] = 0x01;
  263.   buf[6] = 0x00;
  264.   buf[7] = 0x04;            /* we copy the community name */
  265.   buf[8] = strlen (name); 
  267.   strcpy ((buf + 9), name);
  268.   i = 9 + strlen (name);
  269.   if (set_req == 0)
  270.     buf[i++] = 0xa0;     /* a0 = getreq a3 = setreq */
  271.   else              
  272.     buf[i++] = 0xa3;
  273. /** get req **/
  274. /* printf ("buf[%i]=%in", i, 12 + longid); */
  276.   buf[i++] = 9 + longid;
  277.   buf[i++] = 0x02;
  278.   buf[i++] = 0x1;
  279.   buf[i++] = (u_char) id;
  280.   buf[i++] = 0x02;
  281.   buf[i++] = 0x01;
  282.   buf[i++] = 0x00;
  283.   buf[i++] = 0x02;
  284.   buf[i++] = 0x01;
  285.   buf[i++] = 0x00;
  287.   return (20 + strlen (name));
  288. }
  292. /** make the paket snmp :> */
  294. int
  295. makepktsnmp (int sock, u_char * sysdec, int sizeofsysdec, char *buf, int sizeofbuf, char *namez, int id, struct sockaddr_in *sin, int set_req)
  296. {
  297.   int i;
  298.   int GETREQ_SYSDEC;
  299.   GETREQ_SYSDEC = sizeofsysdec - 1;
  300.   memset (buf, 0, sizeofbuf);
  301.   i = getreq (buf, namez, GETREQ_SYSDEC, id, set_req);
  302.   memcpy ((buf + i), sysdec, GETREQ_SYSDEC);
  303.   return (sendto (sock, buf, i + GETREQ_SYSDEC, 0, sin, sizeof (struct sockaddr_in)));
  304. }
  306. /** getreq paket **/
  308. int
  309. req_makepktsnmp (int sock, char *buf, int sizeofbuf, char *namez, int id, struct sockaddr_in *sin)
  310. {
  311.   /** system.sysName.0 :> **/
  312.   u_char sysdec[] = "x30x10x30x82x0x0cx06x08x2bx06x01x02x01x01x05x00x05x00";
  313.   return (makepktsnmp (sock, (u_char *) & sysdec, sizeof (sysdec), buf, sizeofbuf, namez, id, sin, 0));
  314. }
  318. /** setreq paket **/
  319. int
  320. set_makepktsnmp (int sock, char *buf, int sizeofbuf, char *name,
  321.  char *namez, int id, struct sockaddr_in *sin)
  322. {
  323.   int i;
  324.   u_char *save;
  325.   u_char sysdec[] = "x30x10x30x82x0x09x06x08x2bx06x01x02x01x01x05x00";
  327.   save = (u_char *) calloc (1, sizeof (sysdec) + strlen (namez) + 2);
  329.   i = sizeof (sysdec);
  331.   memcpy (save, (u_char *) & sysdec, i);
  333.   i--;
  335.   save[i++] = 'x04';
  336.   save[i++] = strlen (namez);
  338.   memcpy ((save + i), namez, strlen (namez));
  340.   i = strlen (namez) + 3;
  342.   save[1] = save[1] + strlen (namez);
  343.   save[5] = save[5] + i;
  344.   i--;
  346.   return (makepktsnmp (sock, save, sizeof (sysdec) + i, buf, sizeofbuf, name, id, sin, 1));
  347. }
  352. /** keep in memory good community name **/
  353. /** return -2 if we have an Writable access **/
  354. /** return 0 for any good community name **/
  355. /** return -1 for error or  any else     **/
  357. int
  358. snadd (struct snmpchex *sn, int taboff)
  359. {
  360.   int i;
  361.   if (sn->id > 127)
  362.     for (i = 0; i < 255; i++)
  363.       if (strcmp ((char *) &sntab[i].name, sn->name) == 0)
  364. {
  365.   sntab[i].rw = 2;
  366.   return (-2);
  367. }
  369.   for (i = 0; i < 255; i++)
  370.     if (sntab[i].id == sn->id)
  371.       {
  372. return (-1);
  373.       }
  374.     else if (strcmp ((char *) &sntab[i].name, sn->name) == 0)
  375.       return (-1);
  377.   strncpy ((char *) &sntab[taboff].name, (char *) &sn->name, 16);
  378.   sntab[taboff].id = sn->id;
  379.   sntab[taboff].ret = sn->ret;
  380.   return (0);
  381. }
  383. /** main function **/
  385. int 
  386. snmpcheck (u_long ip, FILE * f)
  387. {
  388.   struct snmpchex sn;
  389.   struct sockaddr_in sin;
  390.   int sock;
  391.   int i = 0, x;
  392.   u_char buf[255];
  393.   char namez[24];
  394.   
  396.   int the_id = 10;
  397.   int nd;
  398.   int sntab_off = 0;
  399.   int manysend = 0;
  400.   struct timeval tv2, tv3;
  402.   sin.sin_family = AF_INET;
  403.   sin.sin_port = htons (161);
  404.   sin.sin_addr.s_addr = ip;
  406.   sock = socket (AF_INET, SOCK_DGRAM, IPPROTO_UDP); /* gimme a socket */
  408.   fcntl (sock, F_SETFL, O_NONBLOCK);
  410.   the_id = 1;
  411.   memset ((u_char *) & buf, 0, sizeof (buf));
  412.   while (1)
  413.     {
  414.       if (the_id > 127)
  415. the_id = 0;
  417.       if (!feof (f)) /** get community name to test from the wordfile **/
  418. {
  419.   memset ((char *) &namez, 0, sizeof (namez));
  420.   fgets ((char *) &namez, sizeof (namez), f);
  421.   if (strlen (namez) > 0 && namez [0] != 'n')
  422.     {
  423.       namez[strlen (namez) - 1] = '';
  424.       the_id++;
  425.       printf ("33[0m33[01m33[31m>>>>>>>>>>> get req name=%s  id = %i >>>>>>>>>>>33[0mn", namez, the_id);
  427.       for (manysend = 0; manysend < opz.manysend; manysend++)
  428. {
  429.   if (the_id > 127)
  430.     the_id = 0;
  431.   else
  432.     the_id++;
  433.                                  /* send the request */   
  434.               if (req_makepktsnmp (sock, (char *) &buf, sizeof (buf), namez, the_id, &sin) < 0)
  435.     {
  436.       perror ("sendto");
  437.       exit (-1);
  438.     }
  440.   usleep (opz.uwait);
  441. }
  442.     }
  443. }
  445.       usleep (opz.inter);
  447.       memset ((u_char *) & buf, 0, sizeof (buf));
  448.       x = sizeof (sin);
  450.      if (feof(f)) 
  451.        {
  452.         /** time to wait before quit  this function  **/
  453.          gettimeofday (&tv3, NULL);
  454.          if ( (tv2.tv_sec + opz.utimeout) < tv3.tv_sec)
  455.            break;
  456.        }   
  457.      else  gettimeofday (&tv2, NULL);
  458.      
  460.       i = 0;
  461.       /** we get an answer !!!! */
  462.       
  463.       if ((i = recvfrom (sock, (char *) &buf, sizeof (buf), 0, &sin, &x)) > 0)
  464. {
  465.   nd = 0;
  466.  /** extract the ID the return code and the community name **/
  467.   nd = getret ((char *) &buf, i, &sn);
  468.   printf ("33[0m33[1m33[32m<<<<<<<<<<< recv snmpd paket id = %i name = %s ret =%i <<<<<<<<<<33[0mn", sn.id, sn.name, sn.ret);
  469.   if (nd > 0 && sn.ret == 0)
  470.     {
  472.               /** here we will save our first awnser and trying to see if the
  473.                   we can write with the community name  **/
  474.                    
  475.       for (; nd < i; nd++)
  476. if (buf[nd] == 0x04)
  477.   {
  478.     if (oldbanner[0] == '')
  479.       for (i = 0; i < buf[nd + 1]; i++)
  480. {
  481.   /** save the old system.sysName.0  **/
  482.   oldbanner[i] = buf[nd + 2 + i];
  483. }
  485.     memset ((u_char *) & buf, 0, sizeof (buf));
  486.     if (snadd (&sn, sntab_off++) == 0)
  487.       {
  488. printf ("33[0m33[01m33[33m>>>>>>>>>>>> send setrequest id = %i name = %s >>>>>>>> 33[0mn", sn.id, sn.name);
  489. for (manysend = 0; manysend < opz.manysend; manysend++)
  490.   {
  491. /** set  paket **/    
  492.     set_makepktsnmp (sock, (char *) &buf, sizeof (buf), (char *) &sn.name, "ADMsnmp", the_id + 127, &sin);
  493.     usleep (opz.uwait);
  494.   }
  495.       }
  496.   }
  497.     }
  498.   memset ((u_char *) & buf, 0, sizeof (buf));
  499.   i = 0;
  500. }
  502.     }
  504. /** we look if we have writable community access **/
  505. /** and we setup the old commnunity name (important ;)    **/
  507.   for (i = 0; i < 255; i++)
  508.     if (sntab[i].id != -666)
  509.       if (sntab[i].rw == 2)
  510. {
  511.   set_makepktsnmp (sock, (char *) &buf, sizeof (buf), (char *) &sntab[i].name, (char *) &oldbanner, the_id + 127, &sin);
  512.   sleep (1);
  513.   set_makepktsnmp (sock, (char *) &buf, sizeof (buf), (char *) &sntab[i].name, (char *) &oldbanner, the_id + 127, &sin);
  514.   sleep (1);
  515. }
  516. return (0);
  517. }
  519. /** give you the hostname from the ip **/
  521. char *
  522. ip2host (u_long ip)
  523. {
  524.   struct hostent *ht;
  525.   char *c;
  526.   c = calloc (1, 255);
  528.   ht = gethostbyaddr ((char *) &ip, sizeof (u_long), AF_INET);
  529.   if (ht == NULL)
  530.     return (NULL);
  531.   strncpy (c, ht->h_name, 254);
  532.   return (c);
  533. }
  535. void
  536. usage (char *name)
  537. {
  538.   printf ("ADMsnmp v %s (c) The ADM crewn", "0.1");
  539.   printf ("%s: <host> [-g,-wordf,-out <name>, [-waitf,-sleep, -manysend,-inter <#>] ] n", name);
  540.   printf ("<hostname>     : host to scan n"
  541.   "[-guessname]   : guess password with hostname n"
  542.   "[-wordfile]    : wordlist of password to tryn"
  543.   "[-outputfile] <name>: output filen"
  544.      "[-waitfor] <mili>  : time in milisecond in each send of snmprequestn"
  545.   "[-sleep]   <second> : time in second of the scan process lifen"
  546.   "[-manysend] <number>: how many paket to send by request n"
  547.      "[-inter] <mili>     : time to wait in milisecond after each request");
  548. }
  550. int
  551. main (int argc, char **argv)
  552. {
  553.   FILE *f;
  554.   FILE *fout;
  555.   int i;
  556.   char *c;
  557.   char *fname;
  559. /** clean all ;) **/
  560.   for (i = 0; i < 255; i++)
  561.     {
  562.       memset ((char *) &sntab[i].name, 0, 16);
  563.       sntab[i].id = -666;
  564.       sntab[i].rw = 0;
  565.       sntab[i].ret = -666;
  566.     }
  568.   if (argc < 2)
  569.     {
  570.       usage (argv[0]);
  571.       exit (-1);
  572.     }
  574. /** default setup **/
  576.   opz.utimeout = 10;
  577.   opz.uwait = 100000;
  578.   opz.host = host2ip (argv[1]);
  579.   if (opz.host == 0)
  580.     {
  581.       printf ("cant resolve hostname!n");
  582.       exit (-1);
  583.     }
  584.   opz.wordfile = strdup ("snmp.passwd");
  585.   opz.outputfile = NULL;
  586.   opz.guess = -1;
  587.   opz.manysend = 2;
  588.   opz.inter = 100000;
  591. /* eleet parser :) */
  593.   for (i = 0; i < argc; i++)
  594.     {
  595.       if (strncmp (argv[i], "-g", 2) == 0)
  596. opz.guess = 1;
  597.       if (strncmp (argv[i], "-wo", 3) == 0)
  598. opz.wordfile = strdup (argv[++i]);
  599.       if (strncmp (argv[i], "-out", 4) == 0)
  600. opz.outputfile = strdup (argv[++i]);
  601.       if (strncmp (argv[i], "-wai", 4) == 0)
  602. opz.uwait = 100 * atoi (argv[++i]);
  603.       if (strncmp (argv[i], "-sle", 4) == 0)
  604. opz.utimeout = atoi (argv[++i]);
  605.       if (strncmp (argv[i], "-man", 4) == 0)
  606. opz.manysend = atoi (argv[++i]);
  607.       if (strncmp (argv[i], "-int", 4) == 0)
  608. opz.inter = 100 * atoi (argv[++i]);
  611.     }
  612. /*
  613.  *  printf ("wordfile = %s sleep = %u waitfor = %u guess = %i outputfile = %s manysend = %in",
  614.  *  opz.wordfile, opz.utimeout, opz.uwait, opz.guess, opz.outputfile, opz.manysend);
  615.  */
  616.   
  618. /** if we have the guessname option we make a new wordfile from it result +
  619.  **    the wordfile  choosed  **/
  620.  
  621.   if (opz.guess == 1)
  622.     {
  623.       c = ip2host (opz.host);
  624.       if (c != NULL)
  625. {
  626.   guessname (c);
  627.   c = calloc (1, 255);
  628.   sprintf (c, "/tmp/.ADMsnmp.%i", getpid ());
  629.   fname = strdup (c);
  630.   f = fopen (c, "w+");
  631.   fout = fopen (opz.wordfile, "r");
  632.   if (fout == NULL)
  633.     {
  634.       printf ("cant open wordfile!n");
  635.       perror ("fopen");
  636.       exit (-1);
  637.     }
  638.   while (!feof (fout))
  639.     {
  640.       memset (c, 0, 255);
  641.       fgets (c, 255, fout);
  642.       fwrite (c, strlen (c), 1, f);
  643.     }
  644.   for (i = 0; i < guess_i; i++)
  645.     {
  646.       memset (c, 0, 255);
  647.       fwrite (guess[i], strlen (guess[i]), 1, f);
  648.       fwrite ("n", 1, 1, f);
  649.     }
  650.   fclose (fout);
  651.   rewind (f);
  652. }
  653.     }
  654.   if (opz.guess != 1)
  655.     {
  656.       f = fopen (opz.wordfile, "r");
  657.       if (f == NULL)
  658. {
  659.   printf ("cant open wordfile!n");
  660.   perror ("fopen");
  661.   exit (-1);
  662. }
  663.     }
  665. fout = NULL;
  666.   
  667.   if (opz.outputfile != NULL)
  668.     {
  669.       fout = fopen (opz.outputfile, "w");
  670.       if (fout == NULL)
  671. {
  672.   printf ("cant open outpufile!n");
  673.   exit (-1);
  674. }
  675.     }
  677.   memset ((char *) &oldbanner, 0, sizeof (oldbanner));
  679. /*** the true MAIN :) **/
  681.  printf ("ADMsnmp v%s (c) The ADM crewn",VERSION);
  682.  printf ("ftp://ADM.isp.at/ADM/ngreets: !ADM, el8.org, ansian");
  683.  
  684.  
  685.  snmpcheck (host2ip (argv[1]), f);
  686.  
  687.   if (fout != NULL) 
  688.       fprintf (fout,"nn<!ADM!>ttsnmp check on %stt<!ADM!>n",argv [1]);
  689.  
  690.   printf ("nn<!ADM!>ttsnmp check on %stt<!ADM!>n",argv[1]);
  692.   if (strlen (oldbanner) > 0) 
  693.    {
  694.     printf ("33[1msys.sysName.033[0m:%sn", oldbanner);
  695.     if (fout != NULL) 
  696.         fprintf (fout,"33[1msys.sysName.033[0m:%sn", oldbanner);
  697.    }
  698.    
  699.   for (i = 0; i < 255; i++)
  700.     {
  701.       if (sntab[i].id != -666)
  702. {
  703.   printf ("name = 33[1m33[31m%s33[0m", (char *) &sntab[i].name);
  704.   if (fout != NULL) 
  705.          fprintf (fout,"name = 33[1m33[31m%s33[0m", (char *) &sntab[i].name);
  706.   if (sntab[i].rw == 2)
  707.     {
  708.     printf (" 33[133[5mwrite33[0m accessn");
  709.     if (fout != NULL)fprintf (fout," 33[133[5mwrite33[0m accessn");
  710.     }
  711.   else 
  712.    {
  713.     printf (" readonly accessn");
  714.     if (fout != NULL)fprintf (fout," readonly accessn");
  715.    }
  716. }
  718.     }
  720.   if (opz.guess == 1)
  721.     unlink (fname);
  723. exit (0);
  724. /* bye :) */
  725. }