![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to kname_parse.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / kerberosIV / krb|
Return to kname_parse.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / kerberosIV / krb |
1.1 root 1: /*
2: * $Source: /usr/src/kerberosIV/krb/RCS/kname_parse.c,v $
3: * $Author: kfall $
4: *
5: * Copyright 1987, 1988 by the Massachusetts Institute of Technology.
6: *
7: * For copying and distribution information, please see the file
8: * <mit-copyright.h>.
9: */
10:
11: #ifndef lint
12: static char rcsid_kname_parse_c[] =
13: "$Header: /usr/src/kerberosIV/krb/RCS/kname_parse.c,v 4.5 90/06/25 20:56:35 kfall Exp $";
14: #endif /* lint */
15:
16: #include <mit-copyright.h>
17:
18: #include <stdio.h>
19: #include <des.h>
20: #include <krb.h>
21: #include <strings.h>
22:
23: /* max size of full name */
24: #define FULL_SZ (ANAME_SZ + INST_SZ + REALM_SZ)
25:
26: #define NAME 0 /* which field are we in? */
27: #define INST 1
28: #define REALM 2
29:
30: extern char *krb_err_txt[];
31:
32: /*
33: * This file contains four routines for handling Kerberos names.
34: *
35: * kname_parse() breaks a Kerberos name into its name, instance,
36: * and realm components.
37: *
38: * k_isname(), k_isinst(), and k_isrealm() check a given string to see if
39: * it's a syntactically legitimate respective part of a Kerberos name,
40: * returning 1 if it is, 0 if it isn't.
41: *
42: * Definition of "syntactically legitimate" names is according to
43: * the Project Athena Technical Plan Section E.2.1, page 7 "Specifying
44: * names", version dated 21 Dec 1987.
45: * /
46:
47: /*
48: * kname_parse() takes a Kerberos name "fullname" of the form:
49: *
50: * username[.instance][@realm]
51: *
52: * and returns the three components ("name", "instance", and "realm"
53: * in the example above) in the given arguments "np", "ip", and "rp".
54: *
55: * If successful, it returns KSUCCESS. If there was an error,
56: * KNAME_FMT is returned.
57: */
58:
59: kname_parse(np, ip, rp, fullname)
60: char *np, *ip, *rp, *fullname;
61: {
62: static char buf[FULL_SZ];
63: char *rnext, *wnext; /* next char to read, write */
64: register char c;
65: int backslash;
66: int field;
67:
68: backslash = 0;
69: rnext = buf;
70: wnext = np;
71: field = NAME;
72:
73: if (strlen(fullname) > FULL_SZ)
74: return KNAME_FMT;
75: (void) strcpy(buf, fullname);
76:
77: while (c = *rnext++) {
78: if (backslash) {
79: *wnext++ = c;
80: backslash = 0;
81: continue;
82: }
83: switch (c) {
84: case '\\':
85: backslash++;
86: break;
87: case '.':
88: switch (field) {
89: case NAME:
90: if (wnext == np)
91: return KNAME_FMT;
92: *wnext = '\0';
93: field = INST;
94: wnext = ip;
95: break;
96: case INST:
97: return KNAME_FMT;
98: /* break; */
99: case REALM:
100: *wnext++ = c;
101: break;
102: default:
103: fprintf(stderr, "unknown field value\n");
104: exit(1);
105: }
106: break;
107: case '@':
108: switch (field) {
109: case NAME:
110: if (wnext == np)
111: return KNAME_FMT;
112: *ip = '\0';
113: /* fall through */
114: case INST:
115: *wnext = '\0';
116: field = REALM;
117: wnext = rp;
118: break;
119: case REALM:
120: return KNAME_FMT;
121: default:
122: fprintf(stderr, "unknown field value\n");
123: exit(1);
124: }
125: break;
126: default:
127: *wnext++ = c;
128: }
129: }
130: *wnext = '\0';
131: if ((strlen(np) > ANAME_SZ - 1) ||
132: (strlen(ip) > INST_SZ - 1) ||
133: (strlen(rp) > REALM_SZ - 1))
134: return KNAME_FMT;
135: return KSUCCESS;
136: }
137:
138: /*
139: * k_isname() returns 1 if the given name is a syntactically legitimate
140: * Kerberos name; returns 0 if it's not.
141: */
142:
143: k_isname(s)
144: char *s;
145: {
146: register char c;
147: int backslash = 0;
148:
149: if (!*s)
150: return 0;
151: if (strlen(s) > ANAME_SZ - 1)
152: return 0;
153: while(c = *s++) {
154: if (backslash) {
155: backslash = 0;
156: continue;
157: }
158: switch(c) {
159: case '\\':
160: backslash = 1;
161: break;
162: case '.':
163: return 0;
164: /* break; */
165: case '@':
166: return 0;
167: /* break; */
168: }
169: }
170: return 1;
171: }
172:
173:
174: /*
175: * k_isinst() returns 1 if the given name is a syntactically legitimate
176: * Kerberos instance; returns 0 if it's not.
177: */
178:
179: k_isinst(s)
180: char *s;
181: {
182: register char c;
183: int backslash = 0;
184:
185: if (strlen(s) > INST_SZ - 1)
186: return 0;
187: while(c = *s++) {
188: if (backslash) {
189: backslash = 0;
190: continue;
191: }
192: switch(c) {
193: case '\\':
194: backslash = 1;
195: break;
196: case '.':
197: return 0;
198: /* break; */
199: case '@':
200: return 0;
201: /* break; */
202: }
203: }
204: return 1;
205: }
206:
207: /*
208: * k_isrealm() returns 1 if the given name is a syntactically legitimate
209: * Kerberos realm; returns 0 if it's not.
210: */
211:
212: k_isrealm(s)
213: char *s;
214: {
215: register char c;
216: int backslash = 0;
217:
218: if (!*s)
219: return 0;
220: if (strlen(s) > REALM_SZ - 1)
221: return 0;
222: while(c = *s++) {
223: if (backslash) {
224: backslash = 0;
225: continue;
226: }
227: switch(c) {
228: case '\\':
229: backslash = 1;
230: break;
231: case '@':
232: return 0;
233: /* break; */
234: }
235: }
236: return 1;
237: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.