[unix-history] / .ref-BSD-4_3_Net_2 / usr / src / contrib / isode / ftam / ftambulk1.c

/* ftambulk1.c - FPM: initiate bulk data transfer */

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

/* 
 * $Header: /f/osi/ftam/RCS/ftambulk1.c,v 7.1 91/02/22 09:22:42 mrose Interim $
 *
 *
 * $Log:	ftambulk1.c,v $
 * Revision 7.1  91/02/22  09:22:42  mrose
 * Interim 6.8
 * 
 * Revision 7.0  89/11/23  21:53:27  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"

/* \f   F-{READ,WRITE}.REQUEST */

int	FReadWriteRequest (sd, operation, identity, context, level, lock, fti)
int	sd;
int	operation;
struct FADUidentity *identity;
int	context,		/* F-READ.REQUEST only */
	level,			/*   .. */
    	lock;
struct FTAMindication *fti;
{
    SBV      smask;
    int     result,
	    state;
    register struct ftamblk *fsb;

    switch (operation) {
	case FA_OPS_READ: 
	    state = FSB_DATAREAD;
	    break;

	case FA_OPS_INSERT: 
	case FA_OPS_REPLACE: 
	case FA_OPS_EXTEND: 
	    state = FSB_DATAWRITE;
	    break;

	default: 
	    return ftamlose (fti, FS_GEN_NOREASON, 0, NULLCP,
		    "bad value for operation parameter");
    }
    missingP (identity);
    if (operation == FA_OPS_READ)
	switch (context) {
	    case FA_ACC_HA: 
	    case FA_ACC_HN: 
	    case FA_ACC_FA: 
	    case FA_ACC_FL: 
	    case FA_ACC_FS: 
	    case FA_ACC_UA: 
	    case FA_ACC_US: 
	        break;

	    default:
		return ftamlose (fti, FS_GEN_NOREASON, 0, NULLCP,
				 "bad value for context parameter");
	}
    missingP (fti);

    smask = sigioblock ();

    ftamPsig (fsb, sd);

    result = FReadWriteRequestAux (fsb, state, operation, identity, context,
			level, lock, fti);

    (void) sigiomask (smask);

    return result;
}

/* \f */

static int  FReadWriteRequestAux (fsb, state, operation, identity, context,
		level, lock, fti)
register struct ftamblk *fsb;
int	state,
	operation;
struct FADUidentity *identity;
int	context,
	level,
    	lock;
struct FTAMindication *fti;
{
    int     result;
    char   *fpdu;
    PE	    pe;
    struct PSAPindication   pis;
    struct PSAPindication  *pi = &pis;
    struct PSAPabort   *pa = &pi -> pi_abort;
    register struct type_FTAM_PDU *pdu;
    register struct type_FTAM_F__READ__request *rd;
    register struct type_FTAM_F__WRITE__request *wr;

    if (!(fsb -> fsb_flags & FSB_INIT))
	return ftamlose (fti, FS_GEN (fsb), 0, NULLCP, "not initiator");
    if (fsb -> fsb_state != FSB_DATAIDLE)
	return ftamlose (fti, FS_GEN (fsb), 0, NULLCP, "wrong state");

    switch (state) {
	case FSB_DATAREAD:
	    if (!(fsb -> fsb_units & FUNIT_READ))
		return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
			    "reading not allowed");
	    break;

