BSD 4_3_Net_2 development

[unix-history] / usr / src / contrib / isode / ftam / ftaminitiate.c

/* ftaminitiate.c - FPM: initiator */

#ifndef lint
static char *rcsid = "$Header: /f/osi/ftam/RCS/ftaminitiate.c,v 7.3 91/02/22 09:23:00 mrose Interim $";
#endif

/* 
* $Header: /f/osi/ftam/RCS/ftaminitiate.c,v 7.3 91/02/22 09:23:00 mrose Interim $
*
*
* $Log:        ftaminitiate.c,v $
* Revision 7.3  91/02/22  09:23:00  mrose
* Interim 6.8
* 
* Revision 7.2  91/01/07  12:40:10  mrose
* update
* 
* Revision 7.1  90/11/21  11:30:08  mrose
* sun
* 
* Revision 7.0  89/11/23  21:53:41  mrose
* Release 6.0
* 
*/

/*
*                                NOTICE
*
*    Acquisition, use, and distribution of this module and related
*    materials are subject to the restrictions of a license agreement.
*    Consult the Preface in the User's Manual for the full terms of
*    this agreement.
*
*/


/* LINTLIBRARY */

#include <stdio.h>
#include <signal.h>
#include "fpkt.h"


#define FS_CTX          "iso ftam"
#define FS_ASN          "ftam pci"

/* \f   F-INITIALIZE.REQUEST */

int     FInitializeRequest (context, callingtitle, calledtitle, callingaddr,
       calledaddr, manage, class, units, attrs, sharedASE, fqos, contents,
       initiator, account, password, passlen, qos, tracing, ftc, fti)
OID     context;
AEI     callingtitle,
       calledtitle;
struct PSAPaddr *callingaddr,
               *calledaddr;
int     manage,
       class,
       units,
       attrs,
       fqos,
       passlen;
PE      sharedASE;
struct FTAMcontentlist *contents;
char   *initiator,
      *account,
      *password;
struct QOStype *qos;
IFP     tracing;
struct FTAMconnect *ftc;
struct FTAMindication *fti;
{
   SBV     smask;
   int     result;

#ifdef  notdef
   missingP (context);
   missingP (callingtitle);
   missingP (calledtitle);
   missingP (callingaddr);
#endif
   missingP (calledaddr);
   if (manage)
       return ftamlose (fti, FS_ACS_CONTEXT, 1, NULLCP, NULLCP);
   if (units & ~MY_FUNIT)
       return ftamlose (fti, FS_ACS_FUNIT, 1, NULLCP, NULLCP);
   if (!(units & FUNIT_LIMITED) && (units & FUNIT_ENHANCED))
       return ftamlose (fti, FS_GEN_NOREASON, 1, NULLCP,
               "enhanced-file-management requires limited-file-management");
   if ((class & FCLASS_TRANSFER
               && ((units & FUNITS_TRANSFER) != FUNITS_TRANSFER))) {
not_enough: ;
           return ftamlose (fti, FS_GEN_NOREASON, 1, NULLCP,
                           "insufficient functional units for service class");
   }
   if ((class & FCLASS_TM) && ((units & FUNITS_TM) != FUNITS_TM))
       goto not_enough;
   if ((class & (FCLASS_TRANSFER | FCLASS_TM))
           && !(units & (FUNIT_READ | FUNIT_WRITE)))
       goto not_enough;
   if ((class & FCLASS_ACCESS) && ((units & FUNITS_ACCESS) != FUNITS_ACCESS))
       goto not_enough;
   if ((class & FCLASS_MANAGE) && ((units & FUNITS_MANAGE) != FUNITS_MANAGE))
       goto not_enough;
   if (!(class &=
               (FCLASS_TRANSFER | FCLASS_TM | FCLASS_MANAGE | FCLASS_ACCESS)))
       return ftamlose (fti, FS_ACS_CLASS, 1, NULLCP, NULLCP);
   if (!(units & FUNIT_LIMITED) && (units & FUNIT_ENHANCED))
       return ftamlose (fti, FS_GEN_NOREASON, 1, NULLCP,
           "enhanced-file-management requires limited-file-management");
   if (!(units & FUNIT_GROUPING))      /* XXX: should be OPTIONAL */
           goto not_enough;
   if (attrs & ~MY_FATTR)
       return ftamlose (fti, FS_ACS_GRPSUP, 1, NULLCP, NULLCP);
#ifdef  notdef
   if ((attrs & FATTR_SECURITY) && !(attrs & FATTR_STORAGE))
       return ftamlose (fti, FS_ACS_GRP, 1, NULLCP, NULLCP);
#endif
   if (contents && contents -> fc_ncontent > NFCONT)
       return ftamlose (fti, FS_GEN_NOREASON, 1, NULLCP,
                   "too many content types");
   if (password == NULL)
       passlen = 0;
#ifdef  notdef
   missingP (qos);
#endif
   missingP (fti);

