![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to udemon2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / udemon|
Return to udemon2.c CVS log | Up to [Research Unix] / researchv10no / cmd / udemon |
1.1 root 1: #
2:
3: #include <stdio.h>
4: #include "udemon.h"
5:
6: char argspec[OPNUM][3] /* required arg types (reverse order) */
7: { /* negative entry = any non-name type */
8: 0, 0, 0, /*OK*/
9: -1, NTYPE, 0, /*DEFINE*/
10: -1, NTYPE, 0, /*REDEFINE*/
11: NTYPE, 0, 0, /*DELETE*/
12: 0, 0, 0, /*spare*/
13: 0, 0, 0, /*EOM*/
14: 0, 0, 0, /*unu gd*/
15: 0, 0, 0, /*XMT*/
16: 0, 0, 0, /*spare*/
17: 0, 0, 0, /*POP*/
18: DTYPE, 0, 0, /*CDIR*/
19: IITYPE, IITYPE, FTYPE, /*CMODE*/
20: XTYPE, FTYPE, 0, /*OPEN*/
21: RTYPE, 0, 0, /*CLOSE*/
22: IITYPE, RTYPE, 0, /*SEEK*/
23: XTYPE, RTYPE, 0, /*READ*/
24: XTYPE, RTYPE, 0, /*WRITE*/
25: XTYPE, RTYPE, 0, /*TRUNCATE*/
26: NTYPE, 0, 0, /*LOGIN*/
27: 0, 0, 0, /*QUIT*/
28: DTYPE, 0, 0, /*LIST*/
29: -1, 0, 0, /*STATUS*/
30: 0, 0, 0, /*TIME*/
31: NTYPE, XTYPE, 0, /*UNIQUE*/
32: RTYPE, 0, 0, /*APPEND*/
33: 0, 0, 0, /*spare*/
34: WTYPE, -1, 0, /*ASSIGN*/
35: NTYPE, XTYPE, 0, /*FCREATE*/
36: NTYPE, 0, 0, /*IF*/
37: 0, 0, 0, /*FI*/
38: IITYPE, 0, 0, /*SKIP*/
39: NTYPE, XTYPE, 0, /*DCREATE*/
40: 0, 0, 0, /*spare*/
41: NTYPE, 0, 0 /*UNLESS*/
42: };
43:
44: char nodef[MAXTYPE] { /*non-zero if type can be used in definition*/
45: 0, 0, 0, 0, 0, 0, 0, 0,
46: 1, 1, 1, 0, 0, 0, 0, 0};
47:
48:
49:
50: deref(xsp)
51: struct sentry *xsp;
52: {
53: register i, r;
54: switch (xsp->s_type){
55: case NTYPE:
56: if (dstat(ncopy(xsp),&entry) < 0)
57: error(EUNDEF,2);
58: xsp->s_type = dcheck(xsp);
59: prt("deref ret %o\n",xsp->s_type);
60: break;
61: case WTYPE:
62: i = xsp->s_val1;
63: if ((i < 0) || (i >= VARNO))
64: error(EWADDR,2);
65: xsp->s_type = wstore[i].s_type;
66: xsp->s_val = wstore[i].s_val;
67: xsp->s_val1 = wstore[i].s_val1;
68: break;
69: case NULL:
70: error(EARGT,6);
71: }
72: }
73:
74:
75: argpush(xsp)
76: struct sentry **xsp;
77: {
78: register struct sentry *pp, *ss;
79:
80: ss = sp++;
81: pp = sp;
82: while (ss != *xsp){
83: pp->s_type = ss->s_type;
84: pp->s_val = ss->s_val;
85: (pp--)->s_val1 = (ss--)->s_val1;
86: }
87: *xsp = pp;
88: }
89:
90:
91:
92: respond(t)
93: char t;
94: {
95: if (t) *rp++ = t;
96: if (send(resp,rp-resp,3))
97: return(1);
98: rp = resp;
99: return(0);
100: }
101:
102:
103:
104: addup(b,n)
105: int n;
106: char *b;
107: {
108: register k,s;
109: register char *p;
110:
111: s=0;
112: p = b;
113: if (n>0){
114: for (k=0; k<n; k++)
115: s =+ p[k];
116: }
117: return(s);
118: }
119:
120:
121: send(p,n,c)
122: char *p;
123: int n,c;
124: {
125: extern timeout();
126: register r;
127:
128: if (c==3) {
129: prt("send ");
130: tprint(p,n);
131: }else
132: prt("send data %d,%d\n",n,c);
133: signal(14,timeout);
134: alarm(30);
135: snstat(fn,&c,0);
136: r = write(fn,p,n);
137: alarm(0);
138: if (r < 0 || panic)
139: return(1);
140: return(0);
141: }
142:
143:
144: timeout()
145: {
146: prt("timeout\n");
147: panic = 1;
148: }
149:
150:
151: recv(b,c)
152: int *c;
153: char *b;
154: {
155: register n;
156: register i;
157: if ((n = read(fn,b,512)) < 0)
158: return(-1);
159: snstat(fn,c,1);
160: if (*c==3) {
161: prt("received ");
162: tprint(b,n);
163: }else
164: prt("received data %d,%d\n",n,*c);
165: if (trace){
166: /*
167: for (i=0; i<n; i++){
168: printf("%3.1o ",b[i]&0377);
169: if ((i&7) == 7 || i == (n-1))
170: printf("\n");
171: }
172: */
173: }
174: return(n);
175: }
176:
177:
178:
179: closeall(){
180: register i;
181:
182: for (i=0; i<OPENS; i++)
183: if (openf[i]) {
184: close(i);
185: openf[i] = 0;
186: }
187: for (i=0; i<VARNO; i++)
188: wstore[i].s_type = 0;
189: }
190:
191:
192: logout()
193: {
194: register g,t;
195: static struct utmp z;
196: long l;
197:
198: login = 0;
199: utmp.u_name[0] = 0;
200: #ifdef ACCT
201: if ((g = open("/tmp/utmp",1)) >= 0){
202: t = utmp.u_tty;
203: if(t >= 'a')
204: t =- 'a' - (10+'0');
205: if((t >= 'A')&&(t<= 'Z'))
206: t = 10 + 'z' - 'a' + 1 + '0' + (t - 'A');
207: l = (t-'0')*16;
208: seek(g, l, 0);
209: if(write(g,&utmp,16)<0){
210: prt("write in utmp failed\n");
211: }
212: close(g);
213: }
214: if((g = open("/usr/adm/wtmp",1)) >= 0){
215: z.u_tty = utmp.u_tty;
216: time(&z.u_time[0]);
217: seek(g,0L,2);
218: write(g,&z,16);
219: close(g);
220: }
221: #endif
222: }
223:
224:
225: /*
226: * data from (fil) , block size (cp).
227: * k = 0 if (cp) not set, = 1 normal, = 2 if directory entry
228: */
229:
230: rcopy(fil,k,cp)
231: {
232: register n, code;
233: long tell();
234: register char *bp;
235:
236: if (respond(READ)) return(1);
237: length = 0;
238: sum = 0;
239: for (;;){
240: n = ((k>0)&&(cp<msiz)) ? cp : msiz;
241: if(trace)
242: printf("com %d %d %d %d\n",n,k,cp,msiz);
243: if(trace)
244: printf("posit %d %O\n",fil,tell(fil));
245: n = read(fil,buf,n);
246: if(trace)
247: printf("read %o %o %o\n",fil,buf,n);
248: if(trace&&((n == 0) || (n<0))){
249: perror("read");
250: printf("n = %d %d %d\n",fil,n,k);
251: }
252: if (n < 0)
253: error(0,6);
254: if (k == 2){
255: if (n != cp) {
256: n=0;
257: code = 4;
258: }else
259: if (buf[0] == 0)
260: continue;
261: else{
262: code = 1;
263: }
264: }else
265: if (k>0){
266: cp =- n;
267: code = (cp==0) ? 2 : ((n==msiz) ? 1 : 4);
268: }else
269: if (k<0) code = (n==0) ? 4 : 1;
270: else
271: code = (n==msiz) ? 1 : 4;
272: length =+ n;
273: sum =+ addup(buf,n);
274: prt("part sum %o %o\n",sum , n);
275: if (send(buf,n,code))
276: return(1);
277: if (code > 1)
278: break;
279: }
280: bp = buf;
281: *bp++ = 'K';
282: *bp++ = (sum >> 8); *bp++ = (sum &0377);
283: *bp++ = (length >> 8); *bp++ = (length&0377);
284: prt("send checksum %o %o\n",sum, length);
285: if(send(buf,5,3) < 0)
286: return(1);
287: prt("checksum ok\n");
288: return(0);
289: }
290:
291: ncopy(p)
292: struct sentry *p;
293: {
294: register i;
295: register char *np;
296:
297: prt("ncopy %o\n",p->s_type);
298: if (p->s_type == NTYPE){
299: np = p->s_val1;
300: prt("Ntype %s\n",np);
301: for (i=0; i<(NSIZ-1); i++){
302: if (*np == 0) break;
303: nbuf[i] = *np++;
304: }
305: nbuf[i] = 0;
306: return(nbuf);
307: }
308: prt("ncopy ret %o\n",p->s_val1);
309: return(p->s_val1);
310: }
311:
312:
313: decimal(v)
314: char *v;
315: {
316: register n, negative;
317: char c;
318:
319: n=0;
320: negative=0;
321: while (c = *v++){
322: if ((n==0) && (c=='-')) {
323: negative=1;
324: continue;
325: }
326: if ((c < '0') || (c > '9')) {
327: mesg("Bad buffer size");
328: exit(EBAD);
329: }
330: n = (n*10) + (c-'0');
331: }
332: if (negative)
333: n = -n;
334: return(n);
335: }
336:
337:
338: dcheck(p){
339: register i;
340:
341: prt("dcheck on %s\n",ncopy(p));
342: if (filstat(ncopy(p),&statbuf) < 0)
343: return(NULL);
344: if (statbuf->type == FFILE)
345: return(FTYPE);
346: if (statbuf->type == DIR)
347: return(DTYPE);
348: return(NULL);
349: }
350: char pbuf[128];
351: getpwentry(uname)
352: char *uname;
353: {
354: char *np,*namep;
355: extern char *copy();
356: int t,f;
357: long l;
358: int i;
359:
360: utmp.u_tty = 'A' + chan;
361: if(getent(uname,pbuf))
362: return(1);
363: np = colon(pbuf);
364: #ifdef ROOT
365: if(*np != ':')
366: return(1);
367: #endif
368: for(i=0;i<8;i++)
369: utmp.u_name[i] = 0;
370: copy(utmp.u_name,pbuf,t = (size(pbuf)>8)?8:size(pbuf));
371: np = colon(np);
372: uid = 0;
373: while (*np != ':')
374: uid = uid*10 + *np++ - '0';
375: #ifndef ROOT
376: if(uid == ROOTUSR) /* disallow root */
377: return(1); /* */
378: #endif
379: np++;
380: np = colon(np); /* skip group id */
381: np = colon(np);
382: namep = np;
383: np = colon(np);
384: prt("dir = %s\n",namep);
385: copy(unixid,namep, t = (size(namep)>8)?8:size(namep));
386: if (chdir(namep)<0) {
387: error(0,9);
388: }
389: time(&utmp.u_time[0]);
390: #ifdef ACCT
391: if ((f = open("/tmp/utmp", 1)) >= 0) {
392: t = utmp.u_tty;
393: if (t>='a')
394: t =- 'a' - (10+'0');
395: if((t >= 'A')&&(t<= 'Z'))
396: t = 10 + 'z' - 'a' + 1 + '0' + (t - 'A');
397: l = (t-'0')*16;
398: seek(f, l, 0);
399: write(f, &utmp, 16);
400: close(f);
401: }
402: if ((f = open("/usr/adm/wtmp", 1)) >= 0) {
403: seek(f, 0L, 2);
404: write(f, &utmp, 16);
405: close(f);
406: }
407: #endif
408: return(0);
409: }
410: char ab[BUFSIZ];
411: getent(name, rbuf)
412: char *name, *rbuf;
413: {
414: int fi, r, c;
415: FILE *ffin;
416: register char *gnp, *rnp;
417:
418: r = 1;
419: if((ffin = fopen(netpwd, "r")) == NULL){
420: prt("Can't open passwd");
421: goto ret;
422:
423: }
424: setbuf(ffin,&ab);
425: loop:
426: gnp = name;
427: rnp = rbuf;
428: while((c=getc(ffin)) != '\n') {
429: if(c == EOF)
430: goto ret;
431:
432: *rnp++ = c;
433: }
434: *rnp++ = '\0';
435: rnp = rbuf;
436: while (*gnp++ == *rnp++);
437: if ((*--gnp!='\0') || *--rnp!=':')
438: goto loop;
439:
440: r = 0;
441: ret:
442: fclose(ffin);
443: return(r);
444: }
445:
446: colon(p)
447: register char *p;
448: {
449:
450: while (*p != ':') {
451: if (*p++ == '\0') {
452: error(EPWD,2);
453: }
454: }
455: *p++ = '\0';
456: return(p);
457: }
458: dstat(p,bp)
459: struct dentry *bp;
460: char *p;
461: {
462: int f;
463:
464: prt("dstat on %s\n",p);
465: bp->d_type = NULL;
466: if((f = open(p,0)) < 0)
467: return(-1);
468: close(f);
469: bp->d_type = NTYPE;
470: return(1);
471: }
472: /*
473: * Copy c characters of q into p
474: */
475: char *copy(p,q,c)
476: register char *p,*q;
477: int c;
478: {
479: register i;
480:
481: for(i=0;i<c;i++){
482: *p++ = *q++;
483: }
484: return(c);
485: }
486: /*
487: * Length of string
488: */
489: size(s)
490: register char *s;
491: {
492: register i;
493:
494: i = 0;
495: while(*s++ != '\0')
496: i++;
497: return(i);
498: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.