Return to dcputil.c CVS log

Up to [MW Coherent from dump] / coherent / a / usr / bob / uusrc / dcp

Annotation of coherent/a/usr/bob/uusrc/dcp/dcputil.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * dcputil.c 
                      3:  *
                      4:  * miscellaneous utility functions
                      5:  */
                      6: 
                      7: #include <ctype.h>
                      8: #include <pwd.h>
                      9: #include "dcp.h"
                     10: #include "perm.h"
                     11: 
                     12: /*
                     13:  * |myname()| returns a pointer to the local host's UUCP nodename.
                     14:  *
                     15:  * If there is a MYNAME entry in the PERMS, then return this entry
                     16:  * instead of the name in the NODENAME file.
                     17:  */
                     18: 
                     19: char *
                     20: myname()
                     21: {
                     22:        register char *tmp;
                     23: 
                     24:        if ( (tmp=perm_value(myname_e)) != NULL )
                     25:                return( tmp );
                     26:        else
                     27:                return( uucpname() );
                     28: }
                     29: 
                     30: /*
                     31:  *  char *visib(str)  char *str;
                     32:  *  char *visbuf(data, len)  char *data;  int len;
                     33:  *
                     34:  *  Print the string or buffer of data in "visible" format.  Printable
                     35:  *  characters are printed as themselves, special control characters
                     36:  *  (CR, LF, BS, HT) are printed in the usual escape format, and others
                     37:  *  are printed using 3-digit octal escapes.  Returns a pointer to a
                     38:  *  static buffer containing the visible data.
                     39:  */
                     40: 
                     41: char *
                     42: visib(str)
                     43: unsigned char *str;
                     44: {
                     45:        return( visbuf(str, strlen(str)) );
                     46: }
                     47: 
                     48: char *
                     49: visbuf(data, len)
                     50: unsigned char *data; 
                     51: int len;
                     52: {
                     53:        static char buf[BUFSIZ];
                     54:        register unsigned char c;
                     55:        register char *p;
                     56: 
                     57: 
                     58:        if ( len <= 0 )
                     59:                return("");
                     60:        p = buf;
                     61:        while( (p<&buf[BUFSIZ-4]) && (len--) ) {
                     62:                c = *data++;
                     63:                if ( (c!='\\') && isascii(c) && (isprint(c) || (c==' ')) ) {
                     64:                        *p++ = c;
                     65:                        continue;
                     66:                }
                     67:                *p++ = '\\';
                     68:                switch ( c ) {
                     69:                case '\\':  *p++ = '\\'; break;
                     70:                case '\n':  *p++ = 'n';  break;
                     71:                case '\t':  *p++ = 't';  break;
                     72:                case '\b':  *p++ = 'b';  break;
                     73:                case '\r':  *p++ = 'r';  break;
                     74:                case '\f':  *p++ = 'f';  break;
                     75:                case '\0':  *p++ = '0';  break;
                     76:                default:
                     77:                        sprintf(p, "%03o", c);
                     78:                        p += 3;
                     79:                }
                     80:        }
                     81:        *p = '\0';
                     82:        return( buf );
                     83: }
                     84: 
                     85: /*
                     86:  * |expandtilde(filename)| expands |filename| using the usual "~" convention.
                     87:  * That is, "~user" expands to the home directory of "user". "~" by itself
                     88:  * expands to the home directory of the effective userid, which in this
                     89:  * case is usually the /usr/spool/uucppublic directory. Care is taken not
                     90:  * to overflow the (static) name buffer.
                     91:  */
                     92: char *expandtilde(filename)
                     93: char *filename;
                     94: {
                     95:        struct passwd *pw, *getpwnam(), *getpwuid();
                     96:        static char namebuf[PATHLEN];
                     97:        int goodname = 1;
                     98:        char *p;
                     99:        char logline[60];
                    100: 
                    101:        if ('~' != *filename) {
                    102:                strcpy(namebuf, filename);
                    103:        } else {
                    104:                ++filename;
                    105:                p = namebuf;
                    106:                while(*filename && '/' != *filename && (p - namebuf) < PATHLEN)
                    107:                        *p++ = *filename++;
                    108:                *p = '\0';
                    109:                if (strlen(namebuf) == 0)
                    110:                        pw = getpwuid(geteuid());
                    111:                else
                    112:                        pw = getpwnam(namebuf);
                    113:                if (NULL == pw) {
                    114:                        goodname = 0;
                    115:                } else if (strlen(pw->pw_dir)+strlen(filename)+1 > PATHLEN) {
                    116:                        goodname = 0;
                    117:                } else {
                    118:                        strcpy(namebuf, pw->pw_dir);
                    119:                        strcat(namebuf, filename);
                    120:                }
                    121:        }
                    122:        if (goodname) {
                    123:                sprintf(logline, "tilde->%s", namebuf);
                    124:                plog(M_TRANSFER, logline);
                    125:                return namebuf;
                    126:        } else {
                    127:                plog(M_TRANSFER, "tilde->NULL");
                    128:                return NULL;
                    129:        }
                    130: }
                    131: 

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