   smask = sigioblock ();

   result = FInitializeRequestAux (context, callingtitle, calledtitle,
           callingaddr, calledaddr, manage, class, units, attrs, sharedASE, fqos,
           contents, initiator, account, password, passlen, qos, tracing, ftc,
           fti);

   (void) sigiomask (smask);

   return result;
}

/* \f */

static int  FInitializeRequestAux (context, callingtitle, calledtitle,
       callingaddr, calledaddr, manage, class, units, attrs, sharedASE, fqos,
       contents, initiator, account, password, passlen, qos, tracing, ftc,
       fti)
OID     context;
AEI     callingtitle,
       calledtitle;
struct PSAPaddr *callingaddr,
               *calledaddr;
int     manage,
       class,
       units,
       attrs,
       fqos,
       passlen;
PE      sharedASE;
struct FTAMcontentlist *contents;
char   *initiator,
      *account,
      *password;
struct QOStype *qos;
IFP     tracing;
struct FTAMconnect *ftc;
struct FTAMindication *fti;
{
   register int        i;
   int     bits,
               rcvd_bits,
           idc,
           result,
           settings;
   long    isn;
   PE      pe;
   OID     ctx,
           pci;
   struct SSAPref *sr;
   register struct PSAPcontext *px;
   struct PSAPctxlist pls;
   register struct PSAPctxlist *pl = &pls;
   struct AcSAPconnect accs;
   register struct AcSAPconnect *acc = &accs;
   register struct PSAPconnect *pc = &acc -> acc_connect;
   struct AcSAPindication acis;
   register struct AcSAPindication *aci = &acis;
   register struct AcSAPabort *aca = &aci -> aci_abort;
   register struct FTAMcontent *fx;
   register struct ftamblk *fsb;
   struct type_FTAM_PDU *pdu;
   register struct type_FTAM_F__INITIALIZE__request *req;
   register struct type_FTAM_F__INITIALIZE__response *rsp;

   if ((fsb = newfsblk ()) == NULL)
       return ftamlose (fti, FS_GEN_NOREASON, 1, NULLCP, "out of memory");
   fsb -> fsb_flags |= FSB_INIT;
   fsb -> fsb_trace = tracing;

   ctx = pci = NULLOID, pl -> pc_nctx = 0;
   bzero ((char *) ftc, sizeof *ftc);

   pdu = NULL;

   if (context == NULLOID && (context = ode2oid (FS_CTX)) == NULLOID) {
       result = ftamlose (fti, FS_ACS_MGMT, 1, NULLCP, "%s: unknown", FS_CTX);
       goto out1;
   }
   if ((ctx = oid_cpy (context)) == NULLOID) {
no_mem: ;
       result = ftamlose (fti, FS_GEN_NOREASON, 1, NULLCP, "out of memory");
       goto out1;
   }

