![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to registerhost.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / new / xns / examples / ch|
Return to registerhost.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / xns / examples / ch |
1.1 root 1: /* $Header: registerhost.c,v 2.5 87/04/01 11:48:11 jqj Exp $ */
2:
3: /*
4: * This program enters a Unix host into the Clearinghouse as a server and
5: * workstation, hence eligible for gap telnet
6: */
7: /*
8: * $Log: registerhost.c,v $
9: * Revision 2.5 87/04/01 11:48:11 jqj
10: * merged Webster changes: added -f switch for registering as file service
11: *
12: * Revision 2.4 87/02/19 13:29:59 jqj
13: * If hostname() returns a fully qualified Internet domain name, use only
14: * the leaf (first) componenent.
15: *
16: * Revision 2.3 86/12/15 11:27:06 jqj
17: * rework address code to permit multihomed hosts.
18: *
19: * Revision 2.2 86/05/07 14:05:27 jqj
20: * eliminated use of ns_netof, since it has alignment problems on Gould
21: *
22: * Revision 2.1 85/12/17 10:25:34 jqj
23: * from Sklower: default to our address as set by ifconfig
24: *
25: * Revision 2.0 85/11/21 07:22:36 jqj
26: * 4.3BSD standard release
27: *
28: * Revision 1.1 85/11/20 13:54:08 jqj
29: * Initial revision
30: *
31: */
32:
33: #include <stdio.h>
34: #include <sys/types.h>
35: #include <netns/ns.h>
36: #include "Clearinghouse2_defs.h"
37: #include <xnscourier/CHEntries.h>
38: #include <xnscourier/CH.h>
39: #include <xnscourier/except.h>
40:
41:
42:
43: char *
44: ItemToString(item)
45: Item item;
46: {
47: char *strval;
48:
49: Unspecified buf[501], *bp;
50: Cardinal len;
51:
52: externalize_Item(&item, buf);
53: bp = buf;
54: bp += internalize_Cardinal(&len, bp);
55: bp += internalize_String(&strval, bp);
56: return(strval);
57: }
58:
59: Item
60: StringToItem(strval)
61: String strval;
62: {
63: Unspecified buf[501], *bp;
64: Item item;
65: Cardinal len;
66:
67: bp = buf + sizeof_Cardinal(len);
68: len = externalize_String(&strval, bp);
69: (void) externalize_Cardinal(&len, buf);
70: internalize_Item(&item, buf);
71: return(item);
72: }
73:
74: int
75: isprop(prop, proplist)
76: Property prop;
77: Properties proplist;
78: {
79: int i;
80:
81: prop = prop<<16; /* correct for bug in Clearinghouse v 2 */
82: for (i=0; i < proplist.length; i++) {
83: if (proplist.sequence[i] == prop) return(1);
84: }
85: return(0); /* not found */
86: }
87:
88: char *
89: XNSaddrToString(addr)
90: struct ns_addr *addr;
91: {
92: u_char *s;
93: static char buf[21];
94: union {
95: u_short y_net[2];
96: u_long y_long;
97: } netvalue;
98:
99: s = addr->x_host.c_host;
100: netvalue.y_net[0] = addr->x_net.s_net[0];
101: netvalue.y_net[1] = addr->x_net.s_net[1];
102: sprintf(buf,"%lx#%x.%x.%x.%x.%x.%x#%x",
103: ntohl(netvalue.y_long),
104: s[0], s[1], s[2], s[3], s[4], s[5],
105: ntohs(addr->x_port));
106: return(buf);
107: }
108:
109:
110: addNAelem(nalistp, addr)
111: NetworkAddressList *nalistp;
112: struct ns_addr *addr;
113: {
114: register NetworkAddress *naddrp;
115:
116: naddrp = nalistp->sequence + nalistp->length;
117: nalistp->length++;
118: naddrp->network[0] = htons(addr->x_net.s_net[0]);
119: naddrp->network[1] = htons(addr->x_net.s_net[1]);
120: naddrp->host[0] = htons(addr->x_host.s_host[0]);
121: naddrp->host[1] = htons(addr->x_host.s_host[1]);
122: naddrp->host[2] = htons(addr->x_host.s_host[2]);
123: }
124:
125: Item
126: getaddresslist(myaddr)
127: struct ns_addr *myaddr;
128: {
129: char addrstr[200];
130: struct ns_addr addr;
131: extern struct ns_addr ns_addr();
132: NetworkAddressList nalist;
133: Unspecified buf[501], *bp;
134: Item item;
135: Cardinal len;
136: NetworkAddress naddrs[10];
137:
138: nalist.length = 0;
139: nalist.sequence = naddrs;
140: printf("NS address (e.g. 2-273#2-613-688-939-672, - for default, CR to end):\nPrimary NS address: ");
141:
142: /* get list of addresses */
143: gets(addrstr);
144: while (*addrstr != 0) {
145: if (*addrstr=='-') {
146: addNAelem(&nalist, myaddr);
147: } else {
148: addr = ns_addr(addrstr);
149: addNAelem(&nalist, &addr);
150: }
151: printf("Additional NS address (CR for none): ");
152: gets(addrstr);
153: }
154:
155: /* canonicalize socket #s */
156: for (len = 0; len < nalist.length; len++)
157: nalist.sequence[len].socket = 0;
158:
159: /* encode */
160: bp = buf + sizeof_Cardinal(len);
161: len = externalize_NetworkAddressList(&nalist, bp);
162: (void) externalize_Cardinal(&len, buf);
163: internalize_Item(&item, buf);
164: return(item);
165: }
166:
167: main(argc, argv)
168: int argc;
169: char *argv[];
170: {
171: ObjectName myname, name, defname, fsname;
172: struct ns_addr *destaddr, *getXNSaddr(), *myaddr;
173: struct sockaddr_ns sns;
174: Authenticator agent;
175: CourierConnection *conn;
176: int i;
177: ListPropertiesResults LPresult;
178: RetrieveItemResults RIresult;
179: ChangeItemResults CIresult;
180: AddItemPropertyResults AIPresult;
181: char *pwd, *propval, *getXNSpass(), *malloc(), *gets(),
182: mystrname[200], *myhostname;
183: String ItemToString();
184: Item item, StringToItem(), addrToItem();
185: Property propnum;
186: struct ns_addr *addr;
187: static Boolean authseq[2] = {1, 0}; /* simple, not strong */
188: Boolean fileservice= 0;
189: int opt;
190: extern int optind;
191: extern char *optarg;
192:
193: if (argc < 1 || argc > 5) {
194: fprintf(stderr,"Usage: %s [-f] [hostname]\n",argv[0]);
195: exit(1);
196: }
197: while ( (opt= getopt(argc, argv, "f")) != EOF )
198: switch (opt) {
199: case 'f' :
200: fileservice++;
201: break;
202:
203: default :
204: fprintf(stderr, "Invalid command option -%c\n", opt);
205: exit(1);
206: }
207: CH_NameDefault(&defname);
208: if (argc == optind) {
209: char *tmp; extern char *index();
210: gethostname(myhostname=malloc(100), 100);
211: if ((tmp = index(myhostname,'.')) != NULL)
212: *tmp = '\0';
213: name = CH_StringToName(myhostname, &defname);
214: } else
215: name = CH_StringToName(argv[optind], &defname);
216: printf("Registering host %s\n",
217: CH_NameToString(name) );
218: printf("XNS UserName: ");
219: gets(mystrname);
220: myname = CH_StringToName(mystrname, &name);
221: pwd = getXNSpass("Password:");
222: MakeSimpleCredsAndVerifier(&myname,pwd,
223: &agent.credentials, &agent.verifier);
224: conn = CH_GetFirstCH();
225: i = sizeof(sns); myaddr = &sns.sns_addr;
226: getsockname(*(int *)conn, &sns, &i); myaddr->x_port = 0;
227: DURING {
228: LPresult = ListProperties(conn,NULL,name,agent);
229: } HANDLER {
230: if (Exception.Code == ArgumentError) {
231: DURING CreateObject(conn,NULL,name,agent);
232: HANDLER {
233: fprintf(stderr,"Can't create object. Error %d\n",
234: Exception.Code);
235: exit(1);
236: } END_HANDLER;
237: LPresult.properties.length = 0;
238: }
239: else {
240: fprintf(stderr,"ListProperties failed. Error %d\n",
241: Exception.Code);
242: exit(1);
243: }
244: } END_HANDLER;
245: /* AddressList property */
246: if (isprop(4,LPresult.properties)) {
247: addr = CH_LookupAddr(name,4);
248: if (addr==0) {
249: fprintf(stderr,"NetworkAddress is in property list, but CH_LookupAddr failed\n");
250: exit(1);
251: }
252: printf("Old address: %s\n",XNSaddrToString(addr));
253: myaddr->x_port = 0;
254: item = getaddresslist(myaddr);
255: DURING CIresult = ChangeItem(conn,NULL, name,4,item,agent);
256: HANDLER {
257: fprintf(stderr,"Can't change address. Error %d\n",
258: Exception.Code);
259: exit(1);
260: } END_HANDLER;
261: } else {
262: item = getaddresslist(myaddr);
263: DURING
264: AIPresult = AddItemProperty(conn,NULL,name,4,item,agent);
265: HANDLER {
266: fprintf(stderr,"Can't add address property. Error %d\n",
267: Exception.Code);
268: exit(1);
269: } END_HANDLER;
270: }
271: /* AuthenticationLevel property */
272: if (!isprop(8,LPresult.properties)) {
273: item.length = 2;
274: item.sequence = (Unspecified *) authseq;
275: DURING
276: AIPresult = AddItemProperty(conn,NULL,name,8,item,agent);
277: HANDLER {
278: fprintf(stderr,"Can't add AuthenticationLevel property.\n");
279: exit(1);
280: } END_HANDLER;
281: }
282: /* description */
283: DURING {
284: propnum = 10005; /* 10005<<16; */
285: if (isprop(propnum,LPresult.properties)) {
286: RIresult = RetrieveItem(conn, NULL,
287: name,
288: propnum, agent);
289: propval = ItemToString(RIresult.value);
290: printf("Workstation description (Property 10005) has value ``%s''\n",
291: propval );
292: clear_RetrieveItemResults(&RIresult);
293: }
294: propnum = 10024; /* 10024<<16; */
295: if (isprop(propnum,LPresult.properties)) {
296: RIresult = RetrieveItem(conn, NULL,
297: name,
298: propnum, agent);
299: propval = ItemToString(RIresult.value);
300: printf("Server description (Property 10024) has value ``%s''\nNew value: ",
301: propval );
302: propval = gets(malloc(100));
303: item = StringToItem(propval);
304: CIresult = ChangeItem(conn, NULL,
305: name,
306: propnum, item, agent);
307: clear_RetrieveItemResults(&RIresult);
308: } else {
309: printf("Enter new description: ");
310: propval = gets(malloc(100));
311: item = StringToItem(propval);
312: AIPresult = AddItemProperty(conn, NULL,
313: name,
314: propnum, item, agent);
315: }
316: if ( fileservice ) {
317: propnum= 10000; /* 10000<<16 */
318: if (isprop(10000,LPresult.properties)) {
319: RIresult = RetrieveItem(conn, NULL,
320: name,
321: propnum, agent);
322: propval = ItemToString(RIresult.value);
323: printf("FileService description (Property 10000) has value ``%s''\nNew value: ",
324: propval );
325: propval = gets(malloc(100));
326: item = StringToItem(propval);
327: CIresult = ChangeItem(conn, NULL,
328: name,
329: propnum, item, agent);
330: } else {
331: printf("Enter new FileService description: ");
332: propval = gets(malloc(100));
333: item = StringToItem(propval);
334: AIPresult = AddItemProperty(conn, NULL,
335: name,
336: propnum, item, agent);
337: }
338: }
339: } HANDLER {
340: fprintf(stderr,
341: "Error during Property manipulations, %d (%d)\n",
342: Exception.Code,
343: CourierErrArgs(Clearinghouse2_CallErrorArgs,problem) );
344: } END_HANDLER;
345: }
346:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.