![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ftamd-select.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / ftam2|
Return to ftamd-select.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / ftam2 |
1.1 root 1: /* ftamd-select.c - FTAM responder -- selection regime */
2:
3: #ifndef lint
4: static char *rcsid = "$Header: /f/osi/ftam2/RCS/ftamd-select.c,v 7.1 90/07/01 21:03:20 mrose Exp $";
5: #endif
6:
7: /*
8: * $Header: /f/osi/ftam2/RCS/ftamd-select.c,v 7.1 90/07/01 21:03:20 mrose Exp $
9: *
10: *
11: * $Log: ftamd-select.c,v $
12: * Revision 7.1 90/07/01 21:03:20 mrose
13: * pepsy
14: *
15: * Revision 7.0 89/11/23 21:54:29 mrose
16: * Release 6.0
17: *
18: */
19:
20: /*
21: * NOTICE
22: *
23: * Acquisition, use, and distribution of this module and related
24: * materials are subject to the restrictions of a license agreement.
25: * Consult the Preface in the User's Manual for the full terms of
26: * this agreement.
27: *
28: */
29:
30:
31: #include <grp.h>
32: #include <stdio.h>
33: #include <pwd.h>
34: #include "ftamsystem.h"
35:
36:
37: #define NUID 400
38: #define NGID 400
39:
40:
41: #define FA_CHATTR \
42: (FA_FILENAME | FA_ACCOUNT)
43:
44:
45: #define FA_PERM_WRITE (FA_PERM_INSERT | FA_PERM_REPLACE | FA_PERM_EXTEND \
46: | FA_PERM_ERASE)
47: #define FA_PERM_OWNER FA_PERM_CHNGATTR
48: #define FA_PERM_PARENT FA_PERM_DELETE
49:
50:
51: #ifdef SYS5
52: struct group *getgrnam ();
53: struct passwd *getpwnam (), *getpwent (), *getpwuid ();
54: #endif
55:
56: /* DATA */
57:
58: static char mvfile[MAXPATHLEN];
59: static PE rdparam = NULLPE;
60:
61: char *getfile ();
62: #ifdef BRIDGE
63: #define E_OK R_OK
64: #else
65: char *getuser (), *getgroup ();
66: #endif
67:
68:
69: long lseek ();
70:
71: #ifdef SYS5
72: #define EACCESS access
73:
74: #define rename(f1,f2) \
75: (unlink (f2), link (f1, f2) != NOTOK ? unlink (f1) : NOTOK)
76: #endif
77:
78: #ifdef BRIDGE
79: #define ftp_access(file,mode) ftp_exist (file)
80: #endif
81:
82: /* SELECTION REGIME */
83:
84: int ftam_selection (ftg, ftm)
85: register struct FTAMgroup *ftg,
86: *ftm;
87: {
88: int action,
89: state;
90:
91: bzero ((char *) ftm, sizeof *ftm);
92: ftm -> ftg_flags = ftg -> ftg_flags;
93:
94: statok = 0;
95:
96: state = FSTATE_SUCCESS;
97: if (ftg -> ftg_flags & FTG_SELECT) {
98: register struct FTAMselect *ftse = &ftg -> ftg_select;
99: register struct FTAMattributes *fa = &ftse -> ftse_attrs;
100: struct FTAMdiagnostic *dp = ftm -> ftg_select.ftse_diags;
101:
102: errno = 0;
103: if (!(fa -> fa_present & FA_FILENAME)
104: || fa -> fa_nfile != 1
105: || (myfile = getfile (fa -> fa_files[0])) == NULL
106: #ifdef BRIDGE
107: || ftp_access (myfile, E_OK) == NOTOK) {
108: #else
109: || stat (myfile, &myst) == NOTOK) {
110: #endif
111: dp -> ftd_type = DIAG_PERM;
112: dp -> ftd_identifier = FS_SEL_FILENAME;
113: dp -> ftd_observer = dp -> ftd_source = EREF_RFSU;
114: dp -> ftd_delay = DIAG_NODELAY;
115: if (errno) {
116: (void) strcpy (dp -> ftd_data, sys_errname (errno));
117: dp -> ftd_cc = strlen (dp -> ftd_data);
118: }
119: else
120: dp -> ftd_cc = 0;
121: dp++;
122:
123: state = FSTATE_FAILURE;
124: goto done_select;
125: }
126: statok = 1;
127: #ifndef BRIDGE
128: switch (myst.st_mode & S_IFMT) {
129: case S_IFREG:
130: case S_IFDIR:
131: break;
132:
133: default:
134: if (myst.st_dev == null_dev && myst.st_ino == null_ino) {
135: myst.st_mode &= ~S_IFMT, myst.st_mode |= S_IFREG;
136: break;
137: }
138: dp -> ftd_type = DIAG_PERM;
139: dp -> ftd_identifier = FS_SEL_AVAIL;
140: dp -> ftd_observer = dp -> ftd_source = EREF_RFSU;
141: dp -> ftd_delay = DIAG_NODELAY;
142: dp -> ftd_cc = 0;
143: dp++;
144:
145: state = FSTATE_FAILURE;
146: goto done_select;
147: }
148: #else
149: /* can't check a file you don't have */
150: #endif
151:
152: if (ftg -> ftg_flags & FTG_RDATTR)
153: ftse -> ftse_access |= FA_PERM_READATTR;
154: if (ftg -> ftg_flags & FTG_CHATTR)
155: ftse -> ftse_access |= FA_PERM_CHNGATTR;
156: if (ftg -> ftg_flags & FTG_DELETE)
157: ftse -> ftse_access |= FA_PERM_DELETE;
158: if (chkaccess (NOTOK, ftse -> ftse_access, &ftse -> ftse_conctl, &dp)
159: == NOTOK) {
160: state = FSTATE_FAILURE;
161: goto done_select;
162: }
163: #ifndef BRIDGE
164: if (ftse -> ftse_account) {
165: if ((mygid = findgid (ftse -> ftse_account)) == NOTOK) {
166: dp -> ftd_type = DIAG_PERM;
167: dp -> ftd_identifier = FS_SEL_ACCOUNT;
168: dp -> ftd_observer = EREF_RFSU, dp -> ftd_source = EREF_IFSU;
169: dp -> ftd_delay = DIAG_NODELAY;
170: dp -> ftd_cc = 0;
171: dp++;
172:
173: state = FSTATE_FAILURE;
174: goto done_select;
175: }
176: }
177: else
178: #else
179: /* no account checking */
180: #endif
181: mygid = NOTOK;
182:
183: done_select: ;
184: myaccess = ftse -> ftse_access;
185: ftm -> ftg_select.ftse_state = state;
186: ftm -> ftg_select.ftse_ndiag = dp - ftm -> ftg_select.ftse_diags;
187: }
188:
189: if (ftg -> ftg_flags & FTG_CREATE) {
190: register struct FTAMcreate *ftce = &ftg -> ftg_create;
191: register struct FTAMattributes *fa = &ftce -> ftce_attrs;
192: struct FTAMdiagnostic *dp = ftm -> ftg_create.ftce_diags;
193: register struct vfsmap *vf;
194:
195: if (!(fa -> fa_present & FA_FILENAME)
196: || fa -> fa_nfile != 1
197: || (myfile = getfile (fa -> fa_files[0])) == NULL) {
198: dp -> ftd_type = DIAG_PERM;
199: dp -> ftd_identifier = FS_SEL_FILENAME;
200: dp -> ftd_observer = dp -> ftd_source = EREF_RFSU;
201: dp -> ftd_delay = DIAG_NODELAY;
202: dp -> ftd_cc = 0;
203: dp++;
204:
205: state = FSTATE_FAILURE;
206: goto done_create;
207: }
208: #ifdef BRIDGE
209: if (ftp_access (myfile, E_OK) != NOTOK)
210: #else
211: if (stat (myfile, &myst) != NOTOK)
212: #endif
213: statok = 1;
214: if (statok) {
215: #ifndef BRIDGE /* Assume file type allow corrective action */
216: switch (myst.st_mode & S_IFMT) {
217: case S_IFREG:
218: break;
219:
220: case S_IFDIR:
221: switch (ftce -> ftce_override) {
222: case FOVER_WRITE:
223: dp -> ftd_type = DIAG_PERM;
224: dp -> ftd_identifier = FS_SEL_CRELOSE;
225: dp -> ftd_observer = dp -> ftd_source = EREF_RFSU;
226: dp -> ftd_delay = DIAG_NODELAY;
227: dp -> ftd_cc = 0;
228: dp++;
229:
230: state = FSTATE_FAILURE;
231: goto done_create;
232:
233: default:
234: break;
235: }
236: break;
237:
238: default:
239: if (myst.st_dev == null_dev && myst.st_ino == null_ino) {
240: myst.st_mode &= ~S_IFMT, myst.st_mode |= S_IFREG;
241: break;
242: }
243: dp -> ftd_type = DIAG_PERM;
244: dp -> ftd_identifier = FS_SEL_AVAIL;
245: dp -> ftd_observer = dp -> ftd_source = EREF_RFSU;
246: dp -> ftd_delay = DIAG_NODELAY;
247: dp -> ftd_cc = 0;
248: dp++;
249:
250: state = FSTATE_FAILURE;
251: goto done_create;
252: }
253: #endif
254: switch (ftce -> ftce_override) {
255: case FOVER_FAIL:
256: dp -> ftd_type = DIAG_PERM;
257: dp -> ftd_identifier = FS_SEL_EXISTS;
258: dp -> ftd_observer = dp -> ftd_source = EREF_RFSU;
259: dp -> ftd_delay = DIAG_NODELAY;
260: dp -> ftd_cc = 0;
261: dp++;
262:
263: state = FSTATE_FAILURE;
264: goto done_create;
265:
266: case FOVER_SELECT:
267: if (ftg -> ftg_flags & FTG_RDATTR)
268: ftce -> ftce_access |= FA_PERM_READATTR;
269: if (ftg -> ftg_flags & FTG_CHATTR)
270: ftce -> ftce_access |= FA_PERM_CHNGATTR;
271: if (ftg -> ftg_flags & FTG_DELETE)
272: ftce -> ftce_access |= FA_PERM_DELETE;
273: if (chkaccess (NOTOK, ftce -> ftce_access,
274: &ftce -> ftce_conctl, &dp) == NOTOK) {
275: state = FSTATE_FAILURE;
276: goto done_create;
277: }
278: break;
279:
280: default:
281: break;
282: }
283: }
284:
285: for (vf = vfs; vf -> vf_entry; vf++)
286: if (vf -> vf_oid
287: && oid_cmp (vf -> vf_oid, fa -> fa_contents) == 0)
288: break;
289: if (!vf -> vf_entry) {
290: (void) sprintf (dp -> ftd_data,
291: "invalid contents-type %s",
292: sprintoid (fa -> fa_contents));
293: dp -> ftd_cc = strlen (dp -> ftd_data);
294: dp -> ftd_type = DIAG_PERM;
295: dp -> ftd_identifier = FS_SEL_ATRVALUE;
296: dp -> ftd_observer = EREF_RFSU, dp -> ftd_source = EREF_IFSU;
297: dp -> ftd_delay = DIAG_NODELAY;
298: dp++;
299:
300: state = FSTATE_FAILURE;
301: goto done_create;
302: }
303:
304: if (chkattrs (fa, fa -> fa_present & ~(FA_FILENAME | FA_CONTENTS),
305: 1, &dp) == NOTOK) {
306: state = FSTATE_FAILURE;
307: goto done_create;
308: }
309:
310: #ifndef BRIDGE /* no account checking */
311: if (ftce -> ftce_account) {
312: if ((mygid = findgid (ftce -> ftce_account)) == NOTOK) {
313: dp -> ftd_type = DIAG_PERM;
314: dp -> ftd_identifier = FS_SEL_ACCOUNT;
315: dp -> ftd_observer = EREF_RFSU, dp -> ftd_source = EREF_IFSU;
316: dp -> ftd_delay = DIAG_NODELAY;
317: dp -> ftd_cc = 0;
318: dp++;
319:
320: state = FSTATE_FAILURE;
321: goto done_create;
322: }
323: }
324: else
325: #endif
326: mygid = NOTOK;
327:
328: done_create: ;
329: ftm -> ftg_create.ftce_state = state;
330: ftm -> ftg_create.ftce_ndiag = dp - ftm -> ftg_create.ftce_diags;
331: }
332:
333: if (ftg -> ftg_flags & FTG_RDATTR)
334: ftm -> ftg_readattr.ftra_action = FACTION_SUCCESS;
335:
336: if (ftg -> ftg_flags & FTG_CHATTR) {
337: register struct FTAMchngattr *ftca = &ftg -> ftg_chngattr;
338: register struct FTAMattributes *fa = &ftca -> ftca_attrs;
339: struct FTAMdiagnostic *dp = ftm -> ftg_chngattr.ftca_diags;
340:
341: if (chkattrs (fa, fa -> fa_present, 0, &dp) == NOTOK)
342: action = FACTION_PERM;
343: else
344: action = FACTION_SUCCESS;
345:
346: ftm -> ftg_chngattr.ftca_action = action;
347: ftm -> ftg_chngattr.ftca_ndiag = dp - ftm -> ftg_chngattr.ftca_diags;
348: }
349:
350: if (ftg -> ftg_flags & FTG_OPEN) {
351: register struct FTAMopen *ftop = &ftm -> ftg_open;
352:
353: ftop -> ftop_state = FSTATE_FAILURE;
354: ftop -> ftop_action = FACTION_SUCCESS;
355: if (ftop -> ftop_contents = ftg -> ftg_open.ftop_contents)
356: ftop -> ftop_parameter = ftg -> ftg_open.ftop_parameter;
357:
358: FCINIT (&ftop -> ftop_conctl);
359: }
360:
361: if (ftg -> ftg_flags & FTG_CLOSE)
362: ftm -> ftg_close.ftcl_action = FACTION_SUCCESS;
363:
364: if (ftg -> ftg_flags & FTG_DESELECT)
365: ftm -> ftg_deselect.ftde_action = FACTION_SUCCESS;
366:
367: if (ftg -> ftg_flags & FTG_DELETE)
368: ftm -> ftg_delete.ftxe_action = FACTION_SUCCESS;
369:
370: if (ftg -> ftg_flags & FTG_SELECT) {
371: register struct FTAMselect *ftse = &ftm -> ftg_select;
372: register struct FTAMattributes *fa = &ftse -> ftse_attrs;
373:
374: if (state != FSTATE_SUCCESS) {
375: ftse -> ftse_action = FACTION_PERM;
376: *fa = ftg -> ftg_select.ftse_attrs; /* struct copy */
377: ftm -> ftg_flags &= ~(FTG_RDATTR | FTG_CHATTR | FTG_OPEN);
378: return;
379: }
380: ftse -> ftse_action = FACTION_SUCCESS;
381: fa -> fa_present = FA_FILENAME;
382: fa -> fa_nfile = 0;
383: fa -> fa_files[fa -> fa_nfile++] = myfile;
384: }
385:
386: if (ftg -> ftg_flags & FTG_CREATE) {
387: register struct FTAMattributes *fa = &ftg -> ftg_create.ftce_attrs;
388: register struct FTAMcreate *ftce = &ftm -> ftg_create;
389: struct FTAMdiagnostic *dp = ftce -> ftce_diags + ftce -> ftce_ndiag;
390:
391: if (state != FSTATE_SUCCESS) {
392: ftce -> ftce_action = FACTION_PERM;
393: ftce -> ftce_attrs = *fa; /* struct copy */
394: ftm -> ftg_flags &= ~(FTG_RDATTR | FTG_CHATTR | FTG_OPEN);
395: return;
396: }
397: switch (ftg -> ftg_create.ftce_override) {
398: case FOVER_SELECT:
399: default:
400: if (statok)
401: break;
402: goto do_create;
403:
404: case FOVER_DELETE:
405: #ifdef BRIDGE
406: if (statok && ftp_delete (myfile) == NOTOK) {
407: #else
408: if (statok
409: && ((myst.st_mode & S_IFMT) == S_IFREG
410: ? unlink (myfile)
411: : rmdir (myfile)) == NOTOK) {
412: bad_override: ;
413: #endif
414: dp -> ftd_type = DIAG_PERM;
415: dp -> ftd_identifier = FS_SEL_CRELOSE;
416: dp -> ftd_observer = dp -> ftd_source = EREF_RFSU;
417: dp -> ftd_delay = DIAG_NODELAY;
418: #ifdef BRIDGE
419: (void) strcpy (dp -> ftd_data, ftp_error);
420: #else
421: (void) strcpy (dp -> ftd_data, sys_errname (errno));
422: #endif
423: dp -> ftd_cc = strlen (dp -> ftd_data);
424: dp++;
425:
426: bad_create: ;
427: ftce -> ftce_action = FACTION_PERM;
428: ftce -> ftce_attrs = *fa; /* struct copy */
429: ftce -> ftce_ndiag = dp - ftce -> ftce_diags;
430:
431: ftce -> ftce_state = FSTATE_FAILURE;
432: ftm -> ftg_flags &= ~(FTG_RDATTR | FTG_CHATTR | FTG_OPEN);
433: return;
434: }
435: /* else fall */
436:
437: case FOVER_FAIL:
438: statok = 0;
439: do_create: ;
440: if (!(fa -> fa_present & FA_CONTENTS)
441: || oid_cmp (vfs[VFS_FDF].vf_oid, fa -> fa_contents)) {
442: #ifdef BRIDGE
443: if (ftp_create (myfile) == NOTOK) {
444: #else
445: if ((myfd = open (myfile, O_RDWR | O_CREAT | O_TRUNC,
446: 0666)) == NOTOK) {
447: #endif
448: bad_open: ;
449: dp -> ftd_type = DIAG_PERM;
450: dp -> ftd_identifier = FS_SEL_CREATE;
451: dp -> ftd_observer = dp -> ftd_source = EREF_RFSU;
452: dp -> ftd_delay = DIAG_NODELAY;
453: (void) strcpy (dp -> ftd_data, sys_errname (errno));
454: dp -> ftd_cc = strlen (dp -> ftd_data);
455: dp++;
456:
457: goto bad_create;
458: }
459: }
460: else
461: #ifdef BRIDGE
462: if (ftp_mkdir (myfile) == NOTOK)
463: #else
464: if (mkdir (myfile, 0755) == NOTOK)
465: #endif
466: goto bad_open;
467: if (chngattrs (fa -> fa_present
468: & ~(FA_FILENAME | FA_CONTENTS), fa, &dp) == NOTOK)
469: goto bad_create;
470: break;
471:
472: case FOVER_WRITE:
473: if (!statok)
474: goto do_create;
475: #ifndef BRIDGE
476: #ifdef SUNOS4
477: if (myst.st_size > 0 && truncate (myfile, (off_t) 0) == NOTOK)
478: goto bad_override;
479: #else
480: if (myst.st_size > 0 && truncate (myfile, 0) == NOTOK)
481: goto bad_override;
482: #endif
483: #endif
484: break;
485: }
486:
487: ftce -> ftce_action = FACTION_SUCCESS;
488: (void) readattrs (FA_FILENAME | FA_ACTIONS | FA_CONTENTS,
489: &ftce -> ftce_attrs, fa -> fa_contents,
490: fa -> fa_parameter, myfile, &myst, &dp);
491: if (fa -> fa_present & FA_ACTIONS)
492: ftce -> ftce_attrs.fa_permitted &= fa -> fa_permitted;
493: ftce -> ftce_ndiag = dp - ftce -> ftce_diags;
494: }
495:
496: if (ftg -> ftg_flags & FTG_RDATTR
497: && (ftm -> ftg_readattr.ftra_action == FACTION_SUCCESS)) {
498: register struct FTAMreadattr *ftra = &ftm -> ftg_readattr;
499: struct FTAMdiagnostic *dp = ftra -> ftra_diags + ftra -> ftra_ndiag;
500:
501: if (!statok) {
502: #ifdef BRIDGE
503: if (0) { /* assume OK */
504: #else
505: if ((myfd != NOTOK ? fstat (myfd, &myst)
506: : stat (myfile, &myst)) == NOTOK) {
507: dp -> ftd_type = DIAG_PERM;
508: dp -> ftd_identifier = FS_MGT_READ;
509: dp -> ftd_observer = dp -> ftd_source = EREF_RFSU;
510: dp -> ftd_delay = DIAG_NODELAY;
511: dp -> ftd_cc = 0;
512: dp++;
513: #endif
514:
515: bad_readattr: ;
516: ftra -> ftra_action = FACTION_PERM;
517: ftra -> ftra_ndiag = dp - ftra -> ftra_diags;
518: return;
519: }
520: else
521: statok++;
522: }
523: if (readattrs (ftg -> ftg_readattr.ftra_attrnames,
524: &ftra -> ftra_attrs, ftg -> ftg_flags & FTG_OPEN
525: ? ftg -> ftg_open.ftop_contents : NULLOID, NULLPE,
526: myfile, &myst, &dp) == NOTOK)
527: goto bad_readattr;
528: ftra -> ftra_ndiag = dp - ftra -> ftra_diags;
529: }
530:
531: if (ftg -> ftg_flags & FTG_CHATTR
532: && (ftm -> ftg_chngattr.ftca_action == FACTION_SUCCESS)) {
533: register struct FTAMchngattr *ftca = &ftm -> ftg_chngattr;
534: register struct FTAMattributes *fa = &ftg -> ftg_chngattr.ftca_attrs;
535: struct FTAMdiagnostic *dp = ftca -> ftca_diags + ftca -> ftca_ndiag;
536:
537: if (chngattrs (fa -> fa_present, fa, &dp) == NOTOK) {
538: ftca -> ftca_action = FACTION_PERM;
539: ftca -> ftca_ndiag = dp - ftca -> ftca_diags;
540: return;
541: }
542:
543: ftca -> ftca_ndiag = dp - ftca -> ftca_diags;
544: }
545:
546: if (ftg -> ftg_flags & FTG_OPEN) {
547: #ifndef BRIDGE
548: int mode;
549: #endif
550: register struct FTAMopen *ftop = &ftm -> ftg_open;
551: struct FTAMdiagnostic *dp = ftop -> ftop_diags + ftop -> ftop_ndiag;
552:
553: ftop -> ftop_state = FSTATE_SUCCESS;
554: if (statok == 0) {
555: if (stat (myfile, &myst) == NOTOK) {
556: #ifndef BRIDGE
557: unavailable: ;
558: #endif
559: dp -> ftd_type = DIAG_PERM;
560: dp -> ftd_identifier = FS_SEL_AVAIL;
561: dp -> ftd_observer = dp -> ftd_source = EREF_RFSU;
562: dp -> ftd_delay = DIAG_NODELAY;
563: if (errno) {
564: (void) strcpy (dp -> ftd_data, sys_errname (errno));
565: dp -> ftd_cc = strlen (dp -> ftd_data);
566: }
567: else
568: dp -> ftd_cc = 0;
569: dp++;
570:
571: ftop -> ftop_state = FSTATE_FAILURE;
572: goto done_open;
573: }
574: else
575: statok = 1;
576: }
577:
578: if (ftop -> ftop_contents == NULL) {
579: register struct FTAMattributes *fa;
580:
581: if (ftg -> ftg_flags & FTG_CREATE) {
582: fa = &ftg -> ftg_create.ftce_attrs;
583:
584: ftop -> ftop_contents = fa -> fa_contents;
585: ftop -> ftop_parameter = fa -> fa_parameter;
586: advise (LLOG_DEBUG, NULLCP,
587: "using contents-type from CREATE <%s, 0x%x>",
588: oid2ode (ftop -> ftop_contents),
589: ftop -> ftop_parameter);
590: goto find_myvfs;
591: }
592:
593: if ((ftg -> ftg_flags & FTG_RDATTR)
594: && ftm -> ftg_readattr.ftra_action == FACTION_SUCCESS
595: && ((fa = &ftm -> ftg_readattr.ftra_attrs) -> fa_present
596: & FA_CONTENTS)) {
597: ftop -> ftop_contents = fa -> fa_contents;
598: ftop -> ftop_parameter = fa -> fa_parameter;
599: advise (LLOG_DEBUG, NULLCP,
600: "using contents-type from READ-ATTRIBUTE <%s, 0x%x>",
601: oid2ode (ftop -> ftop_contents),
602: ftop -> ftop_parameter);
603:
604: find_myvfs: ;
605: if ((myvf = st2vfs (myfd, myfile, &myst, ftop -> ftop_contents,
606: ftamfd)) == NULL)
607: goto no_ascertain;
608: if (oid_cmp (ftop -> ftop_contents, myvf -> vf_oid) == 0)
609: goto find_param;
610: advise (LLOG_DEBUG, NULLCP,
611: "wrong intuition; back to step one");
612: ftop -> ftop_contents = NULLOID;
613: ftop -> ftop_parameter = NULLPE;
614: }
615:
616: if ((myvf = st2vfs (myfd, myfile, &myst, NULLOID, ftamfd))
617: == NULL) {
618: no_ascertain: ;
619: (void) strcpy (dp -> ftd_data,
620: "unable to ascertain contents-type");
621: dp -> ftd_cc = strlen (dp -> ftd_data);
622: dp -> ftd_type = DIAG_PERM;
623: dp -> ftd_identifier = FS_ACC_LCL;
624: dp -> ftd_observer = dp -> ftd_source = EREF_RFSU;
625: dp -> ftd_delay = DIAG_NODELAY;
626: dp++;
627:
628: ftop -> ftop_state = FSTATE_FAILURE;
629: goto done_open;
630: }
631: ftop -> ftop_contents = myvf -> vf_oid;
632: advise (LLOG_DEBUG, NULLCP,
633: "using contents-type from st2vfs: %s",
634: oid2ode (ftop -> ftop_contents));
635:
636: find_param: ;
637: if (myvf -> vf_mandatory > 0 && ftop -> ftop_parameter == NULL) {
638: char buffer[BUFSIZ];
639:
640: if (rdparam)
641: pe_free (rdparam), rdparam = NULLPE;
642: if (enc_f (myvf -> vf_number, &_ZDOCS_mod, &rdparam, 1, 0,
643: NULLCP, myvf -> vf_parameter) == NOTOK) {
644: advise (LLOG_EXCEPTIONS, NULLCP,
645: "unable to build parameter: %s", PY_pepy);
646: if (rdparam)
647: pe_free (rdparam), rdparam = NULLPE;
648: goto no_ascertain;
649: }
650: ftop -> ftop_parameter = rdparam;
651:
652: vpushstr (buffer);
653: vunknown (ftop -> ftop_parameter);
654: vpopstr ();
655: advise (LLOG_DEBUG, NULLCP,
656: "generating parameter from vfs: %s", buffer);
657: }
658: else
659: if (!myvf -> vf_mandatory && ftop -> ftop_parameter)
660: ftop -> ftop_parameter = NULLPE;
661: }
662: else
663: if ((myvf = st2vfs (myfd, myfile, &myst, ftop -> ftop_contents,
664: ftamfd)) == NULL) {
665: dp -> ftd_cc = 0;
666: bad_param: ;
667: dp -> ftd_type = DIAG_PERM;
668: dp -> ftd_identifier = FS_ACC_TYPINCON;
669: dp -> ftd_observer = EREF_RFSU, dp -> ftd_source = EREF_IFSU;
670: dp -> ftd_delay = DIAG_NODELAY;
671: dp++;
672:
673: ftop -> ftop_state = FSTATE_FAILURE;
674: goto done_open;
675: }
676:
677: if (oid_cmp (ftop -> ftop_contents, myvf -> vf_oid)) {
678: advise (LLOG_NOTICE, NULLCP, "simplifying document type");
679:
680: ftop -> ftop_contents = myvf -> vf_oid;
681: ftop -> ftop_parameter = NULLPE;
682: if (myvf -> vf_mandatory) {
683: char buffer[BUFSIZ];
684:
685: if (rdparam)
686: pe_free (rdparam), rdparam = NULLPE;
687: if (enc_f (myvf -> vf_number, &_ZDOCS_mod, &rdparam, 1, 0,
688: NULLCP, myvf -> vf_parameter) == NOTOK) {
689: advise (LLOG_EXCEPTIONS, NULLCP,
690: "unable to build parameter: %s", PY_pepy);
691: if (rdparam)
692: pe_free (rdparam), rdparam = NULLPE;
693: goto no_ascertain;
694: }
695: ftop -> ftop_parameter = rdparam;
696:
697: vpushstr (buffer);
698: vunknown (ftop -> ftop_parameter);
699: vpopstr ();
700: advise (LLOG_DEBUG, NULLCP,
701: "generating parameter from myvf: %s", buffer);
702: }
703: }
704:
705: if (ftop -> ftop_parameter) {
706: if (myvf -> vf_number < 0) {
707: (void) sprintf (dp -> ftd_data,
708: "unexpected document type parameter");
709: dp -> ftd_cc = strlen (dp -> ftd_data);
710: goto bad_param;
711: }
712: myparam = NULL;
713: if (dec_f (myvf -> vf_number, &_ZDOCS_mod, ftop -> ftop_parameter,
714: 1, NULLIP, NULLVP, &myparam) == NOTOK) {
715: (void) sprintf (dp -> ftd_data,
716: "unable to parse document type parameter: %s",
717: PY_pepy);
718: dp -> ftd_cc = strlen (dp -> ftd_data);
719: goto bad_param;
720: }
721: if (myvf -> vf_check
722: && (*myvf -> vf_check) (myparam, dp -> ftd_data)
723: == NOTOK)
724: goto bad_param;
725: }
726: else
727: if (myvf -> vf_mandatory > 0) {
728: (void) strcpy (dp -> ftd_data,
729: "mandatory document type parameter missing");
730: dp -> ftd_cc = strlen (dp -> ftd_data);
731: goto bad_param;
732: }
733:
734: mymode = ftg -> ftg_open.ftop_mode;
735: #ifndef BRIDGE
736: if (mymode & FA_PERM_WRITE)
737: mode = (mymode & FA_PERM_READ) ? O_RDWR : O_WRONLY;
738: else
739: mode = O_RDONLY;
740: #endif
741:
742: errno = 0;
743: #ifndef BRIDGE
744: switch (myst.st_mode & S_IFMT) {
745: case S_IFREG:
746: if (myfd == NOTOK && (myfd = open (myfile, mode)) == NOTOK)
747: goto unavailable;
748: break;
749:
750: case S_IFDIR:
751: if (mode == O_RDONLY)
752: break;
753: /* else fall */
754:
755: default:
756: goto unavailable;
757: }
758: #endif
759:
760: myconctl = ftg -> ftg_open.ftop_conctl; /* struct copy */
761: ftm -> ftg_open.ftop_conctl = myconctl; /* .. */
762: mylockstyle = ftg -> ftg_open.ftop_locking;
763:
764: if (chkaccess (myfd, mymode, &myconctl, &dp) == NOTOK) {
765: ftop -> ftop_state = FSTATE_FAILURE;
766: goto done_open;
767: }
768:
769: done_open: ;
770: ftop -> ftop_ndiag = dp - ftop -> ftop_diags;
771:
772: if (ftop -> ftop_state != FSTATE_SUCCESS) {
773: ftop -> ftop_action = FACTION_PERM;
774: return;
775: }
776: }
777:
778: if (ftg -> ftg_flags & FTG_CLOSE
779: && (ftm -> ftg_close.ftcl_action == FACTION_SUCCESS)) {
780: if (myfd != NOTOK) {
781: #ifdef BRIDGE
782: (void) close (myfd);
783: (void) ftp_reply ();
784: #else
785: unlock ();
786: (void) close (myfd);
787: #endif
788: myfd = NOTOK;
789: }
790: if (myvf && myparam) {
791: fre_obj (myparam, _ZDOCS_mod.md_dtab[myvf -> vf_number],
792: &_ZDOCS_mod);
793: myparam = NULL;
794: }
795: }
796:
797: if (ftg -> ftg_flags & FTG_DESELECT) {
798: register struct FTAMdeselect *ftde = &ftm -> ftg_deselect;
799:
800: if (ftde -> ftde_action == FACTION_SUCCESS) {
801: /* anything to charge if (mygid != NOTOK)? ha! */
802: }
803: }
804:
805: if (ftg -> ftg_flags & FTG_DELETE) {
806: register struct FTAMdelete *ftxe = &ftm -> ftg_delete;
807: struct FTAMdiagnostic *dp = ftxe -> ftxe_diags + ftxe -> ftxe_ndiag;
808:
809: if (ftxe -> ftxe_action == FACTION_SUCCESS) {
810: #ifdef BRIDGE
811: if (ftp_delete (myfile) == NOTOK) {
812: #else
813: if (!statok && stat (myfile, &myst) == NOTOK)
814: myst.st_mode = S_IFREG;
815: if (((myst.st_mode & S_IFMT) == S_IFREG ? unlink (myfile)
816: : rmdir (myfile))
817: == NOTOK) {
818: #endif
819: dp -> ftd_type = DIAG_PERM;
820: dp -> ftd_identifier = FS_SEL_DELETE;
821: dp -> ftd_observer = dp -> ftd_source = EREF_RFSU;
822: dp -> ftd_delay = DIAG_NODELAY;
823: #ifdef BRIDGE
824: (void) strcpy (dp -> ftd_data, ftp_error);
825: #else
826: (void) strcpy (dp -> ftd_data, sys_errname (errno));
827: #endif
828: dp -> ftd_cc = strlen (dp -> ftd_data);
829: dp++;
830:
831: ftxe -> ftxe_action = FACTION_PERM;
832: ftxe -> ftxe_ndiag = dp - ftxe -> ftxe_diags;
833: return;
834: }
835: advise (LLOG_NOTICE, NULLCP, "delete %s", myfile);
836: }
837: }
838: }
839:
840: /* */
841:
842: #ifdef BRIDGE
843: /* ARGSUSED */
844: #endif
845:
846: static int chkaccess (fd, request, fc, diags)
847: int fd,
848: request;
849: #ifndef BRIDGE
850: register
851: #endif
852: struct FTAMconcurrency *fc;
853: register struct FTAMdiagnostic **diags;
854: {
855: int result;
856: #ifndef BRIDGE
857: register char *cp;
858: #endif
859: register struct FTAMdiagnostic *dp = *diags;
860:
861: result = OK;
862:
863: #ifndef BRIDGE
864: if (((request & FA_PERM_READ) && EACCESS (myfile, R_OK) == NOTOK)
865: || ((request & FA_PERM_WRITE) && EACCESS (myfile, W_OK) == NOTOK)
866: || ((request & FA_PERM_OWNER)
867: && (myuid != myst.st_uid && myuid != 0))) {
868: no_access: ;
869: dp -> ftd_type = DIAG_PERM;
870: dp -> ftd_identifier = FS_SEL_ACCAVAIL;
871: dp -> ftd_observer = dp -> ftd_source = EREF_RFSU;
872: dp -> ftd_delay = DIAG_NODELAY;
873: dp -> ftd_cc = 0;
874: dp++;
875:
876: result = NOTOK;
877: goto out;
878: }
879: if (request & FA_PERM_PARENT) {
880: if (cp = rindex (myfile, '/')) {
881: *cp = NULL;
882: result = EACCESS (*myfile ? myfile : "/", W_OK);
883: *cp = '/';
884: }
885: else
886: result = EACCESS (".", W_OK);
887:
888: if (result == NOTOK)
889: goto no_access;
890: }
891: #else
892: /* already selected file and know it exists, FTP cannot tell us more */
893: #endif
894:
895: #ifndef BRIDGE
896: out: ;
897:
898: if (attrs & FATTR_STORAGE) {
899: if (fd == NOTOK) {
900: mylock = 0;
901:
902: if (((request & FA_PERM_READATTR)
903: && (fc -> fc_readattrlock & FLOCK_RESTRICT))
904: || ((request & FA_PERM_CHNGATTR)
905: && (fc -> fc_chngattrlock & FLOCK_RESTRICT))
906: || ((request & FA_PERM_DELETE)
907: && (fc -> fc_deletelock & FLOCK_RESTRICT))) {
908: dp -> ftd_type = DIAG_PERM;
909: dp -> ftd_identifier = FS_SEL_CONSUPRT;
910: dp -> ftd_observer = dp -> ftd_source = EREF_RFSU;
911: dp -> ftd_delay = DIAG_NODELAY;
912: dp -> ftd_cc = 0;
913: dp++;
914:
915: result = NOTOK;
916: }
917: }
918: else {
919: #ifdef SYS5
920: struct flock fs;
921: #endif
922:
923: if ((request & FA_PERM_WRITE)
924: && ((fc -> fc_insertlock & FLOCK_RESTRICT)
925: || (fc -> fc_replacelock & FLOCK_RESTRICT)
926: || (fc -> fc_eraselock & FLOCK_RESTRICT)
927: || (fc -> fc_extendlock & FLOCK_RESTRICT))) {
928: mylock = 1;
929: #ifndef SYS5
930: if (flock (fd, LOCK_EX) == NOTOK)
931: goto bad_concur;
932: #else
933: fs.l_type = F_WRLCK;
934: fs.l_whence = L_SET;
935: fs.l_start = fs.l_len = 0;
936: if (fcntl (fd, F_SETLKW, &fs) == NOTOK)
937: goto bad_concur;
938: #endif
939: }
940: else
941: if ((request & FA_PERM_READ)
942: && (fc -> fc_readlock & FLOCK_RESTRICT)) {
943: mylock = 1;
944: #ifndef SYS5
945: if (flock (fd, LOCK_SH) == NOTOK) {
946: #else
947: fs.l_type = F_RDLCK;
948: fs.l_whence = L_SET;
949: fs.l_start = fs.l_len = 0;
950: if (fcntl (fd, F_SETLKW, &fs) == NOTOK) {
951: #endif
952: bad_concur: ;
953: dp -> ftd_type = DIAG_PERM;
954: dp -> ftd_identifier = FS_ACC_CONAVAIL;
955: dp -> ftd_observer = dp -> ftd_source = EREF_RFSU;
956: dp -> ftd_delay = DIAG_NODELAY;
957: (void) strcpy (dp -> ftd_data, sys_errname (errno));
958: dp -> ftd_cc = strlen (dp -> ftd_data);
959: dp++;
960:
961: mylock = 0;
962: result = NOTOK;
963: }
964: }
965: }
966: }
967: #endif
968:
969: *diags = dp;
970: return result;
971: }
972:
973: /* */
974:
975: static int chkattrs (fa, present, select, diags)
976: register struct FTAMattributes *fa;
977: long present;
978: int select;
979: register struct FTAMdiagnostic **diags;
980: {
981: int id,
982: result;
983: char *file;
984: register struct FTAMdiagnostic *dp = *diags;
985:
986: result = OK;
987:
988: present &= ~FA_FUTURESIZE; /* be liberal in what you accept... */
989: if (present & ~(FA_CHATTR | FA_RDATTR)) {
990: dp -> ftd_type = DIAG_PERM;
991: dp -> ftd_identifier = select ? FS_SEL_INITIAL
992: : (present & FA_RDATTR) ? FS_MGT_CHANGE : FS_MGT_EXIST;
993: dp -> ftd_observer = dp -> ftd_source = EREF_RFSU;
994: dp -> ftd_delay = DIAG_NODELAY;
995: dp -> ftd_cc = 0;
996: dp++;
997:
998: result = NOTOK;
999: }
1000:
1001: id = select ? FS_SEL_ATRVALUE : FS_MGT_VALUE;
1002:
1003: if (present & FA_FILENAME) {
1004: if (fa -> fa_nfile != 1
1005: || (file = getfile (fa -> fa_files[0])) == NULL) {
1006: dp -> ftd_type = DIAG_PERM;
1007: dp -> ftd_identifier = id;
1008: dp -> ftd_observer = EREF_RFSU, dp -> ftd_source = EREF_IFSU;
1009: dp -> ftd_delay = DIAG_NODELAY;
1010: (void) strcpy (dp -> ftd_data, "00bad filename");
1011: dp -> ftd_cc = strlen (dp -> ftd_data);
1012: dp++;
1013:
1014: result = NOTOK;
1015: }
1016: else
1017: (void) strcpy (mvfile, file);
1018: }
1019:
1020: #ifndef BRIDGE
1021: if ((present & FA_ACCOUNT) && findgid (fa -> fa_account) == NOTOK) {
1022: dp -> ftd_type = DIAG_PERM;
1023: dp -> ftd_identifier = id;
1024: dp -> ftd_observer = EREF_RFSU, dp -> ftd_source = EREF_IFSU;
1025: dp -> ftd_delay = DIAG_NODELAY;
1026: (void) strcpy (dp -> ftd_data, "02bad storage account");
1027: dp -> ftd_cc = strlen (dp -> ftd_data);
1028: dp++;
1029:
1030: result = NOTOK;
1031: }
1032:
1033: if ((present & FA_FILESIZE) && fa -> fa_filesize < 0) {
1034: dp -> ftd_type = DIAG_PERM;
1035: dp -> ftd_identifier = id;
1036: dp -> ftd_observer = EREF_RFSU, dp -> ftd_source = EREF_IFSU;
1037: dp -> ftd_delay = DIAG_NODELAY;
1038: (void) strcpy (dp -> ftd_data, "13bad filesize");
1039: dp -> ftd_cc = strlen (dp -> ftd_data);
1040: dp++;
1041:
1042: result = NOTOK;
1043: }
1044: #endif
1045:
1046: *diags = dp;
1047: return result;
1048: }
1049:
1050: /* */
1051:
1052: int readattrs (attrnames, fa, proposed, parameter, file, st, diags)
1053: int attrnames;
1054: register struct FTAMattributes *fa;
1055: OID proposed;
1056: PE parameter;
1057: char *file;
1058: struct stat *st;
1059: register struct FTAMdiagnostic **diags;
1060: {
1061: #ifndef BRIDGE
1062: int result;
1063: char *cp;
1064: register struct tm *tm;
1065: #endif
1066: register struct FTAMdiagnostic *dp = *diags;
1067:
1068: fa -> fa_present = attrnames;
1069: fa -> fa_novalue = attrnames & (FA_SECURITY | FA_PRIVATE);
1070:
1071: if (attrnames & FA_FILENAME) {
1072: fa -> fa_nfile = 0;
1073: fa -> fa_files[fa -> fa_nfile++] = file;
1074: }
1075:
1076: if (attrnames & FA_ACTIONS) {
1077: fa -> fa_permitted = 0;
1078: #ifndef BRIDGE
1079: if (EACCESS (file, R_OK) != NOTOK)
1080: #endif
1081: fa -> fa_permitted |= FA_PERM_READ;
1082:
1083: #ifndef BRIDGE
1084: if (EACCESS (file, W_OK) != NOTOK)
1085: #endif
1086: fa -> fa_permitted |= FA_PERM_WRITE;
1087:
1088: if (fa -> fa_permitted & (FA_PERM_READ | FA_PERM_WRITE))
1089: fa -> fa_permitted |= FA_PERM_TRAVERSAL;
1090:
1091: fa -> fa_permitted |= FA_PERM_READATTR;
1092:
1093: #ifndef BRIDGE
1094: if (myuid == st -> st_uid || myuid == 0)
1095: #endif
1096: fa -> fa_permitted |= FA_PERM_OWNER;
1097:
1098: #ifndef BRIDGE
1099: if (cp = rindex (file, '/')) {
1100: *cp = NULL;
1101: result = EACCESS (*file ? file : "/", W_OK);
1102: *cp = '/';
1103: }
1104: else
1105: result = EACCESS (".", W_OK);
1106: if (result != NOTOK)
1107: #endif
1108: fa -> fa_permitted |= FA_PERM_PARENT;
1109: }
1110:
1111: if (attrnames & FA_CONTENTS) {
1112: register struct vfsmap *vf;
1113:
1114: if (vf = st2vfs (myfd, file, st, proposed, ftamfd)) {
1115: fa -> fa_contents = vf -> vf_oid;
1116: if (proposed
1117: && oid_cmp (proposed, vf -> vf_oid) == 0
1118: && parameter
1119: && vf -> vf_number >= 0
1120: && vf -> vf_check) {
1121: caddr_t p = NULL;
1122:
1123: if (dec_f (vf -> vf_number, &_ZDOCS_mod, parameter, 1, NULLIP,
1124: NULLVP, &p) == NOTOK) {
1125: advise (LLOG_NOTICE, NULLCP,
1126: "unable to parse document type parameter: %s",
1127: PY_pepy);
1128: goto bad_param;
1129: }
1130: if ((*vf -> vf_check) (p, dp -> ftd_data) == NOTOK) {
1131: advise (LLOG_NOTICE, NULLCP,
1132: "unacceptable document type parameter: %s",
1133: dp -> ftd_data);
1134: goto bad_param;
1135: }
1136: fre_obj (p, _ZDOCS_mod.md_dtab[vf -> vf_number], &_ZDOCS_mod);
1137: fa -> fa_parameter = parameter;
1138: }
1139: bad_param: ;
1140:
1141: if (vf -> vf_parameter) {
1142: if (rdparam)
1143: pe_free (rdparam), rdparam = NULLPE;
1144:
1145: if (enc_f (vf -> vf_number, &_ZDOCS_mod, &rdparam, 1, 0,
1146: NULLCP, vf -> vf_parameter) == NOTOK) {
1147: advise (LLOG_EXCEPTIONS, NULLCP,
1148: "unable to build parameter: %s", PY_pepy);
1149: if (rdparam)
1150: pe_free (rdparam), rdparam = NULLPE;
1151: }
1152: fa -> fa_parameter = rdparam;
1153: }
1154: else
1155: fa -> fa_parameter = NULLPE;
1156: }
1157: else
1158: fa -> fa_present &= ~FA_CONTENTS;
1159: }
1160:
1161: #ifdef BRIDGE
1162: /* these values cannot be obtained from FTP */
1163: if (attrnames & FA_ACCOUNT)
1164: #else
1165: if ((attrnames & FA_ACCOUNT)
1166: && (fa -> fa_account = getgroup (st -> st_gid)) == NULL)
1167: #endif
1168: fa -> fa_present &= ~FA_ACCOUNT;
1169:
1170: if (attrnames & FA_DATE_CREATE)
1171: #ifndef BRIDGE
1172: if (tm = gmtime ((long *) &st -> st_mtime))
1173: tm2ut (tm, &fa -> fa_date_create);
1174: else
1175: #endif
1176: fa -> fa_novalue |= FA_DATE_CREATE;
1177:
1178: if (attrnames & FA_DATE_MODIFY)
1179: #ifndef BRIDGE
1180: if (tm = gmtime ((long *) &st -> st_mtime))
1181: tm2ut (tm, &fa -> fa_date_modify);
1182: else
1183: #endif
1184: fa -> fa_novalue |= FA_DATE_MODIFY;
1185:
1186: if (attrnames & FA_DATE_READ)
1187: #ifndef BRIDGE
1188: if (tm = gmtime ((long *) &st -> st_atime))
1189: tm2ut (tm, &fa -> fa_date_read);
1190: else
1191: #endif
1192: fa -> fa_novalue |= FA_DATE_READ;
1193:
1194: if (attrnames & FA_DATE_ATTR)
1195: #ifndef BRIDGE
1196: if (tm = gmtime ((long *) &st -> st_ctime))
1197: tm2ut (tm, &fa -> fa_date_attribute);
1198: else
1199: #endif
1200: fa -> fa_novalue |= FA_DATE_ATTR;
1201:
1202: #ifdef BRIDGE
1203: if (attrnames & FA_ID_CREATE)
1204: #else
1205: if ((attrnames & FA_ID_CREATE)
1206: && (fa -> fa_id_create = getuser (st -> st_uid)) == NULL)
1207: #endif
1208: fa -> fa_novalue |= FA_ID_CREATE;
1209:
1210: #ifdef BRIDGE
1211: if (attrnames & FA_ID_MODIFY)
1212: #else
1213: if ((attrnames & FA_ID_MODIFY)
1214: && ((st -> st_mode & 0022)
1215: || (fa -> fa_id_modify = getuser (st -> st_uid)) == NULL))
1216: #endif
1217: fa -> fa_novalue |= FA_ID_MODIFY;
1218:
1219: #ifdef BRIDGE
1220: if (attrnames & FA_ID_READ)
1221: #else
1222: if ((attrnames & FA_ID_READ)
1223: && ((st -> st_mode & 0044)
1224: || (fa -> fa_id_read = getuser (st -> st_uid)) == NULL))
1225: #endif
1226: fa -> fa_novalue |= FA_ID_READ;
1227:
1228: #ifdef BRIDGE
1229: if (attrnames & FA_ID_ATTR)
1230: #else
1231: if ((attrnames & FA_ID_ATTR)
1232: && ( (st -> st_mode & 0022)
1233: || (fa -> fa_id_attribute = getuser (st -> st_uid))
1234: == NULL))
1235: #endif
1236: fa -> fa_novalue |= FA_ID_ATTR;
1237:
1238: if (attrnames & FA_AVAILABILITY)
1239: fa -> fa_availability = FA_AVAIL_IMMED;
1240:
1241: if (attrnames & FA_FILESIZE)
1242: #ifdef BRIDGE
1243: fa -> fa_novalue |= FA_FILESIZE;
1244: #else
1245: fa -> fa_filesize = (int) st -> st_size;
1246: #endif
1247:
1248: if (attrnames & FA_FUTURESIZE)
1249: fa -> fa_novalue |= FA_FUTURESIZE;
1250:
1251: *diags = dp;
1252: return OK;
1253: }
1254:
1255: /* */
1256:
1257: static int chngattrs (present, fa, diags)
1258: long present;
1259: register struct FTAMattributes *fa;
1260: register struct FTAMdiagnostic **diags;
1261: {
1262: #ifndef BRIDGE
1263: int gid,
1264: result;
1265: #endif
1266: register struct FTAMdiagnostic *dp = *diags;
1267:
1268:
1269: #ifdef BRIDGE
1270: statok = 1;
1271: #else
1272: if ((myfd != NOTOK ? fstat (myfd, &myst) : stat (myfile, &myst))
1273: == NOTOK) {
1274: bad_system: ;
1275: (void) strcpy (dp -> ftd_data, sys_errname (errno));
1276: dp -> ftd_cc = strlen (dp -> ftd_data);
1277: goto no_change;
1278: }
1279: statok = 1;
1280: if (myuid != myst.st_uid && myuid != 0) {
1281: errno = EPERM;
1282: goto bad_system;
1283: }
1284: #endif
1285:
1286: #ifndef BRIDGE
1287: if ((present & FA_ACCOUNT)
1288: && (gid = findgid (fa -> fa_account)) != NOTOK) {
1289: #ifndef SYS5
1290: (void) seteuid (0);
1291: result = myfd != NOTOK ? fchown (myfd, -1, gid)
1292: : chown (myfile, -1, gid);
1293: (void) seteuid (myuid);
1294: #else
1295: result = chgrp (myfile, gid);
1296: #endif
1297:
1298: if (result == NOTOK) {
1299: (void) sprintf (dp -> ftd_data, "%s: %s", fa -> fa_account,
1300: sys_errname (errno));
1301: dp -> ftd_cc = strlen (dp -> ftd_data);
1302:
1303: no_change: ;
1304: dp -> ftd_type = DIAG_PERM;
1305: dp -> ftd_identifier = FS_MGT_CHANGE;
1306: dp -> ftd_observer = dp -> ftd_source = EREF_RFSU;
1307: dp -> ftd_delay = DIAG_NODELAY;
1308: dp++;
1309:
1310: *diags = dp;
1311: return NOTOK;
1312: }
1313:
1314: myst.st_gid = gid;
1315: }
1316: #endif
1317:
1318: if (present & FA_FILENAME) {
1319: #ifdef BRIDGE
1320: if (ftp_rename (myfile, mvfile) == NOTOK) {
1321: (void) sprintf (dp -> ftd_data, "%s: %s", fa -> fa_files[0],
1322: ftp_error);
1323: #else
1324: if (rename (myfile, mvfile) == NOTOK) { /* on EXDEV could do gonzo
1325: copy, but why bother? */
1326: (void) sprintf (dp -> ftd_data, "%s: %s", fa -> fa_files[0],
1327: sys_errname (errno));
1328: #endif
1329: dp -> ftd_cc = strlen (dp -> ftd_data);
1330: #ifndef BRIDGE
1331: goto no_change;
1332: #else
1333: dp -> ftd_type = DIAG_PERM;
1334: dp -> ftd_identifier = FS_MGT_CHANGE;
1335: dp -> ftd_observer = dp -> ftd_source = EREF_RFSU;
1336: dp -> ftd_delay = DIAG_NODELAY;
1337: dp++;
1338:
1339: *diags = dp;
1340: return NOTOK;
1341: #endif
1342: }
1343: advise (LLOG_NOTICE, NULLCP, "rename %s to %s", myfile, mvfile);
1344:
1345: myfile = mvfile;
1346: }
1347:
1348: *diags = dp;
1349: return OK;
1350: }
1351:
1352: /* */
1353:
1354: static char *getfile (file)
1355: char *file;
1356: {
1357: register char *bp;
1358: #ifndef BRIDGE
1359: register char *cp,
1360: *pp;
1361: register struct passwd *pw;
1362: #endif
1363: static int i = 0;
1364: static char buffer1[MAXPATHLEN],
1365: buffer2[MAXPATHLEN];
1366:
1367: bp = (i++ % 2) ? buffer1 : buffer2;
1368:
1369: #ifndef BRIDGE
1370: switch (*file) {
1371: case '/':
1372: if (strlen (file) >= MAXPATHLEN)
1373: goto trunc;
1374:
1375: (void) strcpy (bp, file);
1376: break;
1377:
1378: case '~':
1379: if (cp = index (pp = file + 1, '/'))
1380: *cp = NULL;
1381:
1382: if (*pp == NULL)
1383: pp = myhome;
1384: else {
1385: if ((pw = getpwnam (pp)) == NULL)
1386: return NULL;
1387: else
1388: pp = pw -> pw_dir;
1389: }
1390:
1391: if (strlen (pp) + 1 + (cp ? strlen (cp) : 0) >= MAXPATHLEN)
1392: goto trunc;
1393:
1394: (void) sprintf (bp, "%s/%s", pp, cp ? cp + 1 : "");
1395: if (cp)
1396: *cp = '/';
1397: break;
1398:
1399: default:
1400: if (strlen (file) + myhomelen + 1 >= MAXPATHLEN)
1401: goto trunc;
1402:
1403: (void) sprintf (bp, "%s/%s", myhome, file);
1404: break;
1405: }
1406:
1407: compath (bp);
1408:
1409: #ifndef apollo /* always return RELATIVE pathnames */
1410: if (strncmp (bp, myhome, myhomelen - 1) == 0)
1411: switch (bp[myhomelen - 1]) {
1412: case NULL:
1413: (void) strcpy (bp, ".");
1414: break;
1415:
1416: case '/':
1417: bp += myhomelen;
1418: break;
1419:
1420: default:
1421: break;
1422: }
1423: #endif
1424:
1425: return bp;
1426:
1427: trunc: ;
1428: errno = 0;
1429: return NULLCP;
1430: #else
1431: (void) strcpy (bp, file);
1432: return bp;
1433: #endif
1434: }
1435:
1436: /* */
1437:
1438: #ifndef BRIDGE
1439: /* originally used algorithms similar to those in /bin/ls; Don Preuss of
1440: Apollo suggested these algorithms as they work better with distributed
1441: /etc/passwd and /etc/group files */
1442:
1443: static char *getuser (uid)
1444: int uid;
1445: {
1446: static struct passwd *pw = NULL;
1447:
1448: if (pw == NULL || pw -> pw_uid != uid)
1449: pw = getpwuid (uid);
1450: return (pw ? pw -> pw_name : NULL);
1451: }
1452:
1453: /* */
1454:
1455: static char *getgroup (gid)
1456: int gid;
1457: {
1458: register struct group *gr;
1459: static int my_gid = -1;
1460: static char my_name[NMAX + 1];
1461:
1462: if (my_gid != gid) {
1463: if ((gr = getgrgid (gid)) == NULL)
1464: return NULL;
1465:
1466: my_gid = gr -> gr_gid;
1467: (void) strcpy (my_name, gr -> gr_name);
1468: }
1469:
1470: return my_name;
1471: }
1472:
1473: /* */
1474:
1475: int findgid (group)
1476: char *group;
1477: {
1478: int i;
1479: #ifdef BSD42
1480: int gidset[NGROUPS];
1481: #endif
1482: register struct group *gr;
1483: static int my_gid = -1;
1484: static char my_name[NMAX + 1] = "";
1485:
1486: if (*group == NULL)
1487: return NOTOK;
1488:
1489: if (strcmp (my_name, group) != 0) {
1490: if ((gr = getgrnam (group)) == NULL)
1491: return NOTOK;
1492:
1493: #ifdef BSD42
1494: for (i = getgroups (NGROUPS, gidset) - 1; i >= 0; i--)
1495: if (gr -> gr_gid == gidset[i])
1496: break;
1497: if (i < 0)
1498: return NOTOK;
1499: #endif
1500:
1501: (void) strcpy (my_name, gr -> gr_name);
1502: my_gid = gr -> gr_gid;
1503: }
1504:
1505: return my_gid;
1506: }
1507: #endif
1508:
1509: /* */
1510:
1511: #ifndef SYS5
1512: #ifndef BRIDGE
1513: static int EACCESS (file, mode)
1514: char *file;
1515: int mode;
1516: {
1517: int result;
1518:
1519: (void) seteuid (0);
1520: (void) setruid (myuid);
1521:
1522: result = access (file, mode);
1523:
1524: (void) setruid (0);
1525: (void) seteuid (myuid);
1526:
1527: return result;
1528: }
1529: #endif
1530: #else
1531:
1532: /* */
1533:
1534: static int chgrp (file, gid)
1535: char *file;
1536: int gid;
1537: {
1538: int i,
1539: pid,
1540: status;
1541: char group[10];
1542: struct stat st;
1543:
1544: (void) sprintf (group, "%d", gid);
1545:
1546: switch (pid = fork ()) {
1547: case NOTOK:
1548: return NOTOK;
1549:
1550: case OK:
1551: execl ("/bin/chgrp", "chgrp", group, file, NULLCP);
1552: execl ("/usr/bin/chgrp", "chgrp", group, file, NULLCP);
1553: execl ("/etc/chgrp", "chgrp", group, file, NULLCP);
1554: _exit (NOTOK);
1555:
1556: default:
1557: while ((i = wait (&status)) != NOTOK && pid != i)
1558: continue;
1559: if (i != NOTOK && status) {
1560: if (stat (file, &st) == NOTOK || st.st_gid != gid) {
1561: i = NOTOK;
1562: errno = EACCES;
1563: }
1564: else
1565: status = OK;
1566: }
1567: return (i == NOTOK ? NOTOK : status);
1568: }
1569: }
1570:
1571: /* */
1572:
1573: static int mkdir (dir, mode)
1574: char *dir;
1575: int mode;
1576: {
1577: int i,
1578: pid,
1579: status;
1580: struct stat st;
1581:
1582: switch (pid = fork ()) {
1583: case NOTOK:
1584: return NOTOK;
1585:
1586: case OK:
1587: (void) umask (~mode);
1588: execl ("/bin/mkdir", "mkdir", dir, NULLCP);
1589: execl ("/usr/bin/mkdir", "mkdir", dir, NULLCP);
1590: execl ("/etc/mkdir", "mkdir", dir, NULLCP);
1591: _exit (NOTOK);
1592:
1593: default:
1594: while ((i = wait (&status)) != NOTOK && pid != i)
1595: continue;
1596: if (i != NOTOK && status) {
1597: if (stat (dir, &st) == NOTOK
1598: || (st.st_mode & S_IFMT) != S_IFDIR) {
1599: i = NOTOK;
1600: errno = EACCES;
1601: }
1602: else
1603: status = OK;
1604: }
1605: return (i == NOTOK ? NOTOK : status);
1606: }
1607: }
1608:
1609: /* */
1610:
1611: static int rmdir (dir)
1612: char *dir;
1613: {
1614: int i,
1615: pid,
1616: status;
1617:
1618: switch (pid = fork ()) {
1619: case NOTOK:
1620: return NOTOK;
1621:
1622: case OK:
1623: execl ("/bin/rmdir", "rmdir", dir, NULLCP);
1624: execl ("/usr/bin/rmdir", "rmdir", dir, NULLCP);
1625: execl ("/etc/rmdir", "rmdir", dir, NULLCP);
1626: _exit (NOTOK);
1627:
1628: default:
1629: while ((i = wait (&status)) != NOTOK && pid != i)
1630: continue;
1631: if (i != NOTOK && status) {
1632: if (access (dir, 0x00) != NOTOK) {
1633: i = NOTOK;
1634: errno = EACCES;
1635: }
1636: else
1637: status = OK;
1638: }
1639: return (i == NOTOK ? NOTOK : status);
1640: }
1641: }
1642:
1643: /* */
1644:
1645: static int truncate (file, length)
1646: char *file;
1647: int length;
1648: {
1649: int fd;
1650:
1651: if (length != 0) { /* XXX: too much work to get right */
1652: errno = EINVAL;
1653: return NOTOK;
1654: }
1655:
1656: if ((fd = open (file, O_WRONLY | O_TRUNC)) == NOTOK)
1657: return NOTOK;
1658:
1659: (void) close (fd);
1660: return OK;
1661: }
1662:
1663:
1664: /* ARGSUSED */
1665:
1666: int ftruncate (fd, length) /* works only 'cause we're lucky */
1667: int fd,
1668: length;
1669: {
1670: return truncate (myfile, length);
1671: }
1672: #endif
1673:
1674: /* DEBUG */
1675:
1676: #if defined(FTAMDEBUG) && defined(BSD42)
1677: #include <syscall.h>
1678:
1679:
1680: static int unlink (file)
1681: char *file;
1682: {
1683: if (debug) {
1684: int i,
1685: b;
1686:
1687: again: ;
1688: fprintf (stderr, "unlink(\"%s\")? y, w, l: ", file);
1689:
1690: i = b = getchar ();
1691: while (b != '\n' && b != EOF)
1692: b = getchar ();
1693:
1694: switch (i) {
1695: case 'y':
1696: break;
1697:
1698: case 'w':
1699: return OK;
1700:
1701: case 'l':
1702: return NOTOK;
1703:
1704: default:
1705: goto again;
1706: }
1707: }
1708:
1709: return syscall (SYS_unlink, file);
1710: }
1711:
1712:
1713: static int rmdir (dir)
1714: char *dir;
1715: {
1716: if (debug) {
1717: int i,
1718: b;
1719:
1720: again: ;
1721: fprintf (stderr, "rmdir(\"%s\")? y, w, l: ", dir);
1722:
1723: i = b = getchar ();
1724: while (b != '\n' && b != EOF)
1725: b = getchar ();
1726:
1727: switch (i) {
1728: case 'y':
1729: break;
1730:
1731: case 'w':
1732: return OK;
1733:
1734: case 'l':
1735: return NOTOK;
1736:
1737: default:
1738: goto again;
1739: }
1740: }
1741:
1742: return syscall (SYS_rmdir, dir);
1743: }
1744:
1745:
1746: /* VARARGS2 */
1747:
1748: static int open (file, flags, mode)
1749: char *file;
1750: int flags,
1751: mode;
1752: {
1753: if (debug) {
1754: int i,
1755: b;
1756:
1757: again: ;
1758: fprintf (stderr, "open(\"%s\",0x%x,0%o)? y, l: ", file, flags,
1759: (flags & O_CREAT) ? mode : 0);
1760:
1761: i = b = getchar ();
1762: while (b != '\n' && b != EOF)
1763: b = getchar ();
1764:
1765: switch (i) {
1766: case 'y':
1767: break;
1768:
1769: case 'l':
1770: return NOTOK;
1771:
1772: default:
1773: goto again;
1774: }
1775: }
1776:
1777: return syscall (SYS_open, file, flags, mode);
1778: }
1779:
1780:
1781: static int mkdir (dir, mode)
1782: char *dir;
1783: int mode;
1784: {
1785: if (debug) {
1786: int i,
1787: b;
1788:
1789: again: ;
1790: fprintf (stderr, "mkdir(\"%s\",0%o)? y, w, l: ", dir, mode);
1791:
1792: i = b = getchar ();
1793: while (b != '\n' && b != EOF)
1794: b = getchar ();
1795:
1796: switch (i) {
1797: case 'y':
1798: break;
1799:
1800: case 'w':
1801: return OK;
1802:
1803: case 'l':
1804: return NOTOK;
1805:
1806: default:
1807: goto again;
1808: }
1809: }
1810:
1811: return syscall (SYS_mkdir, dir, mode);
1812: }
1813:
1814:
1815: static int chown (file, uid, gid)
1816: char *file;
1817: int uid,
1818: gid;
1819: {
1820: if (debug) {
1821: int i,
1822: b;
1823:
1824: again: ;
1825: fprintf (stderr, "chown(\"%s\",%d,%d)? y, w, l: ", file, uid, gid);
1826:
1827: i = b = getchar ();
1828: while (b != '\n' && b != EOF)
1829: b = getchar ();
1830:
1831: switch (i) {
1832: case 'y':
1833: break;
1834:
1835: case 'w':
1836: return OK;
1837:
1838: case 'l':
1839: return NOTOK;
1840:
1841: default:
1842: goto again;
1843: }
1844: }
1845:
1846: return syscall (SYS_chown, file, uid, gid);
1847: }
1848:
1849:
1850: static int fchown (fd, uid, gid)
1851: int fd;
1852: int uid,
1853: gid;
1854: {
1855: if (debug) {
1856: int i,
1857: b;
1858:
1859: again: ;
1860: fprintf (stderr, "fchown(%d,%d,%d)? y, w, l: ", fd, uid, gid);
1861:
1862: i = b = getchar ();
1863: while (b != '\n' && b != EOF)
1864: b = getchar ();
1865:
1866: switch (i) {
1867: case 'y':
1868: break;
1869:
1870: case 'w':
1871: return OK;
1872:
1873: case 'l':
1874: return NOTOK;
1875:
1876: default:
1877: goto again;
1878: }
1879: }
1880:
1881: return syscall (SYS_fchown, fd, uid, gid);
1882: }
1883:
1884:
1885: static int truncate (file, length)
1886: char *file;
1887: int length;
1888: {
1889: if (debug) {
1890: int i,
1891: b;
1892:
1893: again: ;
1894: fprintf (stderr, "truncate(\"%s\",%d)? y, w, l: ", file, length);
1895:
1896: i = b = getchar ();
1897: while (b != '\n' && b != EOF)
1898: b = getchar ();
1899:
1900: switch (i) {
1901: case 'y':
1902: break;
1903:
1904: case 'w':
1905: return OK;
1906:
1907: case 'l':
1908: return NOTOK;
1909:
1910: default:
1911: goto again;
1912: }
1913: }
1914:
1915: return syscall (SYS_truncate, file, length);
1916: }
1917:
1918:
1919: static int rename (old, new)
1920: char *old;
1921: char *new;
1922: {
1923: if (debug) {
1924: int i,
1925: b;
1926:
1927: again: ;
1928: fprintf (stderr, "rename(\"%s\",\"%s\")? y, w, l: ", old, new);
1929:
1930: i = b = getchar ();
1931: while (b != '\n' && b != EOF)
1932: b = getchar ();
1933:
1934: switch (i) {
1935: case 'y':
1936: break;
1937:
1938: case 'w':
1939: return OK;
1940:
1941: case 'l':
1942: return NOTOK;
1943:
1944: default:
1945: goto again;
1946: }
1947: }
1948:
1949: return syscall (SYS_rename, old, new);
1950: }
1951:
1952:
1953: static int flock (fd, operation)
1954: int fd,
1955: operation;
1956: {
1957: if (debug) {
1958: int i,
1959: b;
1960:
1961: again: ;
1962: fprintf (stderr, "flock(%d,0x%x)? y, w, l: ", fd, operation);
1963:
1964: i = b = getchar ();
1965: while (b != '\n' && b != EOF)
1966: b = getchar ();
1967:
1968: switch (i) {
1969: case 'y':
1970: break;
1971:
1972: case 'w':
1973: return OK;
1974:
1975: case 'l':
1976: return NOTOK;
1977:
1978: default:
1979: goto again;
1980: }
1981: }
1982:
1983: return syscall (SYS_flock, fd, operation);
1984: }
1985: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.