   if ((pci = ode2oid (FS_ASN)) == NULLOID) {
       result = ftamlose (fti, FS_ACS_MGMT, 1, NULLCP, "%s: unknown", FS_ASN);
       goto out1;
   }
   if ((pci = oid_cpy (pci)) == NULLOID)
       goto no_mem;

   px = pl -> pc_ctx, pl -> pc_nctx = 0;

   px -> pc_id = fsb -> fsb_id = idc = 1;
   if ((px -> pc_asn = ode2oid (FS_ASN)) == NULLOID) {
       result = ftamlose (fti, FS_ACS_MGMT, 1, NULLCP, "%s: unknown", FS_ASN);
       goto out1;
   }
   if ((px -> pc_asn = oid_cpy (px -> pc_asn)) == NULLOID)
       goto no_mem;
   if ((px -> pc_atn = ode2oid (BER)) == NULLOID) {
       result = ftamlose (fti, FS_ACS_MGMT, 1, NULLCP, "%s: unknown", BER);
       goto out1;
   }
   if ((px -> pc_atn = oid_cpy (px -> pc_atn)) == NULLOID)
       goto no_mem;
   px++, pl -> pc_nctx++;

   if (contents) {
       register struct isodocument *id;

       for (fx = contents -> fc_contents, i = contents -> fc_ncontent - 1;
               i >= 0;
               fx++, i--) {
           if (fx -> fc_dtn == NULLOID) {
               result = ftamlose (fti, FS_GEN (fsb), 1, NULLCP,
                       "empty content type at slot %d",
                       contents -> fc_ncontent - i - 1);
               goto out1;
           }

           if ((id = getisodocumentbytype (fx -> fc_dtn)) == NULL) {
               result = ftamlose (fti, FS_GEN (fsb), 1, NULLCP,
                       "unknown document type %s at slot %d",
                       sprintoid (fx -> fc_dtn),
                       contents -> fc_ncontent - i - 1);
               goto out1;
           }

           px -> pc_id = (idc += 2);
           if ((px -> pc_asn = oid_cpy (id -> id_abstract)) == NULLOID)
               goto no_mem;
           if ((px -> pc_atn = oid_cpy (id -> id_transfer)) == NULLOID)
               goto no_mem;
           px++, pl -> pc_nctx++;
       }
   }

   if ((pdu = (struct type_FTAM_PDU *) calloc (1, sizeof *pdu)) == NULL)
       goto no_mem;
   pdu -> offset = type_FTAM_PDU_f__initialize__request;
   if ((req = (struct type_FTAM_F__INITIALIZE__request *)
                               calloc (1, sizeof *req)) == NULL)
       goto no_mem;
   pdu -> un.f__initialize__request = req;
   req -> presentation__context__management = manage;
   if (class != FCLASS_TRANSFER
               && (req -> service__class = bits2fpm (fsb, fclass_pairs, class,
                                                     fti)) == NULLPE)
       goto out1;
   if ((req -> functional__units = bits2fpm (fsb, funit_pairs, units, fti))
           == NULLPE)
       goto out1;
   if (attrs && (req -> attribute__groups = bits2fpm (fsb, fattr_pairs,
                                                      attrs, fti)) == NULLPE)
       goto out1;
   if (sharedASE
               && (req -> shared__ASE__information =
                               shared2fpm (fsb, sharedASE, fti)) == NULL)
       goto out1;
   if ((req -> ftam__quality__of__service =
               (struct type_FTAM_FTAM__Quality__Of__Service *)
                       calloc (1, sizeof *req -> ftam__quality__of__service))
           == NULL)
       goto no_mem;
#ifdef  lint
   req -> ftam__quality__of__service -> parm = fqos;
#else
   req -> ftam__quality__of__service -> parm = MY_FQOS;
#endif
   if (contents) {
       struct type_FTAM_Contents__Type__List *fpm;
       register struct type_FTAM_Contents__Type__List **fpc;

       fpc = &req -> contents__type__list;
       for (fx = contents -> fc_contents, i = contents -> fc_ncontent - 1;
               i >= 0;
               fx++, i--) {
           if ((fpm = (struct type_FTAM_Contents__Type__List *)
                           calloc (1, sizeof *fpm)) == NULL)
               goto no_mem;
           *fpc = fpm;

           if ((fpm -> Document__Type__Name = oid_cpy (fx -> fc_dtn))
                   == NULLOID)
               goto no_mem;
           fpc = &fpm -> next;
       }
   }
   if (initiator
           && (req -> initiator__identity = str2qb (initiator,
                                                    strlen (initiator), 1))
                   == NULL)
       goto out1;
   if (account
           && (req -> account = str2qb (account, strlen (account), 1))
                   == NULL)
       goto out1;
   if (password) {
       register struct type_FTAM_Password *p;

       if ((p = (struct type_FTAM_Password *) calloc (1, sizeof *p))
               == NULL)
           goto no_mem;
       req -> filestore__password = p;
       p -> offset = type_FTAM_Password_binary;
       if ((p -> un.binary = str2qb (password, passlen, 1)) == NULL)
           goto no_mem;
   }
   req -> checkpoint__window = 1;

