Return to PasswordLookup_support.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / xns / examples / passwd

Annotation of 43BSD/contrib/xns/examples/passwd/PasswordLookup_support.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * Support routines for PasswordLookup.
                      3:  */
                      4: #include "PasswordLookup_defs.h"
                      5: 
                      6: static int
                      7: sizeof_Passwd(p)
                      8:        register Passwd *p;
                      9: {
                     10:        register int size = 6;
                     11: 
                     12:        size += sizeof_String(&p->pw_name);
                     13:        size += sizeof_String(&p->pw_passwd);
                     14:        size += sizeof_String(&p->pw_comment);
                     15:        size += sizeof_String(&p->pw_gecos);
                     16:        size += sizeof_String(&p->pw_dir);
                     17:        size += sizeof_String(&p->pw_shell);
                     18:        return (size);
                     19: }
                     20: 
                     21: static int
                     22: externalize_Passwd(p, buf)
                     23:        register Passwd *p;
                     24:        register Unspecified *buf;
                     25: {
                     26:        register Unspecified *bp;
                     27: 
                     28:        bp = buf;
                     29:        bp += externalize_String(&p->pw_name, bp);
                     30:        bp += externalize_String(&p->pw_passwd, bp);
                     31:        bp += externalize_LongCardinal(&p->pw_uid, bp);
                     32:        bp += externalize_LongCardinal(&p->pw_gid, bp);
                     33:        bp += externalize_LongCardinal(&p->pw_quota, bp);
                     34:        bp += externalize_String(&p->pw_comment, bp);
                     35:        bp += externalize_String(&p->pw_gecos, bp);
                     36:        bp += externalize_String(&p->pw_dir, bp);
                     37:        bp += externalize_String(&p->pw_shell, bp);
                     38:        return (bp - buf);
                     39: }
                     40: 
                     41: static int
                     42: sizeof_T_cn754_2(p)
                     43:        register T_cn754_2 *p;
                     44: {
                     45:        register int size = 0;
                     46: 
                     47:        size += sizeof_String(&p->errorstring);
                     48:        return (size);
                     49: }
                     50: 
                     51: static int
                     52: externalize_T_cn754_2(p, buf)
                     53:        register T_cn754_2 *p;
                     54:        register Unspecified *buf;
                     55: {
                     56:        register Unspecified *bp;
                     57: 
                     58:        bp = buf;
                     59:        bp += externalize_String(&p->errorstring, bp);
                     60:        return (bp - buf);
                     61: }
                     62: 
                     63: static int
                     64: sizeof_LookupUidResults(p)
                     65:        register LookupUidResults *p;
                     66: {
                     67:        register int size = 0;
                     68: 
                     69:        size += sizeof_Passwd(&p->passwd);
                     70:        return (size);
                     71: }
                     72: 
                     73: static int
                     74: externalize_LookupUidResults(p, buf)
                     75:        register LookupUidResults *p;
                     76:        register Unspecified *buf;
                     77: {
                     78:        register Unspecified *bp;
                     79: 
                     80:        bp = buf;
                     81:        bp += externalize_Passwd(&p->passwd, bp);
                     82:        return (bp - buf);
                     83: }
                     84: 
                     85: static int
                     86: sizeof_LookupUserResults(p)
                     87:        register LookupUserResults *p;
                     88: {
                     89:        register int size = 0;
                     90: 
                     91:        size += sizeof_Passwd(&p->passwd);
                     92:        return (size);
                     93: }
                     94: 
                     95: static int
                     96: externalize_LookupUserResults(p, buf)
                     97:        register LookupUserResults *p;
                     98:        register Unspecified *buf;
                     99: {
                    100:        register Unspecified *bp;
                    101: 
                    102:        bp = buf;
                    103:        bp += externalize_Passwd(&p->passwd, bp);
                    104:        return (bp - buf);
                    105: }
                    106: 
                    107: static int
                    108: internalize_Passwd(p, buf)
                    109:        register Passwd *p;
                    110:        register Unspecified *buf;
                    111: {
                    112:        register Unspecified *bp;
                    113: 
                    114:        bp = buf;
                    115:        bp += internalize_String(&p->pw_name, bp);
                    116:        bp += internalize_String(&p->pw_passwd, bp);
                    117:        bp += internalize_LongCardinal(&p->pw_uid, bp);
                    118:        bp += internalize_LongCardinal(&p->pw_gid, bp);
                    119:        bp += internalize_LongCardinal(&p->pw_quota, bp);
                    120:        bp += internalize_String(&p->pw_comment, bp);
                    121:        bp += internalize_String(&p->pw_gecos, bp);
                    122:        bp += internalize_String(&p->pw_dir, bp);
                    123:        bp += internalize_String(&p->pw_shell, bp);
                    124:        return (bp - buf);
                    125: }
                    126: 
                    127: static int
                    128: internalize_T_cn754_2(p, buf)
                    129:        register T_cn754_2 *p;
                    130:        register Unspecified *buf;
                    131: {
                    132:        register Unspecified *bp;
                    133: 
                    134:        bp = buf;
                    135:        bp += internalize_String(&p->errorstring, bp);
                    136:        return (bp - buf);
                    137: }
                    138: 
                    139: static int
                    140: internalize_LookupUidResults(p, buf)
                    141:        register LookupUidResults *p;
                    142:        register Unspecified *buf;
                    143: {
                    144:        register Unspecified *bp;
                    145: 
                    146:        bp = buf;
                    147:        bp += internalize_Passwd(&p->passwd, bp);
                    148:        return (bp - buf);
                    149: }
                    150: 
                    151: static int
                    152: internalize_LookupUserResults(p, buf)
                    153:        register LookupUserResults *p;
                    154:        register Unspecified *buf;
                    155: {
                    156:        register Unspecified *bp;
                    157: 
                    158:        bp = buf;
                    159:        bp += internalize_Passwd(&p->passwd, bp);
                    160:        return (bp - buf);
                    161: }

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