	case FSB_DATAWRITE:
	    if (!(fsb -> fsb_units & FUNIT_WRITE))
		return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
			    "writing not allowed");
	    break;
    }

    pe = NULLPE;
    if ((pdu = (struct type_FTAM_PDU *) calloc (1, sizeof *pdu)) == NULL) {
no_mem: ;
	(void) ftamlose (fti, FS_GEN (fsb), 1, NULLCP, "out of memory");
out: ;
	if (pe)
	    pe_free (pe);
	if (pdu)
	    free_FTAM_PDU (pdu);
	if (fti -> fti_abort.fta_action == FACTION_PERM)
	    freefsblk (fsb);
	return NOTOK;
    }
    if (state != FSB_DATAREAD) {
	pdu -> offset = type_FTAM_PDU_f__write__request;
	if ((wr = (struct type_FTAM_F__WRITE__request *)
	     		calloc (1, sizeof *wr)) == NULL)
	    goto no_mem;
	pdu -> un.f__write__request = wr;
	fpdu = "F-WRITE-request";

	wr -> file__access__data__unit__operation = operation;
	if ((wr -> file__access__data__unit__identity =
			faduid2fpm (fsb, identity, fti)) == NULL)
	    goto out;
	if (fsb -> fsb_units & FUNIT_FADULOCK) {
	    if ((wr -> fadu__lock = (struct type_FTAM_FADU__Lock *)
					calloc (1, sizeof *wr -> fadu__lock))
		    == NULL)
		goto no_mem;
	    wr -> fadu__lock -> parm = lock ? int_FTAM_FADU__Lock_on
					    : int_FTAM_FADU__Lock_off;
	}
    }
    else {
	pdu -> offset = type_FTAM_PDU_f__read__request;
	if ((rd = (struct type_FTAM_F__READ__request *)
	     		calloc (1, sizeof *rd)) == NULL)
	    goto no_mem;
	pdu -> un.f__read__request = rd;
	fpdu = "F-READ-request";

	if ((rd -> file__access__data__unit__identity =
			faduid2fpm (fsb, identity, fti)) == NULL)
	    goto out;
	if ((rd -> access__context =
			(struct type_FTAM_Access__Context *)
	     			calloc (1, sizeof *rd -> access__context))
	        == NULL)
	    goto no_mem;
	if ((rd -> access__context -> access__context = context)
	        == FA_ACC_FL) {
	    rd -> access__context -> optionals |=
					opt_FTAM_Access__Context_level__number;
	    rd -> access__context -> level__number = level;
	}

	if (fsb -> fsb_units & FUNIT_FADULOCK) {
	    if ((rd -> fadu__lock = (struct type_FTAM_FADU__Lock *)
					calloc (1, sizeof *wr -> fadu__lock))
		    == NULL)
		goto no_mem;
	    rd -> fadu__lock -> parm = lock ? int_FTAM_FADU__Lock_on
					    : int_FTAM_FADU__Lock_off;
	}
    }

    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 out;
    }

    pe -> pe_context = fsb -> fsb_id;

    fsbtrace (fsb, (fsb -> fsb_fd, "P-DATA.REQUEST", fpdu, pe, 0));

    result = PDataRequest (fsb -> fsb_fd, &pe, 1, pi);

    pe_free (pe);
    pe = NULLPE;
    free_FTAM_PDU (pdu);
    pdu = NULL;

    if (result == NOTOK) {
	(void) ps2ftamlose (fsb, fti, "PDataRequest", pa);
	goto out;
    }

    fsb -> fsb_state = state;

    return OK;
}

/* \f   F-TRANSFER-END.REQUEST */

int	FTransEndRequest (sd, sharedASE, fti)
int	sd;
PE	sharedASE;
struct FTAMindication *fti;
{
    SBV	    smask;
    int     result;
    register struct ftamblk *fsb;

    missingP (fti);

    smask = sigioblock ();

    ftamPsig (fsb, sd);

    result = FTransEndRequestAux (fsb, sharedASE, fti);

    (void) sigiomask (smask);

    return result;
}


/* \f */

static int  FTransEndRequestAux (fsb, sharedASE, fti)
register struct ftamblk *fsb;
PE	sharedASE;
struct FTAMindication *fti;
{
    int	    result;
    PE	    pe;
    struct PSAPindication   pis;
    struct PSAPindication  *pi = &pis;
    struct PSAPabort   *pa = &pi -> pi_abort;
    register struct type_FTAM_PDU *pdu;

    if (!(fsb -> fsb_flags & FSB_INIT))
	return ftamlose (fti, FS_GEN (fsb), 0, NULLCP, "not initiator");
    if (fsb -> fsb_state != FSB_DATAFIN1)
	return ftamlose (fti, FS_GEN (fsb), 0, NULLCP, "wrong state");