   if (encode_FTAM_PDU (&pe, 1, 0, NULLCP, pdu) == NOTOK) {
       (void) ftamlose (fti, FS_GEN (fsb), 1, NULLCP,
                        "error encoding PDU: %s", PY_pepy);
       goto out1;
   }

   pe -> pe_context = fsb -> fsb_id;

   fsb -> fsb_srequirements = SR_DUPLEX | SR_RESYNC;
   fsb -> fsb_srequirements &= ~SR_RESYNC;     /* XXX */
   if (units & (FUNIT_RECOVERY | FUNIT_RESTART))
       fsb -> fsb_srequirements |= SR_MINORSYNC;
   isn = (fsb -> fsb_srequirements & (SR_MINORSYNC | SR_RESYNC)) ? 1L
               : SERIAL_NONE;
   fsb -> fsb_prequirements = manage ? (PR_MANAGEMENT | PR_RESTORATION) : 0;
   settings = 0;
#define dotoken(requires,shift,bit,type) \
{ \
   if (fsb -> fsb_srequirements & requires) \
       settings |= ST_INIT_VALUE << shift; \
}
   dotokens ();
#undef  dotoken

   if ((sr = addr2ref (PLocalHostName ())) == NULL)
       goto no_mem;

   fsbtrace (fsb, (fsb -> fsb_fd, "A-ASSOCIATE.REQUEST",
               "F-INITIALIZE-request", pe, 0));

   result = AcAssocRequest (ctx, callingtitle, calledtitle, callingaddr,
               calledaddr, pl, NULLOID /* pci */, fsb -> fsb_prequirements,
               fsb -> fsb_srequirements, isn, settings, sr, &pe, 1,
               qos, acc, aci);

   if (result == NOTOK) {
       (void) acs2ftamlose (fsb, fti, "AcAssocRequest", aca);
       goto out1;
   }

   fsb -> fsb_fd = acc -> acc_sd;

   pe_free (pe);
   pe = NULLPE;
   free_FTAM_PDU (pdu);
   pdu = NULL;
   oid_free (ctx);
   ctx = NULLOID;
   oid_free (pci);
   pci = NULLOID;
   for (px = pl -> pc_ctx, i = pl -> pc_nctx - 1; i >= 0; px++, i--) {
       if (px -> pc_asn)
           oid_free (px -> pc_asn);
       if (px -> pc_atn)
           oid_free (px -> pc_atn);
   }
       
