Return to file_print.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / dsap / common

Annotation of 43BSDReno/contrib/isode-beta/dsap/common/file_print.c, revision 1.1

1.1     ! root        1: #include "quipu/util.h"
        !             2: #include "quipu/attrvalue.h"
        !             3: #include "quipu/malloc.h"
        !             4: 
        !             5: char * parse_file = NULLCP;
        !             6: RDN parse_rdn = NULLRDN;
        !             7: extern LLog * log_dsap;
        !             8: extern AttributeType last_at;
        !             9: 
        !            10: #ifdef SYS5
        !            11: static char used_temp;
        !            12: #else
        !            13: /* ARGSUSED */
        !            14: #endif
        !            15: 
        !            16: int dflt_attr_file (at,x,full)
        !            17: AttributeType  at;
        !            18: AttributeValue x;
        !            19: char full;
        !            20: {
        !            21:        /* make default file name */
        !            22: char buffer [LINESIZE];
        !            23: PS sps;
        !            24: char *pathend = NULLCP;
        !            25: char val, *_isodefile();
        !            26: char *path = NULLCP;
        !            27: struct file_syntax * fs;
        !            28: unsigned last_heap;
        !            29: 
        !            30:        fs = (struct file_syntax *) x->av_struct;
        !            31: 
        !            32:        if ((parse_file != NULLCP) && ((pathend = rindex (parse_file,'/')) != NULLCP)) {
        !            33:                val = *++pathend;
        !            34:                *pathend = 0;
        !            35:                path = parse_file;
        !            36:        }
        !            37: 
        !            38:        last_heap = mem_heap;   /* put PS on general heap */
        !            39:        mem_heap = 0;
        !            40: 
        !            41:        sps = ps_alloc (str_open);
        !            42:        if (str_setup (sps,buffer,LINESIZE,1) == NOTOK) {
        !            43:                mem_heap = last_heap;
        !            44:                ps_free (sps);
        !            45:                return (NOTOK);
        !            46:        }
        !            47:        mem_heap = last_heap;
        !            48: 
        !            49:        if (parse_rdn == NULLRDN) 
        !            50:                ps_print (sps,at->oa_ot.ot_name);
        !            51:        else {
        !            52:                rdn_print (sps,parse_rdn,EDBOUT);
        !            53:                ps_printf (sps,".%s",at->oa_ot.ot_name);
        !            54:        }
        !            55:        *sps->ps_ptr = 0;
        !            56:        ps_free (sps);
        !            57: 
        !            58: 
        !            59: #ifdef SYS5
        !            60:        used_temp = FALSE;
        !            61:        if ((full) && (strlen(buffer) > MAXFILENAMELEN)) {
        !            62:                char *nptr, *mptr;
        !            63:                char nbuf [LINESIZE];
        !            64:                int i;
        !            65: 
        !            66:                nptr = buffer;
        !            67:                mptr = nbuf;            
        !            68:                used_temp = TRUE;
        !            69: 
        !            70:                for (i=0 ; (*nptr!=0) && (i < MAXFILENAMELEN-6) ; nptr++)
        !            71:                        if (isalpha(*nptr))
        !            72:                                *mptr++ = *nptr, i++;
        !            73: 
        !            74:                strcpy (mptr,"XXXXXX");
        !            75:                if (path != NULLCP)
        !            76:                        fs->fs_name = mktemp(strdup (_isodefile(path,nbuf)));
        !            77:                else
        !            78:                        fs->fs_name = mktemp(strdup (nbuf));
        !            79:                if (pathend != NULLCP)
        !            80:                        *pathend = val;
        !            81: 
        !            82:                fs->fs_mode = 0;
        !            83:                return (OK);
        !            84:        } 
        !            85: #endif
        !            86: 
        !            87:        if (path != NULLCP)
        !            88:                fs->fs_name = strdup (_isodefile(path,buffer));
        !            89:        else
        !            90:                fs->fs_name = strdup (buffer);
        !            91:        if (pathend != NULLCP)
        !            92:                *pathend = val;
        !            93: 
        !            94:        return (OK);
        !            95: }
        !            96: 
        !            97: 
        !            98: 
        !            99: fileattr_print (ps,y,format)
        !           100: PS ps;
        !           101: AttributeValue y;
        !           102: int format;
        !           103: {
        !           104: struct file_syntax * fs;
        !           105: int um;
        !           106: 
        !           107:        fs = (struct file_syntax *) y->av_struct;
        !           108: 
        !           109:        if (format != EDBOUT) 
        !           110:                AttrV_print (ps,fs->fs_attr,format);
        !           111:        else {
        !           112:                FILE * fptr;
        !           113:                PS fps;
        !           114: 
        !           115:                ps_print (ps,"{FILE}");
        !           116: 
        !           117:                if (fs->fs_name == NULLCP) {
        !           118:                        if (dflt_attr_file (last_at,y,0) == NOTOK) {
        !           119:                                LLOG (log_dsap,LLOG_EXCEPTIONS,("Could not make default attribute file"));
        !           120:                                return;
        !           121:                        }
        !           122: #ifdef SYS5
        !           123:                        if (used_temp)
        !           124:                                ps_print (ps,fs->fs_name);
        !           125: #endif
        !           126:                } else if ( ! (fs->fs_mode & FS_DEFAULT))
        !           127:                        ps_print (ps,fs->fs_name);
        !           128: 
        !           129:                if (fs->fs_attr == NULLAttrV)   /* already exists */
        !           130:                        return;
        !           131: 
        !           132:                if (fs->fs_mode & FS_CREATE)    /* already written */
        !           133:                        return; 
        !           134: 
        !           135:                um = umask (0177);
        !           136:                if ((fptr = fopen (fs->fs_name,"w")) != NULL) {
        !           137:                        (void) umask (um);
        !           138:                        if ((fps = ps_alloc (std_open)) == NULLPS) {
        !           139:                                (void) fclose (fptr);
        !           140:                                LLOG (log_dsap,LLOG_EXCEPTIONS,("Could not alloc PS file '%s'",fs->fs_name));
        !           141:                                return;
        !           142:                        }                               
        !           143:                        if ((std_setup (fps,fptr)) == NOTOK) {
        !           144:                                (void) fclose (fptr);
        !           145:                                ps_free (fps);
        !           146:                                LLOG (log_dsap,LLOG_EXCEPTIONS,("Could not open PS file '%s'",fs->fs_name));
        !           147:                                return;
        !           148:                        }
        !           149:                } else {
        !           150:                        (void) umask (um);
        !           151:                        LLOG ( log_dsap,LLOG_EXCEPTIONS,("Could not open attribute file '%s'",fs->fs_name));
        !           152:                        return;
        !           153:                }
        !           154:                AttrV_print (fps,fs->fs_attr,FILEOUT);
        !           155:                AttrV_free (fs->fs_attr);
        !           156:                fs->fs_attr = NULLAttrV;
        !           157:                (void) fclose (fptr);
        !           158:                ps_free (fps);
        !           159:                fs->fs_mode |= FS_CREATE;
        !           160: 
        !           161:                DLOG (log_dsap,LLOG_DEBUG,("Written photo file '%s'",fs->fs_name));
        !           162:        }
        !           163:        return;
        !           164: 
        !           165: }
        !           166: 
        !           167: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.