    pe = NULLPE;
    if ((pdu = (struct type_FTAM_PDU *) calloc (1, sizeof *pdu)) == NULL) {
	(void) ftamlose (fti, FS_GEN (fsb), 1, NULLCP, "out of memory");
out: ;
	if (pe)
	    pe_free (pe);
	if (pdu)
	    free_FTAM_PDU (pdu);
	if (fti -> fti_abort.fta_action == FACTION_PERM)
	    freefsblk (fsb);
	return NOTOK;
    }
    pdu -> offset = type_FTAM_PDU_f__transfer__end__request;
    if (sharedASE
	    && (pdu -> un.f__transfer__end__request =
			shared2fpm (fsb, sharedASE, fti)) == NULL)
	goto out;

    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 out;
    }

    pe -> pe_context = fsb -> fsb_id;
    
    fsbtrace (fsb, (fsb -> fsb_fd, "P-DATA.REQUEST", "F-TRANSFER-END-request",
		pe, 0));

    result = PDataRequest (fsb -> fsb_fd, &pe, 1, pi);

    pe_free (pe);
    pe = NULLPE;
    free_FTAM_PDU (pdu);
    pdu = NULL;


    if (result == NOTOK) {
	(void) ps2ftamlose (fsb, fti, "PDataRequest", pa);
	goto out;
    }

    fsb -> fsb_state = FSB_DATAFIN2;

    return FWaitRequestAux (fsb, NOTOK, fti);
}
Commit	Line	Data
53102063 C	1	/* ftambulk1.c - FPM: initiate bulk data transfer */
	2
	3	#ifndef lint
	4	static char *rcsid = "$Header: /f/osi/ftam/RCS/ftambulk1.c,v 7.1 91/02/22 09:22:42 mrose Interim $";
	5	#endif
	6
	7	/*
	8	* $Header: /f/osi/ftam/RCS/ftambulk1.c,v 7.1 91/02/22 09:22:42 mrose Interim $
	9	*
	10	*
	11	* $Log: ftambulk1.c,v $
	12	* Revision 7.1 91/02/22 09:22:42 mrose
	13	* Interim 6.8
	14	*
	15	* Revision 7.0 89/11/23 21:53:27 mrose
	16	* Release 6.0
	17	*
	18	*/
	19
	20	/*
	21	* NOTICE
	22	*
	23	* Acquisition, use, and distribution of this module and related
	24	* materials are subject to the restrictions of a license agreement.
	25	* Consult the Preface in the User's Manual for the full terms of
	26	* this agreement.
	27	*
	28	*/
	29
	30
	31	/* LINTLIBRARY */
	32
	33	#include <stdio.h>
	34	#include <signal.h>
	35	#include "fpkt.h"
	36
	37	/* \f F-{READ,WRITE}.REQUEST */
	38
	39	int FReadWriteRequest (sd, operation, identity, context, level, lock, fti)
	40	int sd;
	41	int operation;
	42	struct FADUidentity *identity;
	43	int context, /* F-READ.REQUEST only */
	44	level, /* .. */
	45	lock;
	46	struct FTAMindication *fti;
	47	{
	48	SBV smask;
	49	int result,
	50	state;
	51	register struct ftamblk *fsb;
	52
	53	switch (operation) {
	54	case FA_OPS_READ:
	55	state = FSB_DATAREAD;
	56	break;
	57
	58	case FA_OPS_INSERT:
	59	case FA_OPS_REPLACE:
	60	case FA_OPS_EXTEND:
	61	state = FSB_DATAWRITE;
	62	break;
	63
	64	default:
65	return ftamlose (fti, FS_GEN_NOREASON, 0, NULLCP,
66	"bad value for operation parameter");
67	}
68	missingP (identity);
69	if (operation == FA_OPS_READ)
70	switch (context) {
71	case FA_ACC_HA:
72	case FA_ACC_HN:
73	case FA_ACC_FA:
74	case FA_ACC_FL:
75	case FA_ACC_FS:
76	case FA_ACC_UA:
77	case FA_ACC_US:
78	break;
79
80	default:
81	return ftamlose (fti, FS_GEN_NOREASON, 0, NULLCP,
82	"bad value for context parameter");
83	}
84	missingP (fti);
85
86	smask = sigioblock ();
87
88	ftamPsig (fsb, sd);
89
90	result = FReadWriteRequestAux (fsb, state, operation, identity, context,
91	level, lock, fti);
92
93	(void) sigiomask (smask);
94
95	return result;
96	}
97
98	/* \f */
99
100	static int FReadWriteRequestAux (fsb, state, operation, identity, context,
101	level, lock, fti)
102	register struct ftamblk *fsb;
103	int state,
104	operation;
105	struct FADUidentity *identity;
106	int context,
107	level,
108	lock;
109	struct FTAMindication *fti;
110	{
111	int result;
112	char *fpdu;
113	PE pe;
114	struct PSAPindication pis;
115	struct PSAPindication *pi = &pis;
116	struct PSAPabort *pa = &pi -> pi_abort;
117	register struct type_FTAM_PDU *pdu;
118	register struct type_FTAM_F__READ__request *rd;
119	register struct type_FTAM_F__WRITE__request *wr;
120
121	if (!(fsb -> fsb_flags & FSB_INIT))
122	return ftamlose (fti, FS_GEN (fsb), 0, NULLCP, "not initiator");
123	if (fsb -> fsb_state != FSB_DATAIDLE)
124	return ftamlose (fti, FS_GEN (fsb), 0, NULLCP, "wrong state");
125
126	switch (state) {
127	case FSB_DATAREAD:
128	if (!(fsb -> fsb_units & FUNIT_READ))
129	return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
130	"reading not allowed");
131	break;
132
133	case FSB_DATAWRITE:
134	if (!(fsb -> fsb_units & FUNIT_WRITE))
135	return ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
136	"writing not allowed");
137	break;
138	}
139
140	pe = NULLPE;
141	if ((pdu = (struct type_FTAM_PDU ) calloc (1, sizeof pdu)) == NULL) {
142	no_mem: ;
143	(void) ftamlose (fti, FS_GEN (fsb), 1, NULLCP, "out of memory");
144	out: ;
145	if (pe)
146	pe_free (pe);
147	if (pdu)
148	free_FTAM_PDU (pdu);
149	if (fti -> fti_abort.fta_action == FACTION_PERM)
150	freefsblk (fsb);
151	return NOTOK;
152	}
153	if (state != FSB_DATAREAD) {
154	pdu -> offset = type_FTAM_PDU_f__write__request;
155	if ((wr = (struct type_FTAM_F__WRITE__request *)
156	calloc (1, sizeof *wr)) == NULL)
157	goto no_mem;
158	pdu -> un.f__write__request = wr;
159	fpdu = "F-WRITE-request";
160
161	wr -> file__access__data__unit__operation = operation;
162	if ((wr -> file__access__data__unit__identity =
163	faduid2fpm (fsb, identity, fti)) == NULL)
164	goto out;
165	if (fsb -> fsb_units & FUNIT_FADULOCK) {
166	if ((wr -> fadu__lock = (struct type_FTAM_FADU__Lock *)
167	calloc (1, sizeof *wr -> fadu__lock))
168	== NULL)
169	goto no_mem;
170	wr -> fadu__lock -> parm = lock ? int_FTAM_FADU__Lock_on
171	: int_FTAM_FADU__Lock_off;
172	}
173	}
174	else {
175	pdu -> offset = type_FTAM_PDU_f__read__request;
176	if ((rd = (struct type_FTAM_F__READ__request *)
177	calloc (1, sizeof *rd)) == NULL)
178	goto no_mem;
179	pdu -> un.f__read__request = rd;
180	fpdu = "F-READ-request";
181
182	if ((rd -> file__access__data__unit__identity =
183	faduid2fpm (fsb, identity, fti)) == NULL)
184	goto out;
185	if ((rd -> access__context =
186	(struct type_FTAM_Access__Context *)
187	calloc (1, sizeof *rd -> access__context))
188	== NULL)
189	goto no_mem;
190	if ((rd -> access__context -> access__context = context)
191	== FA_ACC_FL) {
192	rd -> access__context -> optionals \|=
193	opt_FTAM_Access__Context_level__number;
194	rd -> access__context -> level__number = level;
195	}
196
197	if (fsb -> fsb_units & FUNIT_FADULOCK) {
198	if ((rd -> fadu__lock = (struct type_FTAM_FADU__Lock *)
199	calloc (1, sizeof *wr -> fadu__lock))
200	== NULL)
201	goto no_mem;
202	rd -> fadu__lock -> parm = lock ? int_FTAM_FADU__Lock_on
203	: int_FTAM_FADU__Lock_off;
204	}
205	}
206
207	if (encode_FTAM_PDU (&pe, 1, 0, NULLCP, pdu) == NOTOK) {
208	(void) ftamlose (fti, FS_GEN (fsb), 1, NULLCP,
209	"error encoding PDU: %s", PY_pepy);
210	goto out;
211	}
212
213	pe -> pe_context = fsb -> fsb_id;
214
215	fsbtrace (fsb, (fsb -> fsb_fd, "P-DATA.REQUEST", fpdu, pe, 0));
216
217	result = PDataRequest (fsb -> fsb_fd, &pe, 1, pi);
218
219	pe_free (pe);
220	pe = NULLPE;
221	free_FTAM_PDU (pdu);
222	pdu = NULL;
223
224	if (result == NOTOK) {
225	(void) ps2ftamlose (fsb, fti, "PDataRequest", pa);
226	goto out;
227	}
228
229	fsb -> fsb_state = state;
230
231	return OK;
232	}
233
234	/* \f F-TRANSFER-END.REQUEST */
235
236	int FTransEndRequest (sd, sharedASE, fti)
237	int sd;
238	PE sharedASE;
239	struct FTAMindication *fti;
240	{
241	SBV smask;
242	int result;
243	register struct ftamblk *fsb;
244
245	missingP (fti);
246
247	smask = sigioblock ();
248
249	ftamPsig (fsb, sd);
250
251	result = FTransEndRequestAux (fsb, sharedASE, fti);
252
253	(void) sigiomask (smask);
254
255	return result;
256	}
257
258
259	/* \f */
260
261	static int FTransEndRequestAux (fsb, sharedASE, fti)
262	register struct ftamblk *fsb;
263	PE sharedASE;
264	struct FTAMindication *fti;
265	{
266	int result;
267	PE pe;
268	struct PSAPindication pis;
269	struct PSAPindication *pi = &pis;
270	struct PSAPabort *pa = &pi -> pi_abort;
271	register struct type_FTAM_PDU *pdu;
272
273	if (!(fsb -> fsb_flags & FSB_INIT))
274	return ftamlose (fti, FS_GEN (fsb), 0, NULLCP, "not initiator");
275	if (fsb -> fsb_state != FSB_DATAFIN1)
276	return ftamlose (fti, FS_GEN (fsb), 0, NULLCP, "wrong state");
277
278	pe = NULLPE;
279	if ((pdu = (struct type_FTAM_PDU ) calloc (1, sizeof pdu)) == NULL) {
280	(void) ftamlose (fti, FS_GEN (fsb), 1, NULLCP, "out of memory");
281	out: ;
282	if (pe)
283	pe_free (pe);
284	if (pdu)
285	free_FTAM_PDU (pdu);
286	if (fti -> fti_abort.fta_action == FACTION_PERM)
287	freefsblk (fsb);
288	return NOTOK;
289	}
290	pdu -> offset = type_FTAM_PDU_f__transfer__end__request;
291	if (sharedASE
292	&& (pdu -> un.f__transfer__end__request =
293	shared2fpm (fsb, sharedASE, fti)) == NULL)
294	goto out;
295
296	if (encode_FTAM_PDU (&pe, 1, 0, NULLCP, pdu) == NOTOK) {
297	(void) ftamlose (fti, FS_GEN (fsb), 1, NULLCP,
298	"error encoding PDU: %s", PY_pepy);
299	goto out;
300	}
301
302	pe -> pe_context = fsb -> fsb_id;
303
304	fsbtrace (fsb, (fsb -> fsb_fd, "P-DATA.REQUEST", "F-TRANSFER-END-request",
305	pe, 0));
306
307	result = PDataRequest (fsb -> fsb_fd, &pe, 1, pi);
308
309	pe_free (pe);
310	pe = NULLPE;
311	free_FTAM_PDU (pdu);
312	pdu = NULL;
313
314
315	if (result == NOTOK) {
316	(void) ps2ftamlose (fsb, fti, "PDataRequest", pa);
317	goto out;
318	}
319
320	fsb -> fsb_state = FSB_DATAFIN2;
321
322	return FWaitRequestAux (fsb, NOTOK, fti);
323	}