   if (acc -> acc_ninfo < 1 || (pe = acc -> acc_info[0]) == NULLPE) {
       if (acc -> acc_result != ACS_ACCEPT) {
           register struct FTAMabort *fta = &fti -> fti_abort;

           aca -> aca_reason = acc -> acc_result;
           (void) acs2ftamlose (fsb, fti, "AcAssocRequest(pseudo)", aca);

           ftc -> ftc_sd = NOTOK;
           ftc -> ftc_state = FSTATE_FAILURE;
           ftc -> ftc_action = FACTION_PERM;
           *ftc -> ftc_diags = *fta -> fta_diags;      /* struct copy */
           ftc -> ftc_ndiag = fta -> fta_ndiag;

           result = OK;
       }
       else
           result = fpktlose (fsb, fti, FS_PRO_ERR, NULLCP, NULLCP);
       goto out2;
   }

   if (decode_FTAM_PDU (pe, 1, NULLIP, NULLVP, &pdu) == NOTOK) {
       result = fpktlose (fsb, fti, FS_PRO_ERRMSG, NULLCP,
                          "unable to parse PDU: %s", PY_pepy);
       goto out2;
   }
   if (pdu -> offset != type_FTAM_PDU_f__initialize__response) {
       result = fpktlose (fsb, fti, FS_PRO_ERRPROC, NULLCP,
                          "expecting F-INITIALIZE-response, got %d",
                          pdu -> offset);
       goto out2;
   }
   rsp = pdu -> un.f__initialize__response;

   fsbtrace (fsb,
       (fsb -> fsb_fd, "A-ASSOCIATE.CONFIRMATION", "F-INITIALIZE-response",
               pe, 1));

