Return to hosts.c CVS log

Up to [MW Coherent from dump] / coherent / d / bin / uucheck / checkperms

Annotation of coherent/d/bin/uucheck/checkperms/hosts.c, revision 1.1.1.1

1.1       root        1: /* hosts.c - handles lists of uucp hosts.
                      2:  * part of uucheck
                      3:  */
                      4: 
                      5: #include <stdio.h>
                      6: #include "checkperms.h"
                      7: 
                      8: struct hostname_struct {
                      9:        char    *hostname;
                     10:        struct hostname_struct  *next_hostname;
                     11: };
                     12: 
                     13: typedef struct hostname_struct hostname_type;
                     14: 
                     15: static hostname_type *first_hostname = (hostname_type *) NULL;
                     16: 
                     17: char *
                     18: first_host(command)
                     19:        char *command;
                     20: {
                     21:        FILE *fp;
                     22:        hostname_type *current_hostname; /* Linked list walker.  */
                     23: 
                     24:        /* Here is where we open Permissions and L.sys and extract a list
                     25:          * of all the hosts we might talk to.  This list will be walked
                     26:         * through by "next_host()".
                     27:         */
                     28: 
                     29:        if ((fp = popen(command, "r")) == NULL) {
                     30:                FATAL("Can not create list of host names.\n", NULL);
                     31:        } /* if can not open pipe to uuname */
                     32:        
                     33:        /* Read all the output of uuname into out linked list.  */
                     34: 
                     35:        if (fgets(bigbuf, MAX_NAME + 1, fp) != NULL) {
                     36:            bigbuf[strlen(bigbuf) - 1 ] = (char) NULL; /* Wipe out trailing nl.  */
                     37:            /* Make space for the first entry.  */
                     38:            first_hostname = (hostname_type *) malloc(sizeof(hostname_type));
                     39:            /* Move up to the new entry.  */
                     40:            current_hostname = first_hostname;
                     41:            /* Copy the first hostname into the list.  */
                     42:            copy_str(&current_hostname->hostname, bigbuf);
                     43:            current_hostname->next_hostname = (hostname_type *) NULL;
                     44:        } /* if (fgets(bigbuf, MAX_NAME + 1, fp) != NULL) */
                     45:        
                     46:        while (fgets(bigbuf, MAX_NAME + 1, fp) != NULL) {
                     47:            bigbuf[strlen(bigbuf) - 1] = (char) NULL; /* Wipe out trailing nl.  */
                     48:            /* Make space for the next entry.  */
                     49:            current_hostname->next_hostname =
                     50:                (hostname_type *) malloc(sizeof(hostname_type));
                     51:            /* Move up to the new entry.  */
                     52:            current_hostname = current_hostname->next_hostname;
                     53:            /* Copy the next hostname into the list.  */
                     54:            copy_str(&current_hostname->hostname, bigbuf);
                     55:            current_hostname->next_hostname = (hostname_type *) NULL;
                     56:        } /* while (fgets(bigbuf, MAX_NAME + 1, fp) != NULL) */
                     57: 
                     58:        /* Is this list only one entry long?  */
                     59:        if (first_hostname->next_hostname != NULL ) {
                     60:                last_host = FALSE;
                     61:        } else {
                     62:                last_host = TRUE;
                     63:        }
                     64:        return(first_hostname->hostname);
                     65: } /* first_host() */
                     66: 
                     67: /* Destructively return the next host to be processed.  */
                     68: char *
                     69: next_host()
                     70: {
                     71:        hostname_type *tmp;
                     72: 
                     73:        if ( first_hostname != NULL ) {
                     74:                free(first_hostname->hostname); /* Throw away the last name.  */
                     75:                tmp=first_hostname;
                     76:                first_hostname = first_hostname->next_hostname;
                     77:                free(tmp); /* Throw away the structure it was stored in.  */
                     78:                if (first_hostname->next_hostname == (hostname_type *) NULL) {
                     79:                        last_host = TRUE; /* About to return the last host in the list.  */     
                     80:                } /* if this is the last host  */
                     81:                return(first_hostname->hostname);
                     82:        } else {
                     83:                return(NULL);
                     84:        } /* if fist_hostname != NULL (no hosts left) */
                     85:        FATAL("Unreachable statement in next_host() reached.\n", NULL);
                     86: } /* next_host() */

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.