![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ftamsbr.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 ftamsbr.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / ftam2 |
1.1 root 1: /* ftamsbr.c - FTAM subroutines */
2:
3: #ifndef lint
4: static char *rcsid = "$Header: /f/osi/ftam2/RCS/ftamsbr.c,v 7.1 90/07/01 21:03:31 mrose Exp $";
5: #endif
6:
7: /*
8: * $Header: /f/osi/ftam2/RCS/ftamsbr.c,v 7.1 90/07/01 21:03:31 mrose Exp $
9: *
10: *
11: * $Log: ftamsbr.c,v $
12: * Revision 7.1 90/07/01 21:03:31 mrose
13: * pepsy
14: *
15: * Revision 7.0 89/11/23 21:54:37 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 <ctype.h>
32: #include <stdio.h>
33: #include "ftamsbr.h"
34:
35: #ifdef BRIDGE
36: extern int vfs_fdf;
37: #endif
38:
39: extern struct vfsmap vfs[];
40:
41: /* */
42:
43: #ifdef BRIDGE
44: /* ARGSUSED */
45: #endif
46:
47: struct vfsmap *st2vfs (fd, file, st, proposed, ftamfd)
48: int fd;
49: char *file;
50: struct stat *st;
51: OID proposed;
52: int ftamfd;
53: {
54: #ifndef BRIDGE
55: register int fmt;
56: register struct vfsmap *lf;
57: #endif
58: register struct vfsmap *vf;
59:
60: #ifndef BRIDGE
61: fmt = st -> st_mode & S_IFMT;
62: #else
63: /* Return the suggested TYPE or Unstructured Text type for FTP bridge */
64: /* if during ftp_exist got multiple listing, return directory type */
65: if (ftp_directory)
66: return &vfs[vfs_fdf];
67: #endif
68:
69: if (proposed) {
70: for (vf = vfs; vf -> vf_entry; vf++)
71: if (vf -> vf_oid && oid_cmp (vf -> vf_oid, proposed) == 0) {
72: #ifdef BRIDGE
73: return vf;
74: }
75: #else
76: if ((vf -> vf_flags & VF_OK) && vf -> vf_mode == fmt) {
77: if (vf -> vf_peek
78: && (*vf -> vf_peek) (vf, fd, file, st, ftamfd)
79: == NOTOK)
80: break;
81:
82: return vf;
83: }
84:
85: break;
86: }
87:
88: if (!vf -> vf_entry)
89: return NULL;
90: #endif
91: }
92: #ifndef BRIDGE
93: else {
94: for (lf = vfs; lf -> vf_entry; lf++)
95: continue;
96: lf--;
97:
98: for (vf = lf; vf >= vfs; vf--)
99: if ((vf -> vf_flags & VF_OK) && vf -> vf_mode == fmt) {
100: if (vf -> vf_peek
101: && (*vf -> vf_peek) (vf, fd, file, st, ftamfd) != DONE)
102: continue;
103:
104: return vf;
105: }
106:
107: for (vf = lf; vf >= vfs; vf--)
108: if ((vf -> vf_flags & VF_OK)
109: && vf -> vf_mode == fmt
110: && vf -> vf_simplify != VFS_XXX)
111: break;
112: if (vf < vfs)
113: return NULL;
114: }
115:
116: /* let's hope there aren't any simplification loops! */
117:
118: while (vf -> vf_simplify != VFS_XXX) {
119: vf = &vfs[vf -> vf_simplify];
120:
121: if (vf -> vf_flags & VF_OK) {
122: if (vf -> vf_peek)
123: (void) (*vf -> vf_peek) (vf, fd, file, st, ftamfd);
124: return vf;
125: }
126: }
127:
128: return NULL;
129: #else
130: return &vfs[ftp_default];
131: #endif
132: }
133:
134: /* */
135:
136: int binarycheck (param, data)
137: caddr_t param;
138: char *data;
139: {
140: register struct type_DOCS_FTAM__3__Parameters *p3 =
141: (struct type_DOCS_FTAM__3__Parameters *) param;
142:
143: if (p3 -> optionals
144: & opt_DOCS_FTAM__3__Parameters_maximum__string__length) {
145: if (getenv ("UNISYS-FTAM"))
146: p3 -> maximum__string__length = 0;
147: else
148: p3 -> optionals &=
149: ~opt_DOCS_FTAM__3__Parameters_maximum__string__length;
150: }
151:
152: if ((p3 -> optionals
153: & opt_DOCS_FTAM__3__Parameters_string__significanz)
154: && p3 -> string__significanz
155: == int_DOCS_string__significanz_fixed) {
156: (void) strcpy (data,
157: "filestore does not support fixed-length strings");
158: return NOTOK;
159: }
160:
161:
162: return OK;
163: }
164:
165: /* */
166:
167: int textcheck (param, data)
168: caddr_t param;
169: char *data;
170: {
171: register struct type_DOCS_FTAM__1__Parameters *p1 =
172: (struct type_DOCS_FTAM__1__Parameters *) param;
173:
174: if (!(p1 -> optionals
175: & opt_DOCS_FTAM__1__Parameters_universal__class__number)) {
176: p1 -> optionals |= opt_DOCS_FTAM__1__Parameters_universal__class__number;
177: p1 -> universal__class__number = PE_DEFN_GENS;
178: }
179: switch (p1 -> universal__class__number) {
180: case PE_DEFN_GFXS:
181: case PE_DEFN_IA5S:
182: case PE_DEFN_GENS:
183: break;
184:
185: default:
186: (void) sprintf (data,
187: "filestore does not support strings of universal class number %d",
188: p1 -> universal__class__number);
189: return NOTOK;
190: }
191:
192: if (p1 -> optionals
193: & opt_DOCS_FTAM__1__Parameters_maximum__string__length) {
194: if (getenv ("UNISYS-FTAM")) {
195: p1 -> maximum__string__length = 0;
196: }
197: else
198: p1 -> optionals &=
199: ~opt_DOCS_FTAM__1__Parameters_maximum__string__length;
200: }
201:
202: if ((p1 -> optionals
203: & opt_DOCS_FTAM__1__Parameters_string__significance)
204: && p1 -> string__significance
205: == int_DOCS_string__significance_fixed) {
206: (void) strcpy (data,
207: "filestore does not support fixed-length strings");
208: return NOTOK;
209: }
210:
211:
212: return OK;
213: }
214:
215: /* */
216:
217: /* ARGSUSED */
218:
219: int binarypeek (vf, fd, file, st, ftamfd)
220: register struct vfsmap *vf;
221: int fd;
222: char *file;
223: struct stat *st;
224: int ftamfd;
225: {
226: static struct type_DOCS_FTAM__3__Parameters p3s;
227: register struct type_DOCS_FTAM__3__Parameters *p3 = &p3s;
228:
229: if (vf -> vf_parameter && (vf -> vf_flags & VF_PARM))
230: fre_obj (vf -> vf_parameter, _ZDOCS_mod.md_dtab[vf -> vf_number],
231: &_ZDOCS_mod);
232:
233: vf -> vf_parameter = (caddr_t) p3, vf -> vf_flags &= ~VF_PARM;
234:
235: p3 -> optionals = 0;
236:
237: if (getenv ("UNISYS-FTAM")) {
238: p3 -> optionals |=opt_DOCS_FTAM__3__Parameters_maximum__string__length;
239: p3 -> maximum__string__length = 0;
240: }
241:
242: p3 -> optionals |= opt_DOCS_FTAM__3__Parameters_string__significanz;
243: p3 -> string__significanz = int_DOCS_string__significanz_not__significant;
244:
245: return DONE;
246: }
247:
248: /* */
249:
250: /* Various textual repetories. In addition to the prohibited characters, on
251: UNIX we disallow CRs. This avoids funny CR-LF mappings. */
252:
253: /* Here's the assumptions we make for whether format-effectors are used:
254:
255: PrintableString - no
256: TeletexString - yes
257: VideotexString - yes (?)
258: IA5String - yes
259: GraphicString - no (?)
260: VisibleString - no (?)
261: GeneralString - yes (?)
262:
263: */
264:
265:
266: #define isIA5(c) (isprint (c) || (isspace (c) && (c) != '\r'))
267:
268:
269: /* ARGSUSED */
270:
271: int textpeek (vf, fd, file, st, ftamfd)
272: register struct vfsmap *vf;
273: int fd;
274: char *file;
275: struct stat *st;
276: int ftamfd;
277: {
278: #ifndef BRIDGE
279: int gd,
280: n;
281: register char *cp;
282: char buffer[BLKSIZE];
283: long pos;
284: #endif
285: static struct type_DOCS_FTAM__1__Parameters p1s;
286: register struct type_DOCS_FTAM__1__Parameters *p1 = &p1s;
287:
288: if (vf -> vf_parameter && (vf -> vf_flags & VF_PARM))
289: fre_obj (vf -> vf_parameter, _ZDOCS_mod.md_dtab[vf -> vf_number],
290: &_ZDOCS_mod);
291:
292: vf -> vf_parameter = (caddr_t) p1, vf -> vf_flags &= ~VF_PARM;
293:
294: p1 -> optionals = 0;
295:
296: p1 -> optionals |= opt_DOCS_FTAM__1__Parameters_universal__class__number;
297: p1 -> universal__class__number = PE_DEFN_GENS;
298:
299: if (getenv ("UNISYS-FTAM")) {
300: p1 -> optionals |=opt_DOCS_FTAM__1__Parameters_maximum__string__length;
301: p1 -> maximum__string__length = 0;
302: }
303:
304: p1 -> optionals |= opt_DOCS_FTAM__1__Parameters_string__significance;
305: switch (p1 -> universal__class__number) {
306: case PE_DEFN_GFXS:
307: if (getenv ("HP-FTAM")) {
308: p1 -> string__significance =
309: int_DOCS_string__significance_not__significant;
310: break;
311: } /* else fall... */
312: case PE_DEFN_PRTS:
313: case PE_DEFN_VISS:
314: p1 -> string__significance =
315: int_DOCS_string__significance_variable;
316: break;
317:
318: case PE_DEFN_T61S:
319: case PE_DEFN_VTXS:
320: case PE_DEFN_IA5S:
321: case PE_DEFN_GENS:
322: p1 -> string__significance =
323: int_DOCS_string__significance_not__significant;
324: break;
325: }
326:
327: #ifndef BRIDGE
328: if ((gd = fd) == NOTOK
329: && (file == NULLCP || (gd = open (file, O_RDONLY)) == NOTOK))
330: return OK;
331:
332: if (fd != NOTOK) {
333: pos = lseek (gd, 0L, L_INCR);
334: (void) lseek (gd, 0L, L_SET);
335: }
336: #ifndef MAXBSIZE
337: n = read (gd, buffer, sizeof buffer);
338: #else
339: n = 0 < st -> st_blksize && st -> st_blksize <= sizeof buffer
340: ? st -> st_blksize : sizeof buffer;
341: n = read (gd, buffer, n);
342: #endif
343: if (fd != NOTOK && pos != -1L)
344: (void) lseek (gd, pos, L_SET);
345:
346: if (fd == NOTOK)
347: (void) close (gd);
348:
349: for (cp = buffer + n - 1; cp >= buffer; cp--)
350: if (!isIA5 (*cp))
351: return NOTOK;
352: return DONE;
353: #else
354: return OK;
355: #endif
356: }
357:
358: /* */
359:
360: /* ARGSUSED */
361:
362: int fdfpeek (vf, fd, file, st, ftamfd)
363: register struct vfsmap *vf;
364: int fd;
365: char *file;
366: struct stat *st;
367: int ftamfd;
368: {
369: struct type_DOCS_NBS__9__Parameters *p9;
370: struct FTAMindication ftis;
371:
372: if (vf -> vf_parameter && (vf -> vf_flags & VF_PARM))
373: fre_obj (vf -> vf_parameter, _ZDOCS_mod.md_dtab[vf -> vf_number],
374: &_ZDOCS_mod);
375:
376: vf -> vf_parameter = NULLCP, vf -> vf_flags &= ~VF_PARM;
377:
378: if (fdf_names2p (ftamfd, FA_RDATTR, &p9, &ftis) == NOTOK)
379: return NOTOK;
380:
381: vf -> vf_parameter = (caddr_t) p9;
382:
383: return DONE;
384: }
385:
386: /* */
387:
388: /* If text, then need to worry about ESCape sequences for the various
389: repetoires (thank you, Digital!) For now, we'll recognize G0 and G1 from
390: the 8859-1 (latin) alphabet. Note that when sending a file, we do not
391: generate escape sequences...
392: */
393:
394:
395: int de2fd (fd, pe, text, effector)
396: int fd;
397: PE pe;
398: int text,
399: effector;
400: {
401: register int i,
402: n;
403: register char *bp,
404: *cp,
405: *ep;
406: register PE p;
407:
408: if (pe -> pe_form == PE_FORM_CONS) {
409: for (p = pe -> pe_cons, n = 0; p; p = p -> pe_next, n += i)
410: if ((i = de2fd (fd, p, text, 1)) == NOTOK)
411: return NOTOK;
412: goto outside;
413: }
414:
415: if (!text) {
416: n = pe -> pe_len;
417: if (write (fd, (char *) pe -> pe_prim, n) != n)
418: return NOTOK;
419: goto outside;
420: }
421:
422: n = 0;
423: cp = (char *) pe -> pe_prim;
424: for (ep = (bp = cp) + pe -> pe_len; bp < ep;)
425: switch (*bp) {
426: #ifndef BRIDGE
427: case '\r':
428: if (!effector) {
429: bp++;
430: break;
431: }
432: *bp++ = '\n';
433: i = bp - cp;
434: if (write (fd, cp, i) != i)
435: return NOTOK;
436: cp = ++bp, n += i;
437: break;
438: #endif
439:
440: case 033:
441: switch (*++bp) {
442: case 0x28: /* G0: 02/08 04/02 */
443: if (*++bp == 0x42) {
444: register char *dp;
445:
446: write_it: ;
447: dp = bp - 2;
448: if ((i = (dp - cp)) > 0
449: && write (fd, cp, i) != i)
450: return NOTOK;
451: cp = ++bp, n += i;
452: }
453: else
454: bp--;
455: break;
456:
457: case 0x2d: /* G1: 02/13 04/01 */
458: if (*++bp == 0x41)
459: goto write_it;
460: else
461: bp--;
462: break;
463:
464: default: /* unknown, pass it on... */
465: break;
466: }
467: break;
468:
469: default:
470: bp++;
471: break;
472: }
473:
474: if (i = bp - cp) {
475: if (write (fd, cp, i) != i)
476: return NOTOK;
477:
478: n += i;
479: }
480:
481: outside: ;
482: if (text && !effector) {
483: #ifndef BRIDGE
484: if (write (fd, "\n", 1) != 1)
485: #else
486: if (write (fd, "\r\n", 2) != 2)
487: #endif
488: return NOTOK;
489: }
490:
491: return n;
492: }
493:
494: /* */
495:
496: /* right from MH's sbr/path.c... */
497:
498: #define CWD "./"
499: #define NCWD (sizeof CWD - 1)
500: #define DOT "."
501: #define DOTDOT ".."
502: #define PWD "../"
503: #define NPWD (sizeof PWD - 1)
504:
505:
506: int compath (f)
507: register char *f;
508: {
509: register char *cp,
510: *dp;
511:
512: if (*f != '/')
513: return;
514:
515: for (cp = f; *cp;)
516: if (*cp == '/') {
517: switch (*++cp) {
518: case NULL:
519: if (--cp > f)
520: *cp = NULL;
521: break;
522:
523: case '/':
524: #ifdef apollo
525: if ((f+1) == cp) {
526: cp++;
527: continue;
528: }
529: #endif
530: for (dp = cp; *dp == '/'; dp++)
531: continue;
532: (void) strcpy (cp--, dp);
533: continue;
534:
535: case '.':
536: if (strcmp (cp, DOT) == 0) {
537: if (cp > f + 1)
538: cp--;
539: *cp = NULL;
540: break;
541: }
542: if (strcmp (cp, DOTDOT) == 0) {
543: for (cp -= 2; cp > f; cp--)
544: if (*cp == '/')
545: break;
546: if (cp <= f)
547: cp = f + 1;
548: *cp = NULL;
549: break;
550: }
551: if (strncmp (cp, PWD, NPWD) == 0) {
552: for (dp = cp - 2; dp > f; dp--)
553: if (*dp == '/')
554: break;
555: if (dp <= f)
556: dp = f;
557: (void) strcpy (dp, cp + NPWD - 1);
558: cp = dp;
559: continue;
560: }
561: if (strncmp (cp, CWD, NCWD) == 0) {
562: (void) strcpy (cp - 1, cp + NCWD - 1);
563: cp--;
564: continue;
565: }
566: continue;
567:
568: default:
569: cp++;
570: continue;
571: }
572: break;
573: }
574: else
575: cp++;
576: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.