   ftc -> ftc_state = rsp -> state__result
                         ? rsp -> state__result -> parm
                         : int_FTAM_State__Result_success;
   ftc -> ftc_action = rsp -> action__result
                         ? rsp -> action__result -> parm
                         : int_FTAM_Action__Result_success;
   switch (acc -> acc_result) {
       case ACS_ACCEPT:
           if (ftc -> ftc_state != FSTATE_SUCCESS
                   || ftc -> ftc_action != FACTION_SUCCESS) {
               result = fpktlose (fsb, fti, FS_PRO_ERRPROC, NULLCP,
                               "state/action mismatch");
               goto out2;
           }

           fsb -> fsb_flags |= FSB_CONN;
           fsb -> fsb_srequirements &= pc -> pc_srequirements;
#define dotoken(requires,shift,bit,type) \
{ \
           if (fsb -> fsb_srequirements & requires) \
               switch (pc -> pc_settings & (ST_MASK << shift)) { \
                   case ST_INIT_VALUE << shift: \
                       fsb -> fsb_owned |= bit; \
                       fsb -> fsb_avail |= bit; \
                       break; \
\
                   case ST_RESP_VALUE << shift: \
                       fsb -> fsb_avail |= bit; \
                       break; \
\
                   default: \
                       result = fpktlose (fsb, fti, FS_PRO_ERRPROC, NULLCP, \
                                       "%s token management botched", type); \
                       goto out2; \
               } \
}
           dotokens ();
#undef  dotoken
           if (fsb -> fsb_owned != fsb -> fsb_avail) {
               result = fpktlose (fsb, fti, FS_PRO_ERRPROC, NULLCP,
                           "token management botched");
               goto out2;
           }
           fsb -> fsb_ssdusize = pc -> pc_ssdusize;

           pl = &pc -> pc_ctxlist;
           if (pl -> pc_nctx > 0 && pl -> pc_ctx[0].pc_result != PC_ACCEPT) {
               result = fpktlose (fsb, fti, FS_PRO_ERRPROC, NULLCP,
                                   "FTAM PCI rejected");
               goto out2;
           }

           fsb -> fsb_prequirements &= pc -> pc_prequirements;
           if (rsp -> presentation__context__management) {
               if (!(fsb -> fsb_prequirements & PR_MANAGEMENT)) {
                   result = fpktlose (fsb, fti, FS_PRO_ERRPROC, NULLCP,
                               "presentation content management mismatch");
                   goto out2;
               }
           }
           else
               fsb -> fsb_prequirements &= ~PR_MANAGEMENT;

               if (rsp -> service__class) {
       rcvd_bits = fpm2bits (fsb, fclass_pairs, rsp -> service__class,
&bits, fti);
       if (rcvd_bits == NOTOK)
           goto out2;
       else if (rcvd_bits > 1) {
               result = fpktlose (fsb, fti, FS_PRO_ERRPROC, NULLCP,
                           "illegal negotiation of service classes");
               goto out2;
           }
       }
           else
               bits = FCLASS_TRANSFER;
           switch (fsb -> fsb_class = (bits & class)) {
               case FCLASS_TRANSFER:
                   i = FUNITS_TRANSFER;
                   break;

               case FCLASS_ACCESS:
                   i = FUNITS_ACCESS;
                   break;

               case FCLASS_MANAGE:
                   i = FUNITS_MANAGE;
                   break;

               case FCLASS_TM:
                   i = FUNITS_TM;
                   break;

               case FCLASS_UNCONS:
                   i = FUNITS_UNCONS;
                   break;

               default:
                   result = fpktlose (fsb, fti, FS_PRO_ERRPROC, NULLCP,
                                      "service class mismatch, offered 0x%x received 0x%x",
                                      class, bits);
                   goto out2;
           }
           if (fpm2bits (fsb, funit_pairs, rsp -> functional__units, &bits,
                         fti) == NOTOK)
               goto out2;
           bits |= i;          /* conservative... */
           if ((fsb -> fsb_units = bits) & ~units) {
               result = fpktlose (fsb, fti, FS_PRO_ERRFUNIT, NULLCP,
                               "functional unit mismatch");
               goto out2;
           }
/* check for illegal and mandatory functional units */
           switch (fsb -> fsb_class) {
               case FCLASS_TRANSFER:
                       if (!(fsb -> fsb_units & FUNITS_TRANSFER))
               goto not_enough; 
               goto do_trans;
               case FCLASS_TM:
                       if (!(fsb -> fsb_units & FUNITS_TM))
                               goto not_enough;
do_trans: ;
               if (!(fsb -> fsb_units & (FUNIT_READ | FUNIT_WRITE))) {
not_enough: ;
                       result = fpktlose (fsb, fti, FS_PRO_ERRFUNIT, NULLCP,
                        "insufficient functional units for service class");
                       goto out2;
               }
                   if (fsb -> fsb_units & (FUNIT_ACCESS | FUNIT_FADULOCK)) {
too_many: ;
                       result = fpktlose (fsb, fti, FS_PRO_ERRFUNIT, NULLCP,
                                          "illegal functional units for service class");
                       goto out2;
                   }
                   break;

           case FCLASS_ACCESS:
               if (!(fsb -> fsb_units & FUNITS_ACCESS))
               goto not_enough;
               break;

               case FCLASS_MANAGE:
               if (!(fsb -> fsb_units & FUNITS_MANAGE))
               goto not_enough;
                   if (fsb -> fsb_units & (FUNIT_READ | FUNIT_WRITE
                                               | FUNIT_ACCESS | FUNIT_FADULOCK
                                               | FUNIT_RECOVERY
                                               | FUNIT_RESTART))
                       goto too_many;
                   break;
           }
           if (rsp -> attribute__groups) {
               if (fpm2bits (fsb, fattr_pairs, rsp -> attribute__groups,
                             &bits, fti) == NOTOK)
                   goto out2;
           }
           else
               bits = 0;
           if (bits & ~attrs) {
               result = fpktlose (fsb, fti, FS_PRO_ERRPROC, NULLCP,
                               "attribute group mismatch");
               goto out2;
           }
           fsb -> fsb_attrs = bits;
           if (rsp -> ftam__quality__of__service -> parm != MY_FQOS) {
               result = fpktlose (fsb, fti, FS_ACS_ROLLBACK, NULLCP,
                               "class-%d-recovery not supported",
                                  rsp -> ftam__quality__of__service -> parm);
               goto out2;
           }
           fsb -> fsb_fqos = MY_FQOS;

           ftc -> ftc_sd = fsb -> fsb_fd;
           break;
           
       default:
           ftc -> ftc_sd = NOTOK;
           if (ftc -> ftc_state == FSTATE_SUCCESS
                   && ftc -> ftc_action == FACTION_SUCCESS) {
               result = fpktlose (fsb, fti, FS_PRO_ERRPROC, NULLCP,
                               "state/action mismatch");
               goto out2;
           }
           {
               register struct FTAMabort *fta = &fti -> fti_abort;

               bzero ((char *) fta, sizeof *fta);
               fta -> fta_peer = 1;
           }
           break;
   }

