Return to ftam-mgmt.c CVS log

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

Annotation of 43BSDReno/contrib/isode-beta/ftam2/ftam-mgmt.c, revision 1.1

1.1     ! root        1: /* ftam-mgmt.c - interactive initiator FTAM -- file management */
        !             2: 
        !             3: #ifndef        lint
        !             4: static char *rcsid = "$Header: /f/osi/ftam2/RCS/ftam-mgmt.c,v 7.0 89/11/23 21:54:23 mrose Rel $";
        !             5: #endif
        !             6: 
        !             7: /* 
        !             8:  * $Header: /f/osi/ftam2/RCS/ftam-mgmt.c,v 7.0 89/11/23 21:54:23 mrose Rel $
        !             9:  *
        !            10:  *
        !            11:  * $Log:       ftam-mgmt.c,v $
        !            12:  * Revision 7.0  89/11/23  21:54:23  mrose
        !            13:  * Release 6.0
        !            14:  * 
        !            15:  */
        !            16: 
        !            17: /*
        !            18:  *                               NOTICE
        !            19:  *
        !            20:  *    Acquisition, use, and distribution of this module and related
        !            21:  *    materials are subject to the restrictions of a license agreement.
        !            22:  *    Consult the Preface in the User's Manual for the full terms of
        !            23:  *    this agreement.
        !            24:  *
        !            25:  */
        !            26: 
        !            27: 
        !            28: #include <stdio.h>
        !            29: #include "ftamuser.h"
        !            30: 
        !            31: /*  */
        !            32: 
        !            33: int    f_mv (vec)
        !            34: char  **vec;
        !            35: {
        !            36: #ifdef BRIDGE
        !            37:     register char *src;
        !            38: #else
        !            39:     int        sglobbed;
        !            40:     register char  *bp,
        !            41:                  **gp,
        !            42:                  **src;
        !            43:     char   *freedst = NULL,
        !            44:            buffer[BUFSIZ];
        !            45: #endif
        !            46:     register char  *dst;
        !            47: 
        !            48:     if (*++vec == NULL) {
        !            49: #ifdef BRIDGE
        !            50:        return NOTOK;
        !            51: #else
        !            52:        if (getline ("source: ", buffer) == NOTOK || str2vec (buffer, vec) < 1)
        !            53:            return OK;
        !            54:        dst = NULL;
        !            55: #endif
        !            56:     }
        !            57: #ifdef BRIDGE
        !            58:     src = *vec;
        !            59:     if (*++vec == NULL)
        !            60:        return NOTOK;
        !            61:     dst = *vec;
        !            62: #else
        !            63:     else {
        !            64:        register char **ap;
        !            65: 
        !            66:        for (ap = vec; *ap; ap++)
        !            67:            continue;
        !            68:        if (--ap != vec)
        !            69:            dst = *ap, *ap = NULL;
        !            70:        else
        !            71:            dst = NULL;
        !            72:     }
        !            73: #endif
        !            74: #ifndef        BRIDGE
        !            75:     if (!(src = xglob (vec, 1)))
        !            76:        return OK;
        !            77:     sglobbed = xglobbed;
        !            78: 
        !            79:     if (dst == NULL) {
        !            80:        if (getline ("destination: ", buffer) == NOTOK) {
        !            81:            blkfree (src);
        !            82:            return OK;
        !            83:        }
        !            84:        switch (str2vec (buffer, vec)) {
        !            85:            case 0: 
        !            86:                switch (realstore) {
        !            87:                    case RFS_UNIX:
        !            88:                        dst = ".";
        !            89:                        break;
        !            90: 
        !            91:                    default:
        !            92:                        advise (NULLCP, "need a destination");
        !            93:                        goto out;
        !            94:                }
        !            95:                break;
        !            96: 
        !            97:            case 1: 
        !            98:                dst = *vec;
        !            99:                break;
        !           100: 
        !           101:            default: 
        !           102:                advise (NULLCP, "too many destinations");
        !           103:                goto out;
        !           104:        }
        !           105:     }
        !           106:     if (!(dst = freedst = xglob1val (dst, 1)))
        !           107:        goto out;
        !           108: 
        !           109:     if (src[1] == NULL) {
        !           110:        if (interrupted)
        !           111:            goto out;
        !           112:            
        !           113:        switch (realstore) {
        !           114:            case RFS_UNIX:
        !           115:                if (isdir (dst, NULLCP, 1) == NOTOK)
        !           116:                    break;
        !           117: #ifdef apollo
        !           118:                 if (*dst == '/')
        !           119:                    (void) sprintf (bp = buffer, "%s", dst);
        !           120:                 else
        !           121: #endif
        !           122:                (void) sprintf (bp = buffer, "%s/", dst);
        !           123:                bp += strlen (bp);
        !           124:                if (dst = rindex (*src, '/'))
        !           125:                    dst++;
        !           126:                if (dst == NULL || *dst == NULL)
        !           127:                    dst = *src;
        !           128:                (void) strcpy (bp, dst);
        !           129:                dst = buffer;
        !           130: 
        !           131:                switch (ask ("mv %s %s", *src, dst)) {
        !           132:                    case NOTOK: 
        !           133:                        goto out;
        !           134: 
        !           135:                    case OK: 
        !           136:                    default: 
        !           137:                        break;
        !           138: 
        !           139:                    case DONE: 
        !           140:                        goto out;
        !           141:                }
        !           142:                break;
        !           143: 
        !           144:            default:
        !           145:                break;
        !           146:        }
        !           147: 
        !           148:        (void) mv (*src, dst, 0);
        !           149:        goto out;
        !           150:     }
        !           151: 
        !           152:     switch (realstore) {
        !           153:        case RFS_UNKNOWN: 
        !           154:            advise (NULLCP, "%s", rs_unknown);
        !           155:            goto out;
        !           156: 
        !           157:        case RFS_UNIX: 
        !           158: #ifdef apollo
        !           159:             if (*dst == '/')
        !           160:                 (void) sprintf (bp = buffer, "%s", dst);
        !           161:             else
        !           162: #endif
        !           163:            (void) sprintf (bp = buffer, "%s/", dst);
        !           164:            bp += strlen (bp);
        !           165:            break;
        !           166: 
        !           167:        default: 
        !           168:            advise (NULLCP, "%s", rs_support);
        !           169:            goto out;
        !           170:     }
        !           171: 
        !           172:     if (isdir (dst, NULLCP, 0) == NOTOK)
        !           173:        goto out;
        !           174: 
        !           175:     for (gp = src; *gp; gp++) {
        !           176:        switch (realstore) {
        !           177:            case RFS_UNIX:
        !           178:                if (dst = rindex (*gp, '/'))
        !           179:                    dst++;
        !           180:                if (dst == NULL || *dst == NULL)
        !           181:                    dst = *gp;
        !           182:                break;
        !           183: 
        !           184:            default:
        !           185:                dst = *gp;
        !           186:        }
        !           187:        (void) strcpy (bp, dst);
        !           188:        dst = str2file (buffer);
        !           189: 
        !           190:        if (sglobbed) {
        !           191:            if (query)
        !           192:                switch (ask ("mv %s %s", *gp, dst)) {
        !           193:                    case NOTOK:
        !           194:                        continue;
        !           195: 
        !           196:                    case OK:
        !           197:                    default:
        !           198:                        break;
        !           199: 
        !           200:                    case DONE:
        !           201:                        goto out;
        !           202:                }
        !           203:            else
        !           204:                advise (NULLCP, "mv %s %s", *gp, dst);
        !           205:        }
        !           206: 
        !           207:        (void) mv (*gp, dst, 1);
        !           208: 
        !           209:        if (ftamfd == NOTOK)
        !           210:            break;
        !           211:     }
        !           212: #else
        !           213:     return mv (src, dst, 0);
        !           214: #endif
        !           215: 
        !           216: #ifndef        BRIDGE
        !           217: out: ;
        !           218:     blkfree (src);
        !           219:     if (freedst)
        !           220:        free (freedst);
        !           221: 
        !           222:     return OK;
        !           223: #endif
        !           224: }
        !           225: 
        !           226: /*  */
        !           227: 
        !           228: static int  mv (src, dst, multi)
        !           229: char   *src,
        !           230:        *dst;
        !           231: int    multi;
        !           232: {
        !           233:     struct FTAMgroup    ftgs;
        !           234:     register struct FTAMgroup  *ftg = &ftgs;
        !           235:     struct FTAMindication   ftis;
        !           236:     register struct FTAMindication *fti = &ftis;
        !           237: 
        !           238:     bzero ((char *) ftg, sizeof *ftg);
        !           239:     ftg -> ftg_flags |= FTG_BEGIN | FTG_END;
        !           240:     ftg -> ftg_threshold = 0;
        !           241: 
        !           242:     ftg -> ftg_flags |= FTG_SELECT;
        !           243:     {
        !           244:        register struct FTAMselect *ftse = &ftg -> ftg_select;
        !           245:        register struct FTAMattributes *fa = &ftse -> ftse_attrs;
        !           246: 
        !           247:        fa -> fa_present = FA_FILENAME;
        !           248:        fa -> fa_nfile = 0;
        !           249:        fa -> fa_files[fa -> fa_nfile++] = src;
        !           250: 
        !           251:        ftse -> ftse_access = FA_PERM_CHNGATTR;
        !           252:        FCINIT (&ftse -> ftse_conctl);
        !           253:     }
        !           254:     ftg -> ftg_threshold++;
        !           255: 
        !           256:     ftg -> ftg_flags |= FTG_CHATTR;
        !           257:     {
        !           258:        register struct FTAMchngattr   *ftca = &ftg -> ftg_chngattr;
        !           259:        register struct FTAMattributes *fa = &ftca -> ftca_attrs;
        !           260: 
        !           261:        fa -> fa_present = FA_FILENAME;
        !           262:        fa -> fa_nfile = 0;
        !           263:        fa -> fa_files[fa -> fa_nfile++] = dst;
        !           264:     }
        !           265:     ftg -> ftg_threshold++;
        !           266: 
        !           267:     ftg -> ftg_flags |= FTG_DESELECT;
        !           268:     ftg -> ftg_threshold++;
        !           269: 
        !           270:     if (FManageRequest (ftamfd, ftg, fti) == NOTOK) {
        !           271:        ftam_advise (&fti -> fti_abort, "F-MANAGE.REQUEST");
        !           272:        return NOTOK;
        !           273:     }
        !           274: 
        !           275:     ftg = &fti -> fti_group;
        !           276: 
        !           277:     if (ftg -> ftg_flags & FTG_SELECT) {
        !           278:        register struct FTAMselect *ftse = &ftg -> ftg_select;
        !           279: 
        !           280:        if (multi && ftse -> ftse_state != FSTATE_SUCCESS)
        !           281:            printf ("%s\n", src);
        !           282:        ftam_diag (ftse -> ftse_diags, ftse -> ftse_ndiag, 1, 
        !           283:                ftse -> ftse_action);
        !           284:        if (ftse -> ftse_state != FSTATE_SUCCESS)
        !           285:            goto you_lose;
        !           286:     }
        !           287: 
        !           288:     if (ftg -> ftg_flags & FTG_CHATTR) {
        !           289:        register struct FTAMchngattr   *ftca = &ftg -> ftg_chngattr;
        !           290: 
        !           291:        ftam_diag (ftca -> ftca_diags, ftca -> ftca_ndiag, 1,
        !           292:                ftca -> ftca_action);
        !           293:     }
        !           294: 
        !           295:     if (ftg -> ftg_flags & FTG_DESELECT) {
        !           296:        register struct FTAMdeselect   *ftde = &ftg -> ftg_deselect;
        !           297: 
        !           298:        ftam_diag (ftde -> ftde_diags, ftde -> ftde_ndiag, 1,
        !           299:                ftde -> ftde_action);
        !           300:        ftam_chrg (&ftde -> ftde_charges);
        !           301:     }
        !           302: 
        !           303:     FTGFREE (ftg);
        !           304:     return OK;
        !           305: 
        !           306: you_lose: ;
        !           307:     FTGFREE (ftg);
        !           308:     return NOTOK;
        !           309: }
        !           310: 
        !           311: /*  */
        !           312: 
        !           313: int    f_rm (vec)
        !           314: char  **vec;
        !           315: {
        !           316: #ifndef        BRIDGE
        !           317:     int     multi;
        !           318:     char    buffer[BUFSIZ];
        !           319: #endif
        !           320: 
        !           321:     if (*++vec == NULL) {
        !           322: #ifdef BRIDGE
        !           323:        return NOTOK;
        !           324: #else
        !           325:        if (getline ("file: ", buffer) == NOTOK || str2vec (buffer, vec) < 1)
        !           326:            return OK;
        !           327: #endif
        !           328:     }
        !           329: 
        !           330: #ifdef BRIDGE
        !           331:     return rm (*vec, 0);
        !           332: #else
        !           333:     if (vec = xglob (vec, 1)) {
        !           334:        register char **gp;
        !           335: 
        !           336:        multi = vec[1] ? 1 : 0;
        !           337: 
        !           338:        for (gp = vec; *gp && !interrupted; gp++) {
        !           339:            if (xglobbed && query)
        !           340:                switch (ask ("rm %s", *gp)) {
        !           341:                    case NOTOK:
        !           342:                        continue;
        !           343: 
        !           344:                    case OK:
        !           345:                    default:
        !           346:                        break;
        !           347: 
        !           348:                    case DONE:
        !           349:                        goto out;
        !           350:                }
        !           351:                    
        !           352:            (void) rm (*gp, multi);
        !           353: 
        !           354:            if (ftamfd == NOTOK)
        !           355:                break;
        !           356:        }
        !           357: 
        !           358: out: ;
        !           359:        blkfree (vec);
        !           360:     }
        !           361: 
        !           362:     return OK;
        !           363: #endif
        !           364: }
        !           365: 
        !           366: /*  */
        !           367: 
        !           368: static int  rm (file, multi)
        !           369: char   *file;
        !           370: int    multi;
        !           371: {
        !           372:     struct FTAMgroup    ftgs;
        !           373:     register struct FTAMgroup  *ftg = &ftgs;
        !           374:     struct FTAMindication   ftis;
        !           375:     register struct FTAMindication *fti = &ftis;
        !           376: 
        !           377:     bzero ((char *) ftg, sizeof *ftg);
        !           378:     ftg -> ftg_flags |= FTG_BEGIN | FTG_END;
        !           379:     ftg -> ftg_threshold = 0;
        !           380: 
        !           381:     ftg -> ftg_flags |= FTG_SELECT;
        !           382:     {
        !           383:        register struct FTAMselect *ftse = &ftg -> ftg_select;
        !           384:        register struct FTAMattributes *fa = &ftse -> ftse_attrs;
        !           385: 
        !           386:        fa -> fa_present = FA_FILENAME;
        !           387:        fa -> fa_nfile = 0;
        !           388:        fa -> fa_files[fa -> fa_nfile++] = file;
        !           389: 
        !           390:        ftse -> ftse_access = FA_PERM_DELETE;
        !           391:        FCINIT (&ftse -> ftse_conctl);
        !           392:     }
        !           393:     ftg -> ftg_threshold++;
        !           394: 
        !           395:     ftg -> ftg_flags |= FTG_DELETE;
        !           396:     ftg -> ftg_threshold++;
        !           397: 
        !           398:     if (FManageRequest (ftamfd, ftg, fti) == NOTOK) {
        !           399:        ftam_advise (&fti -> fti_abort, "F-MANAGE.REQUEST");
        !           400:        return NOTOK;
        !           401:     }
        !           402: 
        !           403:     ftg = &fti -> fti_group;
        !           404: 
        !           405:     if (ftg -> ftg_flags & FTG_SELECT) {
        !           406:        register struct FTAMselect *ftse = &ftg -> ftg_select;
        !           407: 
        !           408:        if (multi && ftse -> ftse_state != FSTATE_SUCCESS)
        !           409:            printf ("%s\n", file);
        !           410:        ftam_diag (ftse -> ftse_diags, ftse -> ftse_ndiag, 1,
        !           411:                ftse -> ftse_action);
        !           412:        if (ftse -> ftse_state != FSTATE_SUCCESS)
        !           413:            goto you_lose;
        !           414:     }
        !           415: 
        !           416:     if (ftg -> ftg_flags & FTG_DELETE) {
        !           417:        register struct FTAMdelete   *ftxe = &ftg -> ftg_delete;
        !           418: 
        !           419:        ftam_diag (ftxe -> ftxe_diags, ftxe -> ftxe_ndiag, 1,
        !           420:                ftxe -> ftxe_action);
        !           421:        ftam_chrg (&ftxe -> ftxe_charges);
        !           422:     }
        !           423: 
        !           424:     FTGFREE (ftg);
        !           425:     return OK;
        !           426: 
        !           427: you_lose: ;
        !           428:     FTGFREE (ftg);
        !           429:     return NOTOK;
        !           430: }
        !           431: 
        !           432: /*  */
        !           433: 
        !           434: #ifndef        BRIDGE
        !           435: int    f_chgrp (vec)
        !           436: char  **vec;
        !           437: {
        !           438:     int     multi;
        !           439:     char    group[8 + 1];
        !           440:     char    buffer[BUFSIZ];
        !           441: 
        !           442:     if (!(attrs & FATTR_STORAGE)) {
        !           443:        advise (NULLCP, "no support for storage attributes");
        !           444:        return OK;
        !           445:     }
        !           446: 
        !           447:     if (*++vec == NULL) {
        !           448:        if (getline ("group: ", buffer) == NOTOK || str2vec (buffer, vec) < 1)
        !           449:            return OK;
        !           450:     }
        !           451: 
        !           452:     (void) strcpy (group, vec[0]);
        !           453: 
        !           454:     if (*++vec == NULL) {
        !           455:        if (getline ("file: ", buffer) == NOTOK || str2vec (buffer, vec) < 1)
        !           456:            return OK;
        !           457:     }
        !           458: 
        !           459:     if (vec = xglob (vec, 1)) {
        !           460:        register char **gp;
        !           461: 
        !           462:        multi = vec[1] ? 1 : 0;
        !           463: 
        !           464:        for (gp = vec; *gp && !interrupted; gp++) {
        !           465:            if (xglobbed && query)
        !           466:                switch (ask ("chgrp %s %s", group, *gp)) {
        !           467:                    case NOTOK:
        !           468:                        continue;
        !           469: 
        !           470:                    case OK:
        !           471:                    default:
        !           472:                        break;
        !           473: 
        !           474:                    case DONE:
        !           475:                        goto out;
        !           476:                }
        !           477:                    
        !           478:            (void) chgrp (group, *gp, multi);
        !           479: 
        !           480:            if (ftamfd == NOTOK)
        !           481:                break;
        !           482:        }
        !           483: 
        !           484: out: ;
        !           485:        blkfree (vec);
        !           486:     }
        !           487: 
        !           488:     return OK;
        !           489: }
        !           490: 
        !           491: /*  */
        !           492: 
        !           493: static int  chgrp (group, file, multi)
        !           494: char   *group,
        !           495:        *file;
        !           496: int    multi;
        !           497: {
        !           498:     struct FTAMgroup    ftgs;
        !           499:     register struct FTAMgroup  *ftg = &ftgs;
        !           500:     struct FTAMindication   ftis;
        !           501:     register struct FTAMindication *fti = &ftis;
        !           502: 
        !           503:     bzero ((char *) ftg, sizeof *ftg);
        !           504:     ftg -> ftg_flags |= FTG_BEGIN | FTG_END;
        !           505:     ftg -> ftg_threshold = 0;
        !           506: 
        !           507:     ftg -> ftg_flags |= FTG_SELECT;
        !           508:     {
        !           509:        register struct FTAMselect *ftse = &ftg -> ftg_select;
        !           510:        register struct FTAMattributes *fa = &ftse -> ftse_attrs;
        !           511: 
        !           512:        fa -> fa_present = FA_FILENAME;
        !           513:        fa -> fa_nfile = 0;
        !           514:        fa -> fa_files[fa -> fa_nfile++] = file;
        !           515: 
        !           516:        ftse -> ftse_access = FA_PERM_CHNGATTR;
        !           517:        FCINIT (&ftse -> ftse_conctl);
        !           518:     }
        !           519:     ftg -> ftg_threshold++;
        !           520: 
        !           521:     ftg -> ftg_flags |= FTG_CHATTR;
        !           522:     {
        !           523:        register struct FTAMchngattr   *ftca = &ftg -> ftg_chngattr;
        !           524:        register struct FTAMattributes *fa = &ftca -> ftca_attrs;
        !           525: 
        !           526:        fa -> fa_present = FA_ACCOUNT;
        !           527:        fa -> fa_account = group;
        !           528:     }
        !           529:     ftg -> ftg_threshold++;
        !           530: 
        !           531:     ftg -> ftg_flags |= FTG_DESELECT;
        !           532:     ftg -> ftg_threshold++;
        !           533: 
        !           534:     if (FManageRequest (ftamfd, ftg, fti) == NOTOK) {
        !           535:        ftam_advise (&fti -> fti_abort, "F-MANAGE.REQUEST");
        !           536:        return NOTOK;
        !           537:     }
        !           538: 
        !           539:     ftg = &fti -> fti_group;
        !           540: 
        !           541:     if (ftg -> ftg_flags & FTG_SELECT) {
        !           542:        register struct FTAMselect *ftse = &ftg -> ftg_select;
        !           543: 
        !           544:        if (multi && ftse -> ftse_state != FSTATE_SUCCESS)
        !           545:            printf ("%s\n", file);
        !           546:        ftam_diag (ftse -> ftse_diags, ftse -> ftse_ndiag, 1, 
        !           547:                ftse -> ftse_action);
        !           548:        if (ftse -> ftse_state != FSTATE_SUCCESS)
        !           549:            goto you_lose;
        !           550:     }
        !           551: 
        !           552:     if (ftg -> ftg_flags & FTG_CHATTR) {
        !           553:        register struct FTAMchngattr   *ftca = &ftg -> ftg_chngattr;
        !           554: 
        !           555:        ftam_diag (ftca -> ftca_diags, ftca -> ftca_ndiag, 1,
        !           556:                ftca -> ftca_action);
        !           557:     }
        !           558: 
        !           559:     if (ftg -> ftg_flags & FTG_DESELECT) {
        !           560:        register struct FTAMdeselect   *ftde = &ftg -> ftg_deselect;
        !           561: 
        !           562:        ftam_diag (ftde -> ftde_diags, ftde -> ftde_ndiag, 1,
        !           563:                ftde -> ftde_action);
        !           564:        ftam_chrg (&ftde -> ftde_charges);
        !           565:     }
        !           566: 
        !           567:     FTGFREE (ftg);
        !           568:     return OK;
        !           569: 
        !           570: you_lose: ;
        !           571:     FTGFREE (ftg);
        !           572:     return NOTOK;
        !           573: }
        !           574: #endif
        !           575: 
        !           576: /*  */
        !           577: 
        !           578: int    f_mkdir (vec)
        !           579: char  **vec;
        !           580: {
        !           581: #ifndef        BRIDGE
        !           582:     int            multi;
        !           583:     register char  *dir;
        !           584:     char    buffer[BUFSIZ];
        !           585: #endif
        !           586: 
        !           587:     if (*++vec == NULL) {
        !           588: #ifdef BRIDGE
        !           589:        return NOTOK;
        !           590: #else
        !           591:        if (getline ("directory: ", buffer) == NOTOK
        !           592:                || str2vec (buffer, vec) < 1)
        !           593:            return OK;
        !           594: 
        !           595:        (void) makedir (str2file (*vec), 0);
        !           596: #endif
        !           597:     }
        !           598: #ifdef BRIDGE
        !           599:     return makedir (str2file (*vec));
        !           600: #else
        !           601:     else {
        !           602:        multi = vec[1] ? 1 : 0;
        !           603: 
        !           604:        while (dir = *vec++)
        !           605:            (void) makedir (str2file (dir), multi);
        !           606:     }
        !           607: 
        !           608:     return OK;
        !           609: #endif
        !           610: }
        !           611: 
        !           612: /*  */
        !           613: 
        !           614: static int  makedir (dir, multi)
        !           615: char   *dir;
        !           616: int    multi;
        !           617: {
        !           618:     struct FTAMgroup    ftgs;
        !           619:     register struct FTAMgroup  *ftg = &ftgs;
        !           620:     struct FTAMindication   ftis;
        !           621:     register struct FTAMindication *fti = &ftis;
        !           622:     struct vfsmap *vf = &vfs[VFS_FDF];
        !           623: 
        !           624:     if (vf -> vf_oid == NULLOID) {
        !           625:        advise (NULLCP, "no support for %ss", vf -> vf_text);
        !           626:        return NOTOK;
        !           627:     }
        !           628: 
        !           629:     bzero ((char *) ftg, sizeof *ftg);
        !           630:     ftg -> ftg_flags |= FTG_BEGIN | FTG_END;
        !           631:     ftg -> ftg_threshold = 0;
        !           632: 
        !           633:     ftg -> ftg_flags |= FTG_CREATE;
        !           634:     {
        !           635:        register struct FTAMcreate *ftce = &ftg -> ftg_create;
        !           636:        register struct FTAMattributes *fa = &ftce -> ftce_attrs;
        !           637: 
        !           638:        ftce -> ftce_override = FOVER_FAIL;
        !           639: 
        !           640:        fa -> fa_present = FA_FILENAME;
        !           641:        fa -> fa_nfile = 0;
        !           642:        fa -> fa_files[fa -> fa_nfile++] = dir;
        !           643: 
        !           644:        fa -> fa_present |= FA_ACTIONS;
        !           645:        fa -> fa_permitted = FA_PERM_READ | FA_PERM_READATTR | FA_PERM_CHNGATTR
        !           646:                                | FA_PERM_DELETE | FA_PERM_TRAV;
        !           647: 
        !           648:        fa -> fa_present |= FA_CONTENTS;
        !           649:        fa -> fa_contents = vf -> vf_oid;
        !           650: 
        !           651:        ftce -> ftce_access = 0;
        !           652:        FCINIT (&ftce -> ftce_conctl);
        !           653:     }
        !           654:     ftg -> ftg_threshold++;
        !           655: 
        !           656:     ftg -> ftg_flags |= FTG_DESELECT;
        !           657:     ftg -> ftg_threshold++;
        !           658: 
        !           659:     if (FManageRequest (ftamfd, ftg, fti) == NOTOK) {
        !           660:        ftam_advise (&fti -> fti_abort, "F-MANAGE.REQUEST");
        !           661:        return NOTOK;
        !           662:     }
        !           663: 
        !           664:     ftg = &fti -> fti_group;
        !           665: 
        !           666:     if (ftg -> ftg_flags & FTG_CREATE) {
        !           667:        register struct FTAMcreate *ftce = &ftg -> ftg_create;
        !           668: 
        !           669:        if (multi && ftce -> ftce_state != FSTATE_SUCCESS)
        !           670:            printf ("%s\n", dir);
        !           671:        ftam_diag (ftce -> ftce_diags, ftce -> ftce_ndiag, 1, 
        !           672:                ftce -> ftce_action);
        !           673:        if (ftce -> ftce_state != FSTATE_SUCCESS)
        !           674:            goto you_lose;
        !           675:     }
        !           676: 
        !           677:     if (ftg -> ftg_flags & FTG_DESELECT) {
        !           678:        register struct FTAMdeselect   *ftde = &ftg -> ftg_deselect;
        !           679: 
        !           680:        ftam_diag (ftde -> ftde_diags, ftde -> ftde_ndiag, 1,
        !           681:                ftde -> ftde_action);
        !           682:        ftam_chrg (&ftde -> ftde_charges);
        !           683:     }
        !           684: 
        !           685:     FTGFREE (ftg);
        !           686:     return OK;
        !           687: 
        !           688: you_lose: ;
        !           689:     FTGFREE (ftg);
        !           690:     return NOTOK;
        !           691: }

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