diff options
Diffstat (limited to 'src/isode/h/ftam.h')
-rw-r--r-- | src/isode/h/ftam.h | 1255 |
1 files changed, 1255 insertions, 0 deletions
diff --git a/src/isode/h/ftam.h b/src/isode/h/ftam.h new file mode 100644 index 000000000..009002cb1 --- /dev/null +++ b/src/isode/h/ftam.h @@ -0,0 +1,1255 @@ +/* ftam.h - include file for FTAM users (FS-USER) */ + +/* + * $Header$ + * + * + * $Log$ + * Revision 1.1 1994/06/10 03:29:15 eichin + * autoconfed isode for kerberos work + * + * Revision 1.1 94/06/10 03:17:36 eichin + * autoconfed isode for kerberos work + * + * Revision 1.1 1994/05/31 20:37:53 eichin + * reduced-isode release from /mit/isode/isode-subset/src + * + * Revision 8.0 91/07/17 12:33:43 isode + * Release 7.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. + * + */ + + +#ifndef _FTAM_ +#define _FTAM_ + +#ifndef _PSAP2_ +#include "psap2.h" /* definitions for PS-USERs */ +#endif +#include "logger.h" + +/* */ + + /* FTAM-QoS */ +#define FQOS_NORECOVERY 0 /* no-recovery */ +#define FQOS_CLASS1 1 /* class-1-recovery */ +#define FQOS_CLASS2 2 /* class-2-recovery */ +#define FQOS_CLASS3 3 /* class-3-recovery */ +#define MY_FQOS FQOS_NORECOVERY + + + /* Service-Class */ +#define FCLASS_UNCONS 0x01 /* unconstrained-class */ +#define FCLASS_MANAGE 0x02 /* management-class */ +#define FCLASS_TRANSFER 0x04 /* transfer-class */ +#define FCLASS_TM 0x08 /* transfer-and-management-class */ +#define FCLASS_ACCESS 0x10 /* access-class */ + + /* Functional-Units */ +#define FUNIT_READ 0x001 /* read */ +#define FUNIT_WRITE 0x002 /* write */ +#define FUNIT_ACCESS 0x004 /* file-access */ +#define FUNIT_LIMITED 0x008 /* limited-file-managment */ +#define FUNIT_ENHANCED 0x010 /* enhanced-file-management */ +#define FUNIT_GROUPING 0x020 /* grouping */ +#define FUNIT_FADULOCK 0x040 /* fadu-locking */ +#define FUNIT_RECOVERY 0x080 /* recovery */ +#define FUNIT_RESTART 0x100 /* restart-data-transfer */ +#define MY_FUNIT (FUNIT_READ | FUNIT_WRITE | FUNIT_ACCESS \ + | FUNIT_LIMITED | FUNIT_ENHANCED \ + | FUNIT_GROUPING | FUNIT_FADULOCK) + + /* Attribute-Groups */ +#define FATTR_STORAGE 0x01 /* storage */ +#define FATTR_SECURITY 0x02 /* security */ +#define FATTR_PRIVATE 0x04 /* private */ +#define MY_FATTR (FATTR_STORAGE | FATTR_SECURITY) + + + /* State-Result */ +#define FSTATE_SUCCESS 0 /* success */ +#define FSTATE_FAILURE 1 /* failure */ + + /* Action-Result */ +#define FACTION_SUCCESS 0 /* success */ +#define FACTION_TRANS 1 /* transient-error */ +#define FACTION_PERM 2 /* permanent-error */ + +/* */ + +struct FTAMcontent { + OID fc_dtn; /* Document-Type-Name */ + + /* associated presentation context info */ + int fc_id; /* identifier */ + int fc_result; /* status */ +}; + + +struct FTAMcontentlist { /* Contents-Type-List */ + int fc_ncontent; /* number of contents */ + +#define NFCONT (NPCTX - 2) /* not-so-arbitrary */ + struct FTAMcontent fc_contents[NFCONT]; +}; + +/* */ + +struct FTAMdiagnostic { /* Diagnostic */ + int ftd_type; /* diagnostic-type */ +#define DIAG_INFORM 0 /* informative */ +#define DIAG_TRANS 1 /* transient */ +#define DIAG_PERM 2 /* permanent */ + + int ftd_identifier; /* error-identifier */ +#define FS_CODE2OFF(c) ((c) % 1000) + +#define FS_GEN_BASE 0 /* General FTAM diagnostics */ +#define FS_GEN_NOREASON 0 /* No reason */ +#define FS_GEN_RESPONDER 1 /* Responder error (unspecific) */ +#define FS_GEN_SHUTDOWN 2 /* System shutdown */ +#define FS_GEN_MGMT 3 /* FTAM management problem (unspecific) */ +#define FS_GEN_MGMTACCT 4 /* FTAM management, bad account */ +#define FS_GEN_MGMTPASS 5 /* FTAM management, security not passed */ +#define FS_GEN_DELAY 6 /* Delay may be encountered */ +#define FS_GEN_INITIATOR 7 /* Initiator error (unspecific) */ +#define FS_GEN_SUBSEQ 8 /* Subsequent error */ +#define FS_GEN_TEMPORAL 9 /* Temporal insufficiency of resources */ +#define FS_GEN_VFSECURE 10 /* Access request violates VFS security */ +#define FS_GEN_LSECURE 11 /* Access request violates local security */ +#define FS_GEN_WAITING 12 /* Indications waiting (unofficial) */ + +#define FS_PRO_BASE 1000 /* Protocol and supporting service related + diagnostics */ +#define FS_PRO_CONFLICT 1000 /* Conflicting parameter values */ +#define FS_PRO_UNSUPORT 1001 /* Unsupported parameter values */ +#define FS_PRO_MANDATORY 1002 /* Mandatory parameter not set */ +#define FS_PRO_UNPARAM 1003 /* Unsupported parameter */ +#define FS_PRO_DUPARAM 1004 /* Duplicated parameter */ +#define FS_PRO_ILLEGAL 1005 /* Illegal parameter type */ +#define FS_PRO_UNTYPE 1006 /* Unsupported parameter type */ +#define FS_PRO_ERR 1007 /* FTAM protocol error (unspecific) */ +#define FS_PRO_ERRPROC 1008 /* FTAM protocol error, procedure error */ +#define FS_PRO_ERRFUNIT 1009 /* FTAM protocol error, functional unit error*/ +#define FS_PRO_ERRMSG 1010 /* FTAM protocol error, corruption error */ +#define FS_PRO_LOWFAIL 1011 /* Lower layer failure */ +#define FS_PRO_LOWADDR 1012 /* Lower layer addressing error */ +#define FS_PRO_TIMEOUT 1013 /* Timeout */ +#define FS_PRO_SHUTDOWN 1014 /* System shutdown */ +#define FS_PRO_GROUPING 1015 /* Illegal grouping sequence */ +#define FS_PRO_THRESH 1016 /* Grouping threshold violation */ +#define FS_PRO_PDU 1017 /* Specific PDU request inconsistent with the + current requested access */ + +#define FS_ACS_BASE 2000 /* Association related diagnostics */ +#define FS_ACS_USER 2000 /* Association with user not allowed */ +#define FS_ACS_2001 2001 /* not assigned, #2001 */ +#define FS_ACS_CLASS 2002 /* Unsupported service class */ +#define FS_ACS_FUNIT 2003 /* Unsupported functional unit */ +#define FS_ACS_GRP 2004 /* Attribute group error (unspecific) */ +#define FS_ACS_GRPSUP 2005 /* Attribute group not supported */ +#define FS_ACS_GRPALL 2006 /* Attribute group not allowed */ +#define FS_ACS_ACCT 2007 /* Bad account */ +#define FS_ACS_MGMT 2008 /* Association management (unspecific) */ +#define FS_ACS_MGMTADDR 2009 /* Association management - bad address */ +#define FS_ACS_MGMTACCT 2010 /* Association management - bad account */ +#define FS_ACS_CKPLARGE 2011 /* Checkpoint window error - too large */ +#define FS_ACS_CKPSMALL 2012 /* Checkpoint window error - too small */ +#define FS_ACS_CKPERR 2013 /* Checkpoint window error - unsupported */ +#define FS_ACS_QOS 2014 /* Communications QoS not supported */ +#define FS_ACS_IDENTITY 2015 /* Initiator identity unacceptable */ +#define FS_ACS_CONTEXT 2016 /* Context management refused */ +#define FS_ACS_ROLLBACK 2017 /* Rollback not available */ +#define FS_ACS_CNTRESP 2018 /* Contents type list cut by responder */ +#define FS_ACS_CNTPSAP 2019 /* Contents type list cut by Presentation + service */ +#define FS_ACS_PASSWORD 2020 /* Invalid filestore password */ +#define FS_ACS_SERVICES 2021 /* Incompatible service classes */ + +#define FS_SEL_BASE 3000 /* Selection related diagnostics */ +#define FS_SEL_FILENAME 3000 /* Filename not found */ +#define FS_SEL_MATCHED 3001 /* Selection attributes not matched */ +#define FS_SEL_INITIAL 3002 /* Initial attributes not possible */ +#define FS_SEL_ATTRNAME 3003 /* Bad attribute name */ +#define FS_SEL_NOEXIST 3004 /* Non-existent file */ +#define FS_SEL_EXISTS 3005 /* File already exists */ +#define FS_SEL_CREATE 3006 /* File can not be created */ +#define FS_SEL_DELETE 3007 /* File can not be deleted */ +#define FS_SEL_CONAVAIL 3008 /* Concurrency control not available */ +#define FS_SEL_CONSUPRT 3009 /* Concurrency control not supported */ +#define FS_SEL_CONPOSS 3010 /* Concurrency control not possible */ +#define FS_SEL_RESTRICT 3011 /* More restrictive lock */ +#define FS_SEL_BUSY 3012 /* File busy */ +#define FS_SEL_AVAIL 3013 /* File not available */ +#define FS_SEL_ACCAVAIL 3014 /* Access control not available */ +#define FS_SEL_ACCSUPRT 3015 /* Access control not supported */ +#define FS_SEL_ACCINCON 3016 /* Access control inconsistent */ +#define FS_SEL_TRUNC 3017 /* Filename truncated */ +#define FS_SEL_ALTER 3018 /* Initial attributes altered */ +#define FS_SEL_ACCOUNT 3019 /* Bad account */ +#define FS_SEL_CREEXIST 3020 /* Override selected existing file */ +#define FS_SEL_CREOLD 3021 /* Override deleted and recreated file + with old attributes */ +#define FS_SEL_CRENEW 3022 /* Create override deleted and recreated file + with new attributes */ +#define FS_SEL_CRELOSE 3023 /* Create override - not possible */ +#define FS_SEL_AMBIG 3024 /* Ambiguous file specification */ +#define FS_SEL_CREPASS 3025 /* Invalid create password */ +#define FS_SEL_DELPASS 3026 /* Invalid delete password on override */ +#define FS_SEL_ATRVALUE 3027 /* Bad attribute value */ +#define FS_SEL_VIOLATES 3028 /* Requested access violates permitted + actions */ +#define FS_SEL_NOTAVAIL 3029 /* Functional unit not available for requested + access */ +#define FS_SEL_CRENOSEL 3030 /* File created but not selected */ + +#define FS_MGT_BASE 4000 /* File management related diagnostics */ +#define FS_MGT_EXIST 4000 /* Attribute non-existant */ +#define FS_MGT_READ 4001 /* Attribute cannot be read */ +#define FS_MGT_CHANGE 4002 /* Attribute cannot be changed */ +#define FS_MGT_SUPPORT 4003 /* Attribute not supported */ +#define FS_MGT_NAME 4004 /* Bad attribute name */ +#define FS_MGT_VALUE 4005 /* Bad attribute value */ +#define FS_MGT_PARTIAL 4006 /* Attribute partially supported */ +#define FS_MGMT_DISTINCT 4007 /* Additional set attribute not distinct */ + +#define FS_ACC_BASE 5000 /* Access related diagnostics */ +#define FS_ACC_FADU 5000 /* Bad FADU (unspecific) */ +#define FS_ACC_FADUSIZE 5001 /* Bad FADU - size error */ +#define FS_ACC_FADUTYPE 5002 /* Bad FADU - type error */ +#define FS_ACC_FADUSPEC 5003 /* Bad FADU - poorly specified */ +#define FS_ACC_FADULOC 5004 /* Bad FADU - bad location */ +#define FS_ACC_EXIST 5005 /* FADU does not exist */ +#define FS_ACC_AVL 5006 /* FADU not available (unspecific) */ +#define FS_ACC_AVLREAD 5007 /* FADU not available for reading */ +#define FS_ACC_AVLWRITE 5008 /* FADU not available for writing */ +#define FS_ACC_AVLLOC 5009 /* FADU not available for location */ +#define FS_ACC_AVLERASE 5010 /* FADU not available for erasure */ +#define FS_ACC_INSERT 5011 /* FADU cannot be inserted */ +#define FS_ACC_REPLACE 5012 /* FADU cannot be replaced */ +#define FS_ACC_LOCATE 5013 /* FADU cannot be located */ +#define FS_ACC_ELEMENT 5014 /* Bad data element type */ +#define FS_ACC_OPAVAIL 5015 /* Operation not available */ +#define FS_ACC_OPSUPRT 5016 /* Operation not supported */ +#define FS_ACC_OPCONS 5017 /* Operation inconsistent */ +#define FS_ACC_CONAVAIL 5018 /* Concurrency control not available */ +#define FS_ACC_CONSUPRT 5019 /* Concurrency control not supported */ +#define FS_ACC_CONINCON 5020 /* Concurrency control inconsistent */ +#define FS_ACC_MODAVAIL 5021 /* Processing mode not available */ +#define FS_ACC_MODSUPRT 5022 /* Processing mode not supported */ +#define FS_ACC_MODINCON 5023 /* Processing mode inconsistent */ +#define FS_ACC_CTXAVAIL 5024 /* Access context not available */ +#define FS_ACC_CTXSUPRT 5025 /* Access context not supported */ +#define FS_ACC_WRITE 5026 /* Bad write (unspecific) */ +#define FS_ACC_READ 5027 /* Bad read (unspecific) */ +#define FS_ACC_LCL 5028 /* Local failure (unspecific) */ +#define FS_ACC_LCLSPACE 5029 /* Local failure - file space exhausted */ +#define FS_ACC_LCLDATA 5030 /* Local failure - data corrupted */ +#define FS_ACC_LCLDEV 5031 /* Local failure - device failure */ +#define FS_ACC_FFSEXCEED 5032 /* Future file size exceeded */ +#define FS_ACC_FFSINCRES 5034 /* Future file size increased */ +#define FS_ACC_FUNIT 5035 /* Functional unit invalid in processing + mode */ +#define FS_ACC_TYPINCON 5036 /* Contents type inconsistent */ +#define FS_ACC_TYPSIMPL 5037 /* Contents type simplified */ +#define FS_ACC_DUPLICATE 5038 /* Duplicate FADU name */ +#define FS_ACC_DAMAGED 5039 /* Damage to select/open regime */ +#define FS_ACC_NOLOCKS 5040 /* FADU locking not available on file */ +#define FS_ACC_LOCKED 5041 /* FADU locked by another user */ + +#define FS_RVY_BASE 6000 /* Recovery related diagnostics */ +#define FS_RVY_CKP 6000 /* Bad checkpoint (unspecific) */ +#define FS_RVY_UNIQUE 6001 /* Activity not unique */ +#define FS_RVY_WINDOW 6002 /* Checkpoint outside window */ +#define FS_RVY_EXISTS 6003 /* Activity no longer exists */ +#define FS_RVY_RECOG 6004 /* Activity not recognized */ +#define FS_RVY_NODOCKET 6005 /* No docket */ +#define FS_RVY_CODOCKET 6006 /* Corrupt docket */ +#define FS_RVY_WAITING 6007 /* File waiting restart */ +#define FS_RVY_RECOVERY 6008 /* Bad recovery point */ +#define FS_RVY_NOPOINT 6009 /* Non-existent recovery point */ +#define FS_RVY_MODAVAIL 6010 /* Recovery mode not available */ +#define FS_RVY_MODINCON 6011 /* Recovery mode inconsistent */ +#define FS_RVY_MODREDUCE 6012 /* Recovery mode reduced */ +#define FS_RVY_ACCAVAIL 6013 /* Access control not available */ +#define FS_RVY_ACCSUPRT 6014 /* Access control not supported */ +#define FS_RVY_ACCINCON 6015 /* Access control inconsistent */ +#define FS_RVY_TYPINCON 6016 /* Contents type inconsistent */ +#define FS_RVY_TYPSIMPL 6017 /* Contents type simplified */ + + int ftd_observer; /* error-observer */ + int ftd_source; /* error-source */ +#define EREF_NONE 0 /* no-categorizaton-possible */ +#define EREF_IFSU 1 /* initiating-file-service-user */ +#define EREF_IFPM 2 /* initiating-file-protocol-machine */ +#define EREF_SERV 3 /* service-supporting-the-file-protocol-machine */ +#define EREF_RFPM 4 /* responding-file-protocol-machine */ +#define EREF_RFSU 5 /* responding-file-service-user */ + + int ftd_delay; /* suggested-delay */ +#define DIAG_NODELAY (-1) + + /* further-details */ +#define FTD_SIZE 512 /* should be unlimited... */ + int ftd_cc; /* length */ + char ftd_data[FTD_SIZE]; /* data */ +}; + +/* */ + +struct FTAMcharging { /* Charging */ + int fc_ncharge; /* number of charges */ + +#define NFCHRG 5 /* arbitrary */ + struct fc_charge { + char *fc_resource; /* resource-identifier */ + char *fc_unit; /* charging-unit */ + int fc_value; /* charging-value */ + } fc_charges[NFCHRG]; +}; + +/* */ + +struct FTAMpasswords { /* Access-Passwords */ + char *fp_read; /* read-password */ + int fp_readlen; + + char *fp_insert; /* insert-password */ + int fp_insertlen; + + char *fp_replace; /* replace-password */ + int fp_replacelen; + + char *fp_extend; /* extend-password */ + int fp_extendlen; + + char *fp_erase; /* erase-password */ + int fp_eraselen; + + char *fp_readattr; /* read-attribute-password */ + int fp_readattrlen; + + char *fp_chngattr; /* change-attribute-password */ + int fp_chngattrlen; + + char *fp_delete; /* delete-password */ + int fp_deletelen; +}; +#define FPFREE(fp) \ +{ \ + register struct FTAMpasswords *FP = (fp); \ + \ + if (FP -> fp_read) \ + free (FP -> fp_read), FP -> fp_read = NULL; \ + if (FP -> fp_insert) \ + free (FP -> fp_insert), FP -> fp_insert = NULL; \ + if (FP -> fp_replace) \ + free (FP -> fp_replace), FP -> fp_replace = NULL; \ + if (FP -> fp_extend) \ + free (FP -> fp_extend), FP -> fp_extend = NULL; \ + if (FP -> fp_erase) \ + free (FP -> fp_erase), FP -> fp_erase = NULL; \ + if (FP -> fp_readattr) \ + free (FP -> fp_readattr), FP -> fp_readattr = NULL; \ + if (FP -> fp_chngattr) \ + free (FP -> fp_chngattr), FP -> fp_chngattr = NULL; \ + if (FP -> fp_delete) \ + free (FP -> fp_delete), FP -> fp_delete = NULL; \ +} + +/* */ + +struct FTAMconcurrency { /* Concurrency-Control/Concurrency-Access */ +#define FLOCK_SHARED 00 /* shared */ +#define FLOCK_EXCLUSIVE 01 /* exclusive */ +#define FLOCK_NOTREQD 02 /* not-required */ +#define FLOCK_NOACCESS 03 /* no-access */ +#define FLOCK_MASK 03 +#define FLOCK_PRESENT FLOCK_EXCLUSIVE +#define FLOCK_RESTRICT 01 + + char fc_readlock; + char fc_insertlock; + char fc_replacelock; + char fc_extendlock; + char fc_eraselock; + char fc_readattrlock; + char fc_chngattrlock; + char fc_deletelock; +}; +#define FCINIT(fc) \ +{ \ + (fc) -> fc_readlock = FLOCK_NOTREQD; \ + (fc) -> fc_insertlock = FLOCK_NOTREQD; \ + (fc) -> fc_replacelock = FLOCK_NOTREQD; \ + (fc) -> fc_eraselock = FLOCK_NOTREQD; \ + (fc) -> fc_extendlock = FLOCK_NOTREQD; \ + (fc) -> fc_readattrlock = FLOCK_NOTREQD; \ + (fc) -> fc_chngattrlock = FLOCK_NOTREQD; \ + (fc) -> fc_deletelock = FLOCK_NOTREQD; \ +} + +/* */ + +struct FTAMacelement { /* SET OF Access-Control-Element */ + int fe_actions; /* action-list */ +#define FA_PERM_READ 0x0001 /* read */ +#define FA_PERM_INSERT 0x0002 /* insert */ +#define FA_PERM_REPLACE 0x0004 /* replace */ +#define FA_PERM_EXTEND 0x0008 /* extend */ +#define FA_PERM_ERASE 0x0010 /* erase */ +#define FA_PERM_READATTR 0x0020 /* read-attribute */ +#define FA_PERM_CHNGATTR 0x0040 /* change-attribute */ +#define FA_PERM_DELETE 0x0080 /* delete-file */ + + struct FTAMconcurrency fe_concurrency; /* concurrency-access */ + + char *fe_identity; /* user-identity */ + + struct FTAMpasswords fe_passwords; + + AEI fe_aet; /* application-entity-title */ + + struct FTAMacelement *fe_next; +}; +#define FEFREE(fe) \ +{ \ + register struct FTAMacelement *FE, \ + *FN; \ + \ + for (FE = (fe); FE; FE = FN) { \ + FN = FE -> fe_next; \ + \ + if (FE -> fe_identity) \ + free (FE -> fe_identity), FE -> fe_identity = NULL; \ + \ + FPFREE (&FE -> fe_passwords); \ + \ + if (FE -> fe_aet) { \ + AEIFREE (FE -> fe_aet); \ + free ((char *) FE -> fe_aet), FE -> fe_aet = NULL; \ + } \ + \ + FE -> fe_next = NULL; \ + \ + free ((char *) FE); \ + } \ +} + +/* */ + +struct FTAMattributes { /* {Change,Create,Read,Select}-Attributes */ + long fa_present; /* values present */ + long fa_novalue; /* no value available */ +#define FA_NULL 0x00000 +#define FA_FILENAME 0x00001 /* filename */ +#define FA_ACTIONS 0x00002 /* permitted-actions */ +#define FA_CONTENTS 0x00004 /* contents-type */ +#define FA_ACCOUNT 0x00008 /* account */ +#define FA_DATE_CREATE 0x00010 /* date-and-time-of-creation */ +#define FA_DATE_MODIFY 0x00020 /* date-and-time-of-last-modification */ +#define FA_DATE_READ 0x00040 /* date-and-time-of-last-read-access */ +#define FA_DATE_ATTR 0x00080 /* date-and-time-of-last-attribute-modification */ +#define FA_ID_CREATE 0x00100 /* identity-of-creator */ +#define FA_ID_MODIFY 0x00200 /* identity-of-last-modifier */ +#define FA_ID_READ 0x00400 /* identity-of-last-reader */ +#define FA_ID_ATTR 0x00800 /* identity-of-last-attribute-modifier */ +#define FA_AVAILABILITY 0x01000 /* file-availability */ +#define FA_FILESIZE 0x02000 /* filesize */ +#define FA_FUTURESIZE 0x04000 /* future-filesize */ +#define FA_CONTROL 0x08000 /* access-control */ +#define FA_LEGAL 0x10000 /* legal-qualifications */ +#define FA_PRIVATE 0x20000 /* private-use */ + +#define FA_KERNEL (FA_FILENAME | FA_ACTIONS | FA_CONTENTS) +#define FA_STORAGE (FA_ACCOUNT | FA_DATE_CREATE | FA_DATE_MODIFY \ + | FA_DATE_READ | FA_DATE_ATTR | FA_ID_CREATE \ + | FA_ID_MODIFY | FA_ID_READ | FA_ID_ATTR \ + | FA_AVAILABILITY | FA_FILESIZE | FA_FUTURESIZE) +#define FA_SECURITY (FA_CONTROL | FA_LEGAL) + +#define NFFILE 5 /* arbitrary */ + int fa_nfile; /* filename */ + char *fa_files[NFFILE]; /* .. */ + + int fa_permitted; /* permitted-actions, + same as fe_actions, plus: */ +#define FA_PERM_TRAV 0x0100 /* traversal */ +#define FA_PERM_RVTRAV 0x0200 /* reverse-traversal */ +#define FA_PERM_RANDOM 0x0400 /* random-order */ +#define FA_PERM_TRAVERSAL (FA_PERM_TRAV | FA_PERM_RVTRAV \ + | FA_PERM_RANDOM) + + OID fa_contents; /* contents-type */ + PE fa_parameter; /* .. parameter */ + + char *fa_account; /* account */ + + /* date-and-time-of- ... */ + struct UTCtime fa_date_create; + struct UTCtime fa_date_modify; + struct UTCtime fa_date_read; + struct UTCtime fa_date_attribute; + + /* identity-of- ... */ + char *fa_id_create; + char *fa_id_modify; + char *fa_id_read; + char *fa_id_attribute; + + int fa_availability; /* file-availability */ +#define FA_AVAIL_IMMED 0 /* immediate */ +#define FA_AVAIL_DEFER 1 /* deferred */ + + int fa_filesize; /* filesize */ + int fa_futuresize; /* future-filesize */ + + struct FTAMacelement *fa_control;/* access-control */ + char *fa_legal; /* legal-qualification */ + + char *fa_private; /* XXX */ +}; + +void FAFREE (); + +/* */ + +struct FADUidentity { /* FADU-Identity */ + int fa_type; +#define FA_FIRSTLAST 0 /* first-last */ +#define FA_RELATIVE 1 /* relative */ +#define FA_BEGINEND 2 /* begin-end */ +#define FA_SINGLE 3 /* single-name */ +#define FA_NAMELIST 4 /* name-list */ +#define FA_FADUNUMBER 5 /* fadu-number */ + + union { + int fa_un_firstlast; +#define FA_FIRST 0 +#define FA_LAST 1 + + int fa_un_relative; +#define FA_PREVIOUS 0 +#define FA_CURRENT 1 +#define FA_NEXT 2 + + int fa_un_beginend; +#define FA_BEGIN 0 +#define FA_END 1 + + char *fa_un_singlename; + +#define NANAME 5 /* arbitrary */ + struct { + char *fa_un_names[NANAME]; + int fa_un_nname; + } fa_un_list; + + int fa_un_fadunumber; + } fa_un; +#define fa_firstlast fa_un.fa_un_firstlast +#define fa_relative fa_un.fa_un_relative +#define fa_beginend fa_un.fa_un_beginend +#define fa_singlename fa_un.fa_un_singlename +#define fa_names fa_un.fa_un_list.fa_un_names +#define fa_nname fa_un.fa_un_list.fa_un_nname +#define fa_fadunumber fa_un.fa_un_fadunumber +}; +#define FUFREE(fu) \ +{ \ + register int FUI; \ + \ + if ((fu) -> fa_singlename) \ + free ((fu) -> fa_singlename), (fu) -> fa_singlename = NULL; \ + \ + for (FUI = (fu) -> fa_nname - 1; FUI >= 0; FUI--) \ + if ((fu) -> fa_names[FUI]) \ + free ((fu) -> fa_names[FUI]), (fu) -> fa_names[FUI] = NULL; \ +} + +/* */ + +struct FTAMstart { /* F-INITIALIZE.INDICATION */ + int fts_sd; /* FTAM descriptor */ + + AEInfo fts_callingtitle; /* info on calling application-entity */ + AEInfo fts_calledtitle; /* info called application-entity */ + + struct PSAPaddr fts_calledaddr;/* called presentation address */ + struct PSAPaddr fts_callingaddr;/* calling presentation address */ + + OID fts_context; /* application context name */ + + int fts_manage; /* presentation-context-management */ + + int fts_class; /* service-class */ + + int fts_units; /* functional-units */ + int fts_attrs; /* attribute-groups */ + + PE fts_sharedASE; /* shared-ASE-information */ + + int fts_fqos; /* ftam-QoS */ + + struct FTAMcontentlist fts_contents;/* contents-type-list */ + + char *fts_initiator; /* initiator-identity */ + char *fts_account; /* account */ + char *fts_password; /* filestore-password */ + int fts_passlen; /* .. */ + + int fts_ssdusize; /* largest atomic SSDU */ + + struct QOStype fts_qos; /* Communications QoS */ +}; +#define FTSFREE(fts) \ +{ \ + register int FSI; \ + \ + AEIFREE (&(fts) -> fts_callingtitle); \ + AEIFREE (&(fts) -> fts_calledtitle); \ + if ((fts) -> fts_context) \ + oid_free ((fts) -> fts_context), (fts) -> fts_context = NULLOID; \ + \ + if ((fts) -> fts_sharedASE) \ + pe_free ((fts) -> fts_sharedASE), (fts) -> fts_sharedASE = NULLPE; \ + \ + for (FSI = (fts) -> fts_contents.fc_ncontent - 1; FSI >= 0; FSI--) \ + oid_free ((fts) -> fts_contents.fc_contents[FSI].fc_dtn), \ + (fts) -> fts_contents.fc_contents[FSI].fc_dtn = NULLOID; \ + (fts) -> fts_contents.fc_ncontent = 0; \ + \ + if ((fts) -> fts_initiator) \ + free ((fts) -> fts_initiator), (fts) -> fts_initiator = NULL; \ + if ((fts) -> fts_account) \ + free ((fts) -> fts_account), (fts) -> fts_account = NULL; \ + if ((fts) -> fts_password) \ + free ((fts) -> fts_password), (fts) -> fts_password = NULL; \ +} + + +struct FTAMconnect { /* F-INITIALIZE.CONFIRMATION */ + int ftc_sd; /* FTAM descriptor */ + + AEInfo ftc_respondtitle; /* responding application-entity title */ + + struct PSAPaddr ftc_respondaddr;/* responding presentation address */ + + OID ftc_context; /* application context name */ + + int ftc_state; /* state-result */ + int ftc_action; /* action-result */ + + int ftc_manage; /* presentation-context-management */ + + int ftc_class; /* service-class */ + + int ftc_units; /* functional-units */ + int ftc_attrs; /* attribute-groups */ + + PE ftc_sharedASE; /* shared-ASE-information */ + + int ftc_fqos; /* ftam-QoS */ + + struct FTAMcontentlist ftc_contents;/* contents-type-list */ + +#define NFDIAG 5 /* diagnostic */ + int ftc_ndiag; + struct FTAMdiagnostic ftc_diags[NFDIAG]; + + int ftc_ssdusize; /* largest atomic SSDU */ + + struct QOStype ftc_qos; /* communications QoS */ +}; +#define FTCFREE(ftc) \ +{ \ + register int FCI; \ + \ + AEIFREE (&(ftc) -> ftc_respondtitle); \ + if ((ftc) -> ftc_context) \ + oid_free ((ftc) -> ftc_context), (ftc) -> ftc_context = NULLOID; \ + \ + if ((ftc) -> ftc_sharedASE) \ + pe_free ((ftc) -> ftc_sharedASE), (ftc) -> ftc_sharedASE = NULLPE; \ + \ + for (FCI = (ftc) -> ftc_contents.fc_ncontent - 1; FCI >= 0; FCI--) \ + oid_free ((ftc) -> ftc_contents.fc_contents[FCI].fc_dtn), \ + (ftc) -> ftc_contents.fc_contents[FCI].fc_dtn = NULLOID; \ + (ftc) -> ftc_contents.fc_ncontent = 0; \ +} + + +struct FTAMfinish { /* F-TERMINATE.INDICATION */ + PE ftf_sharedASE; /* shared-ASE-information */ +}; +#define FTFFREE(ftf) \ +{ \ + if ((ftf) -> ftf_sharedASE) \ + pe_free ((ftf) -> ftf_sharedASE), (ftf) -> ftf_sharedASE = NULLPE; \ +} + +struct FTAMrelease { /* F-TERMINATE.CONFIRMATION */ + PE ftr_sharedASE; /* shared-ASE-information */ + /* charging */ + struct FTAMcharging ftr_charges; +}; +#define FTRFREE(ftr) \ +{ \ + register int FRI; \ + register struct fc_charge *FC; \ + \ + if ((ftr) -> ftr_sharedASE) \ + pe_free ((ftr) -> ftr_sharedASE), (ftr) -> ftr_sharedASE = NULLPE; \ + \ + for (FC = (ftr) -> ftr_charges.fc_charges, FRI = (ftr) -> ftr_charges.fc_ncharge - 1; \ + FRI >= 0; \ + FC++, FRI--) { \ + if (FC -> fc_resource) \ + free (FC -> fc_resource), FC -> fc_resource = NULL; \ + if (FC -> fc_unit) \ + free (FC -> fc_unit), FC -> fc_unit = NULL; \ + } \ + (ftr) -> ftr_charges.fc_ncharge = 0; \ +} + + +struct FTAMabort { /* F-{U,P}-ABORT.INDICATION */ + int fta_peer; /* T = F-U-ABORT.INDICATION + NIL = F-P-ABORT.INDICATION */ + + int fta_action; /* action-result */ + + int fta_ndiag; /* diagnostic */ + struct FTAMdiagnostic fta_diags[NFDIAG]; +}; + + +struct FTAMselect { /* F-SELECT.* */ + /* RESPONSE only */ + int ftse_state; /* state-result */ + int ftse_action; /* action-result */ + + /* attributes (FILENAME only) */ + struct FTAMattributes ftse_attrs; +#define FA_SEL_ATTRS FA_FILENAME + + /* REQUEST only */ + int ftse_access; /* requested-access */ +#define FA_REQ_MASK (FA_PERM_READ | FA_PERM_INSERT | FA_PERM_REPLACE \ + | FA_PERM_EXTEND | FA_PERM_ERASE \ + | FA_PERM_READATTR | FA_PERM_CHNGATTR \ + | FA_PERM_DELETE) + /* access-passwords */ + struct FTAMpasswords ftse_pwds; + /* concurrency-control */ + struct FTAMconcurrency ftse_conctl; + PE ftse_sharedASE; /* shared-ASE-information */ + char *ftse_account; /* account */ + + /* RESPONSE only */ + int ftse_ndiag; /* diagnostic */ + struct FTAMdiagnostic ftse_diags[NFDIAG]; +}; +#define FTSEFREE(ftse) \ +{ \ + FAFREE (&((ftse) -> ftse_attrs)); \ + FPFREE (&((ftse) -> ftse_pwds)); \ + if ((ftse) -> ftse_sharedASE) \ + pe_free ((ftse) -> ftse_sharedASE), (ftse) -> ftse_sharedASE = NULLPE; \ + if ((ftse) -> ftse_account) \ + free ((ftse) -> ftse_account), (ftse) -> ftse_account = NULLCP; \ +} + + +struct FTAMdeselect { /* F-DESELECT.* */ + /* RESPONSE only */ + int ftde_action; /* action-result */ + + PE ftde_sharedASE; /* shared-ASE-information */ + + /* RESPONSE only */ + /* charging */ + struct FTAMcharging ftde_charges; + int ftde_ndiag; /* diagnostic */ + struct FTAMdiagnostic ftde_diags[NFDIAG]; +}; +#define FTDEFREE(ftde) \ +{ \ + register int FDEI; \ + register struct fc_charge *FC; \ + \ + for (FC = (ftde) -> ftde_charges.fc_charges, FDEI = (ftde) -> ftde_charges.fc_ncharge - 1; \ + FDEI >= 0; \ + FC++, FDEI--) { \ + if (FC -> fc_resource) \ + free (FC -> fc_resource), FC -> fc_resource = NULL; \ + if (FC -> fc_unit) \ + free (FC -> fc_unit), FC -> fc_unit = NULL; \ + } \ + (ftde) -> ftde_charges.fc_ncharge = 0; \ + if ((ftde) -> ftde_sharedASE) \ + pe_free ((ftde) -> ftde_sharedASE), (ftde) -> ftde_sharedASE = NULLPE; \ +} + + +struct FTAMcreate { /* F-CREATE.* */ + /* RESPONSE only */ + int ftce_state; /* state-result */ + int ftce_action; /* action-result */ + + /* REQUEST only */ + int ftce_override; /* override */ +#define FOVER_FAIL 0 /* fail, if already exists */ +#define FOVER_SELECT 1 /* select, if it already exists */ +#define FOVER_WRITE 2 /* zero-truncate, if it already exists */ +#define FOVER_DELETE 3 /* delete, if it already exists */ + + /* initial-attributes */ + struct FTAMattributes ftce_attrs; +#define FA_CRE_ATTRS (FA_FILENAME | FA_ACTIONS | FA_CONTENTS | FA_ACCOUNT \ + | FA_AVAILABILITY | FA_FUTURESIZE | FA_CONTROL \ + | FA_LEGAL | FA_PRIVATE) + + /* REQUEST only */ + char *ftce_create; /* create-password */ + int ftce_crelen; /* .. */ + int ftce_access; /* requested-access */ + /* access-passwords */ + struct FTAMpasswords ftce_pwds; + /* concurrency-control */ + struct FTAMconcurrency ftce_conctl; + + PE ftce_sharedASE; /* shared-ASE-information */ + + /* REQUEST only */ + char *ftce_account; /* account */ + + /* RESPONSE only */ + int ftce_ndiag; /* diagnostic */ + struct FTAMdiagnostic ftce_diags[NFDIAG]; +}; +#define FTCEFREE(ftce) \ +{ \ + FAFREE (&((ftce) -> ftce_attrs)); \ + if ((ftce) -> ftce_create) \ + free ((ftce) -> ftce_create), (ftce) -> ftce_create = NULLCP; \ + FPFREE (&((ftce) -> ftce_pwds)); \ + if ((ftce) -> ftce_sharedASE) \ + pe_free ((ftce) -> ftce_sharedASE), (ftce) -> ftce_sharedASE = NULLPE; \ + if ((ftce) -> ftce_account) \ + free ((ftce) -> ftce_account), (ftce) -> ftce_account = NULLCP; \ +} + + +struct FTAMdelete { /* F-DELETE.* */ + /* RESPONSE only */ + int ftxe_action; /* action-result */ + + PE ftxe_sharedASE; /* shared-ASE-information */ + + /* RESPONSE only */ + /* charging */ + struct FTAMcharging ftxe_charges; + int ftxe_ndiag; /* diagnostic */ + struct FTAMdiagnostic ftxe_diags[NFDIAG]; +}; +#define FTXEFREE(ftxe) \ +{ \ + register int FXEI; \ + register struct fc_charge *FC; \ + \ + if ((ftxe) -> ftxe_sharedASE) \ + pe_free ((ftxe) -> ftxe_sharedASE), (ftxe) -> ftxe_sharedASE = NULLPE; \ + \ + for (FC = (ftxe) -> ftxe_charges.fc_charges, FXEI = (ftxe) -> ftxe_charges.fc_ncharge - 1; \ + FXEI >= 0; \ + FC++, FXEI--) { \ + if (FC -> fc_resource) \ + free (FC -> fc_resource), FC -> fc_resource = NULL; \ + if (FC -> fc_unit) \ + free (FC -> fc_unit), FC -> fc_unit = NULL; \ + } \ + (ftxe) -> ftxe_charges.fc_ncharge = 0; \ +} + + +struct FTAMreadattr { /* F-READ-ATTRIB.* */ + /* RESPONSE only */ + int ftra_action; /* action-result */ + + /* REQUEST only */ + int ftra_attrnames; /* attribute names (from fa_present) */ + + /* RESPONSE only */ + struct FTAMattributes ftra_attrs; + int ftra_ndiag; /* diagnostic */ + struct FTAMdiagnostic ftra_diags[NFDIAG]; +}; +#define FTRAFREE(ftra) \ +{ \ + FAFREE (&((ftra) -> ftra_attrs)); \ +} + + +struct FTAMchngattr { /* F-CHANGE-ATTRIB.* */ + /* RESPONSE only */ + int ftca_action; /* action-result */ + + struct FTAMattributes ftca_attrs; +#define FA_CHG_ATTRS (FA_FILENAME | FA_ACCOUNT | FA_AVAILABILITY \ + | FA_FUTURESIZE | FA_CONTROL | FA_LEGAL \ + | FA_PRIVATE) + + /* RESPONSE only */ + int ftca_ndiag; /* diagnostic */ + struct FTAMdiagnostic ftca_diags[NFDIAG]; +}; +#define FTCAFREE(ftca) \ +{ \ + FAFREE (&((ftca) -> ftca_attrs)); \ +} + + +struct FTAMopen { /* F-OPEN.* */ + /* RESPONSE only */ + int ftop_state; /* state-result */ + int ftop_action; /* action-result */ + + /* REQUEST only */ + int ftop_mode; /* processing-mode (read..erase) */ +#define FA_MODE_MASK (FA_PERM_READ | FA_PERM_INSERT | FA_PERM_REPLACE \ + | FA_PERM_EXTEND | FA_PERM_ERASE) + + OID ftop_contents; /* contents-type */ + PE ftop_parameter; /* .. */ + /* concurrency-control */ + struct FTAMconcurrency ftop_conctl; + PE ftop_sharedASE; /* shared-ASE-information */ + + /* REQUEST only */ + int ftop_locking; /* enable-fadu-locking */ + + /* RESPONSE only */ + int ftop_ndiag; /* diagnostic */ + struct FTAMdiagnostic ftop_diags[NFDIAG]; +}; +#define FTOPFREE(ftop) \ +{ \ + if ((ftop) -> ftop_contents) \ + oid_free ((ftop) -> ftop_contents), \ + (ftop) -> ftop_contents = NULLOID; \ + if ((ftop) -> ftop_parameter) \ + pe_free ((ftop) -> ftop_parameter), \ + (ftop) -> ftop_parameter = NULLPE; \ + if ((ftop) -> ftop_sharedASE) \ + pe_free ((ftop) -> ftop_sharedASE), (ftop) -> ftop_sharedASE = NULLPE; \ +} + + +struct FTAMclose { /* F-CLOSE.* */ + int ftcl_action; /* action-result */ + + PE ftcl_sharedASE; /* shared-ASE-information */ + + int ftcl_ndiag; /* diagnostic */ + struct FTAMdiagnostic ftcl_diags[NFDIAG]; +}; +#define FTCLFREE(ftcl) \ +{ \ + if ((ftcl) -> ftcl_sharedASE) \ + pe_free ((ftcl) -> ftcl_sharedASE), (ftcl) -> ftcl_sharedASE = NULLPE; \ +} + + +struct FTAMgroup { + int ftg_threshold; /* threshold */ + + int ftg_flags; +#define FTG_NULL 0x0000 +#define FTG_BEGIN 0x0001 /* have begin */ +#define FTG_SELECT 0x0002 /* .. select */ +#define FTG_CREATE 0x0004 /* .. create */ +#define FTG_RDATTR 0x0008 /* .. read attribute */ +#define FTG_CHATTR 0x0010 /* .. change attribute */ +#define FTG_OPEN 0x0020 /* .. open */ +#define FTG_CLOSE 0x0040 /* .. close */ +#define FTG_DESELECT 0x0080 /* .. deselect */ +#define FTG_DELETE 0x0100 /* .. delete */ +#define FTG_END 0x0200 /* .. end */ + + union { + struct FTAMselect ftg_un1_select; + struct FTAMcreate ftg_un1_create; + struct FTAMclose ftg_un1_close; + } ftg_un1; +#define ftg_select ftg_un1.ftg_un1_select +#define ftg_create ftg_un1.ftg_un1_create +#define ftg_close ftg_un1.ftg_un1_close + + struct FTAMreadattr ftg_readattr; + + struct FTAMchngattr ftg_chngattr; + + union { + struct FTAMdeselect ftg_un2_deselect; + struct FTAMdelete ftg_un2_delete; + struct FTAMopen ftg_un2_open; + } ftg_un2; +#define ftg_deselect ftg_un2.ftg_un2_deselect +#define ftg_delete ftg_un2.ftg_un2_delete +#define ftg_open ftg_un2.ftg_un2_open +}; +#define FTGFREE(ftg) \ +{ \ + if ((ftg) -> ftg_flags & FTG_SELECT) { \ + FTSEFREE (&((ftg) -> ftg_select)); \ + } \ + else \ + if ((ftg) -> ftg_flags & FTG_CREATE) { \ + FTCEFREE (&((ftg) -> ftg_create)); \ + } \ + else \ + if ((ftg) -> ftg_flags & FTG_CLOSE) \ + FTCLFREE (&((ftg) -> ftg_close)); \ + \ + if ((ftg) ->ftg_flags & FTG_RDATTR) \ + FTRAFREE (&((ftg) -> ftg_readattr)); \ + \ + if ((ftg) ->ftg_flags & FTG_CHATTR) \ + FTCAFREE (&((ftg) -> ftg_chngattr)); \ + \ + if ((ftg) -> ftg_flags & FTG_DESELECT) { \ + FTDEFREE (&((ftg) -> ftg_deselect)); \ + } \ + else \ + if ((ftg) -> ftg_flags & FTG_DELETE) { \ + FTXEFREE (&((ftg) -> ftg_delete)); \ + } \ + else \ + if ((ftg) -> ftg_flags & FTG_OPEN) \ + FTOPFREE (&((ftg) -> ftg_open)); \ +} + + +struct FTAMaccess { /* F-{LOCATE,ERASE}.{INDICATION,CONFIRMATION} */ + int ftac_operation; +#define FA_OPS_LOCATE 0 /* locate */ +#define FA_OPS_ERASE 1 /* erase */ + + /* CONFIRMATION only */ + int ftac_action; /* action-result */ + + /* *.INDICATION OR F-LOCATE.CONFIRMATION */ + /* fadu-identity */ + struct FADUidentity ftac_identity; + + /* F-LOCATE.INDICATION only */ + int ftac_locking; /* fadu-lock (on, off) */ + + /* CONFIRMATION only */ + int ftac_ndiag; /* diagnostic */ + struct FTAMdiagnostic ftac_diags[NFDIAG]; +}; +#define FTACFREE(ftac) \ +{ \ + FUFREE (&((ftac) -> ftac_identity)); \ +} + + +struct FTAMreadwrite { /* F-{READ,WRITE}.INDICATION */ + int ftrw_operation; /* fadu-operation */ +#define FA_OPS_READ (-1) /* read (pseudo) */ +#define FA_OPS_INSERT 0 /* insert */ +#define FA_OPS_REPLACE 1 /* replace */ +#define FA_OPS_EXTEND 2 /* extend */ + + /* fadu-identity */ + struct FADUidentity ftrw_identity; + + /* F-READ.INDICATION only */ + int ftrw_context; /* access-context */ +#define FA_ACC_HA 0 /* hierarchical-all-data-units */ +#define FA_ACC_HN 1 /* hierarchical-no-data-units */ +#define FA_ACC_FA 2 /* flat-all-data-units */ +#define FA_ACC_FL 3 /* flat-one-level-data-units */ +#define FA_ACC_FS 4 /* flat-single-data-unit */ +#define FA_ACC_UA 5 /* unstructured-all-data-units */ +#define FA_ACC_US 6 /* unstructured-single-data-unit */ + int ftrw_level; /* level for FL */ + + int ftrw_locking; /* fadu-lock */ +}; +#define FTRWFREE(ftrw) \ +{ \ + FUFREE (&((ftrw) -> ftrw_identity)); \ +} + + +struct FTAMdataend { /* F-DATA-END.INDICATION */ + int ftda_action; /* action-result */ + + int ftda_ndiag; /* diagnostic */ + struct FTAMdiagnostic ftda_diags[NFDIAG]; +}; + + +struct FTAMtransend { /* F-TRANSFER-END.{INDICATION,CONFIRMATION} */ + /* RESPONSE only */ + int ftre_action; /* action-result */ + + PE ftre_sharedASE; /* shared-ASE-information */ + + /* RESPONSE only */ + int ftre_ndiag; /* diagnostic */ + struct FTAMdiagnostic ftre_diags[NFDIAG]; +}; +#define FTREFREE(ftre) \ +{ \ + if ((ftre) -> ftre_sharedASE) \ + pe_free ((ftre) -> ftre_sharedASE), (ftre) -> ftre_sharedASE = NULLPE; \ +} + + +struct FTAMcancel { /* F-CANCEL.{INDICATION,CONFIRMATION} */ + int ftcn_action; /* action-result */ + + PE ftcn_sharedASE; /* shared-ASE-information */ + + int ftcn_ndiag; /* diagnostic */ + struct FTAMdiagnostic ftcn_diags[NFDIAG]; +}; +#define FTCNFREE(ftcn) \ +{ \ + if ((ftcn) -> ftcn_sharedASE) \ + pe_free ((ftcn) -> ftcn_sharedASE), (ftcn) -> ftcn_sharedASE = NULLPE; \ +} + + +struct FTAMindication { + int fti_type; /* the union element present */ +#define FTI_FINISH 0x00 +#define FTI_ABORT 0x01 +#define FTI_MANAGEMENT 0x02 +#define FTI_BULKBEGIN 0x03 +#define FTI_BULKEND 0x04 +#define FTI_ACCESS 0x05 +#define FTI_READWRITE 0x06 +#define FTI_DATA 0x07 +#define FTI_DATAEND 0x08 +#define FTI_CANCEL 0x09 +#define FTI_TRANSEND 0x10 + + union { + struct FTAMfinish fti_un_finish; + struct FTAMabort fti_un_abort; + struct FTAMgroup fti_un_group; + struct FTAMaccess fti_un_access; + struct FTAMreadwrite fti_un_readwrite; + struct PSAPdata fti_un_data; + struct FTAMdataend fti_un_dataend; + struct FTAMcancel fti_un_cancel; + struct FTAMtransend fti_un_transend; + } fti_un; +#define fti_finish fti_un.fti_un_finish +#define fti_abort fti_un.fti_un_abort +#define fti_group fti_un.fti_un_group +#define fti_access fti_un.fti_un_access +#define fti_readwrite fti_un.fti_un_readwrite +#define fti_data fti_un.fti_un_data +#define fti_dataend fti_un.fti_un_dataend +#define fti_cancel fti_un.fti_un_cancel +#define fti_transend fti_un.fti_un_transend +}; + +/* when FTAMindication has PSAPdata, the pe_context indicates whether + each data is from the FTAM PCI or is a data element. + + FTAM PCI - PE_DFLT_CTX + + data element - anything else + + three different types of data in the FTAM PCI are handled by the user: + + Node-Descriptor-Data-Element ::= [APPLICATION 0] ... + Enter-Subtree-Data-Element ::= [APPLICATION 1] ... + Exit-Subtree-Data-Element ::= [APPLICATION 2] ... + */ + +#define FADU_NODESCR 0 /* Node-Descriptor-Data-Element */ +#define FADU_ENTERTREE 1 /* Enter-Subtree-Data-Element */ +#define FADU_EXITREE 2 /* Exit-Subtree-Data-Element */ + +/* */ + +extern char *ftamversion; + +extern LLog _ftam_log, *ftam_log; + + +int FInit (); /* F-INITIALIZE.INDICATION */ +int FInitializeResponse (); /* F-INITIALIZE.RESPONSE */ +int FInitializeRequest (); /* F-INITIALIZE.REQUEST */ +int FTerminateRequest (); /* F-TERMINATE.REQUEST */ +int FTerminateResponse (); /* F-TERMINATE.RESPONSE */ +int FUAbortRequest (); /* F-U-ABORT.REQUEST */ + +int FWaitRequest (); /* F-WAIT.REQUEST (pseudo) */ + +int FManageRequest (); /* F-MANAGE.REQUEST (group) */ +int FManageResponse (); /* F-MANAGE.RESPONSE (group) */ +int FBulkBeginRequest (); /* F-BULK-BEGIN.REQUEST (group) */ +int FBulkBeginResponse (); /* F-BULK-BEGIN.RESPONSE (group) */ +int FBulkEndRequest (); /* F-BULK-END.REQUEST (group) */ +int FBulkEndResponse (); /* F-BULK-END.RESPONSE (group) */ + +int FAccessRequest (); /* F-{LOCATE,ERASE}.REQUEST */ +int FAccessResponse (); /* F-{LOCATE,ERASE}.RESPONSE */ + +int FReadWriteRequest (); /* F-{READ,WRITE}.REQUEST */ +int FDataRequest (); /* F-DATA.REQUEST */ +int FDataEndRequest (); /* F-DATA-END.REQUEST */ +int FCancelRequest (); /* F-CANCEL.REQUEST */ +int FCancelResponse (); /* F-CANCEL.RESPONSE */ +int FTransEndRequest (); /* F-TRANSFER-END.REQUEST */ +int FTransEndResponse (); /* F-TRANSFER-END.RESPONSE */ + +int FSetIndications (); /* define vector for INDICATION events */ +int FSelectMask (); /* map ftam descriptors for select() */ + +int FHookRequest (); /* set tracing */ +int FTraceHook (); /* user-defined tracing */ + +char *FErrString (); /* return FTAM error code in string form */ + +/* */ + +struct isodocument { + char *id_entry; + + OID id_type; + + OID id_abstract; + OID id_transfer; + OID id_model; + OID id_constraint; +}; + +int setisodocument (), endisodocument (); + +struct isodocument *getisodocument (); + +struct isodocument *getisodocumentbyentry (); +struct isodocument *getisodocumentbytype (); + +#endif |