   ftc -> ftc_respondtitle = acc -> acc_respondtitle;  /* struct copy */
   bzero ((char *) &acc -> acc_respondtitle, sizeof acc -> acc_respondtitle);
   ftc -> ftc_respondaddr = pc -> pc_responding;       /* struct copy */
   ftc -> ftc_context = acc -> acc_context;
   acc -> acc_context = NULLOID;
   ftc -> ftc_manage = (fsb -> fsb_prequirements & PR_MANAGEMENT) ? 1 : 0;
   ftc -> ftc_class = fsb -> fsb_class;
   ftc -> ftc_units = fsb -> fsb_units;
   ftc -> ftc_attrs = fsb -> fsb_attrs;
   if (rsp -> shared__ASE__information
           && fpm2shared (fsb, rsp -> shared__ASE__information,
                          &ftc -> ftc_sharedASE, fti) == NOTOK)
       goto out2;
   ftc -> ftc_fqos = fsb -> fsb_fqos;

   if (contents) {
       register struct type_FTAM_Contents__Type__List *dtn;
       register struct FTAMcontent *fx2;

       fx2 = ftc -> ftc_contents.fc_contents;

       for (fx = contents -> fc_contents,
               i = contents -> fc_ncontent - 1;
               i >= 0;
               fx++, i--) {
           for (dtn = rsp -> contents__type__list; dtn; dtn = dtn -> next)
               if (oid_cmp (fx -> fc_dtn, dtn -> Document__Type__Name) == 0)
                   break;
           if (dtn == NULL)
               continue;

           px = pl -> pc_ctx + 1 + (fx - contents -> fc_contents);

           fx2 -> fc_dtn = dtn -> Document__Type__Name;
           fx2 -> fc_id = px -> pc_id;
           fx2 -> fc_result = px -> pc_result;

           fx2++, ftc -> ftc_contents.fc_ncontent++;
       }

       for (dtn = rsp -> contents__type__list; dtn; dtn = dtn -> next) {
           for (fx2 = ftc -> ftc_contents.fc_contents,
                   i = ftc -> ftc_contents.fc_ncontent - 1;
                   i >= 0;
                   fx2++, i--)
               if (dtn -> Document__Type__Name == fx2 -> fc_dtn) {
                   dtn -> Document__Type__Name = NULLOID;
                   break;
               }
       }
   }
   if (rsp -> diagnostic)
       (void) fpm2diag (fsb, rsp -> diagnostic, ftc -> ftc_diags,
                        &ftc -> ftc_ndiag, fti);
   ftc -> ftc_ssdusize = fsb -> fsb_ssdusize;
   ftc -> ftc_qos = pc -> pc_qos;      /* struct copy */

   free_FTAM_PDU (pdu);
   ACCFREE (acc);

   if (acc -> acc_result != ACS_ACCEPT)
       freefsblk (fsb);

   return OK;
   
out2: ;
   ACCFREE (acc);

out1: ;
   if (pdu)
       free_FTAM_PDU (pdu);
   if (ctx)
       oid_free (ctx);
   if (pci)
       oid_free (pci);
   for (px = pl -> pc_ctx, i = pl -> pc_nctx - 1; i >= 0; px++, i--) {
       if (px -> pc_asn)
           oid_free (px -> pc_asn);
       if (px -> pc_atn)
           oid_free (px -> pc_atn);
   }
   freefsblk (fsb);

   return result;
}