[moira.git] / gdb / gdb_serv.c

/*
 *	$Source$
 *	$Header$
 */

#ifndef lint
static char *rcsid_gdb_serv_c = "$Header$";
#endif	lint


/************************************************************************/
/*	
/*			   gdb_serv.c
/*	
/*	      GDB - Routines to implement the server/client model
/*		    of connections.
/*	
/*	Author: Noah Mendelsohn
/*	Copyright: 1986 MIT Project Athena 
/*	
/************************************************************************/

#include <stdio.h>
#include <strings.h>
#include "gdb.h"
#include <sys/ioctl.h>

	/*----------------------------------------------------------*/
	/*	
	/*	The following field names and types describe the
	/*	tuple sent from clients to servers during negotiation.
	/*	
	/*----------------------------------------------------------*/

char *g_tsv_field_names[] = {"server_id",
			    "parms",
		            "host",
		            "user"};
FIELD_TYPE g_tsv_ftypes[] = {STRING_T,
			    STRING_T,
		            STRING_T,
		            STRING_T};

#define TSV_FLDCOUNT 4

#define TSV_SERVER_ID 0
#define TSV_PARMS     1
#define TSV_HOST      2
#define TSV_USER      3


	/*----------------------------------------------------------*/
	/*	
	/*	The following field names and types describe the
	/*	tuple returned from the server to the client during
	/*	negotiation.
	/*	
	/*----------------------------------------------------------*/

char *g_fsv_field_names[] = {"disposition",
			     "server_id",
			     "parms"};
FIELD_TYPE g_fsv_ftypes[] = {INTEGER_T,
			     STRING_T,
			     STRING_T};

#define FSV_FLDCOUNT 3

#define FSV_DISPOSITION 0
#define FSV_SERVER_ID   1
#define FSV_PARMS       2

\f
/************************************************************************/
/*	
/*			  gdb_i_srv
/*	
/*	Initialize the server client layer.
/*	
/*	This routine is called during gdb_init to do the processing
/*	common to all server/client handing.
/*	
/*	In particular, we build the tuple descriptors for the 
/*	messages used in negotiating the server/client startup.
/*	
/************************************************************************/

int
gdb_i_srv()
{
	gdb_tosrv = create_tuple_descriptor(TSV_FLDCOUNT, g_tsv_field_names, 
					    g_tsv_ftypes);
	gdb_fmsrv = create_tuple_descriptor(FSV_FLDCOUNT, g_fsv_field_names, 
					    g_fsv_ftypes);
	gdb_client_tuple = NULL;
	gdb_socklen = sizeof(gdb_sockaddr_of_client);
}

\f
/************************************************************************/
/*	
/*		   start_server_connection (start_server_connection)
/*	
/*	This routine is called from a client that wishes to make a
/*	connection to a server.  In the current implementation, the
/*	string argument supplied is just the internet name of the 
/*	host on which the server runs.  This will later be generalized
/*	to a more flexible naming scheme.
/*	
/*	This routine builds a connection to the requested server, 
/*	sends the server i.d. and parms to the server (as strings), 
/*	and waits for a response indicating whether the server has
/*	agreed to the connection.  The server responds in one of three
/*	ways (1) connection accepted (2) connection declined (3) redirect.
/*	In this last case, the server returns a forwarding address to
/*	be substituted for the server_id, and the whole process is tried
/*	again repeatedly until a connection is established or a
/*	retry limit is exceeded.
/*	
/************************************************************************/

CONNECTION
start_server_connection(server_id, parms)
char *server_id;
char *parms;
{
	CONNECTION con;				/* the connection we're */
						/* creating */
	TUPLE response = NULL;			/* each time we try a server */
						/* it sends back its */
						/* response here */
	int retries = GDB_MAX_SERVER_RETRIES;	/* number of servers we'll */
						/* try before giving up in */
						/* fear of a loop */

	char serv_id[GDB_MAX_SERVER_ID_SIZE];	/* a place to store server */
						/* id's.  New ones go here */
						/* when our request is */
						/* forwarded */
	char latest_parms[GDB_MAX_SERVER_PARMS_SIZE];
						/* likewise for parms */

	GDB_INIT_CHECK

       /*
        * Try to allocate a connection and fill it in with null values.
        */

	con = g_make_con();

       /*
        * Loop asking different servers to accept our connection
        * until one does or we are flatly refused.
        */

	/*
	 * Allocate a buffer, if necessary, and reset buffer pointers
	 * so first request will result in a long read into the buffer
	 */
	g_allocate_connection_buffers(con);


	g_try_server(&con, server_id, parms, &response);

        while ((retries--) &&
	       con != NULL && 
	       response != NULL &&
	       *(int *)FIELD_FROM_TUPLE(response,FSV_DISPOSITION)==GDB_FORWARDED) {

		(void) sever_connection(con);
		con = g_make_con();
		(void) strcpy(serv_id, 
		       STRING_DATA(*(STRING *) 
				   (FIELD_FROM_TUPLE(response, 
						     FSV_SERVER_ID))));
		(void) strcpy(latest_parms, 
		       STRING_DATA(*(STRING *) 
				   (FIELD_FROM_TUPLE(response, 
						     FSV_PARMS))));
		null_tuple_strings(response);
		delete_tuple(response);
		g_try_server(&con, serv_id, latest_parms, &response);
	}

	/*
	 * At this point, we are done trying servers, now find out
         * whether we get to keep the connnection or whether it
         * didn't work.  First, see whether the connection is even up.
	 */
	if (con == NULL ||
	    connection_status(con) != CON_UP) {
		return con;
	}

       /*
        * We have at least some active connection, now see whether we 
        * are going to get to keep it
        */
	if (response != NULL &&
	    *(int *)FIELD_FROM_TUPLE(response,FSV_DISPOSITION) == GDB_ACCEPTED) {
		null_tuple_strings(response);
		delete_tuple(response);
		return con;
	} else {
		if (response != NULL) {
			null_tuple_strings(response);
			delete_tuple(response);
		}
		(void) sever_connection(con);
		return NULL;
	}
}
\f
/************************************************************************/
/*	
/*	  		     g_try_server
/*	
/*	Builds a single connection to a server and returns status
/*	to indicate whether the connection has been accepted, declined,
/*	or is to be retried.  This status is conveyed in a tuple received
/*	back from the server.
/*	
/************************************************************************/

int
g_try_server(conp, server_id, parms, responsep)
CONNECTION *conp;
char *server_id;
char *parms;
TUPLE *responsep;
{

	register CONNECTION con = *conp;
	int flag = 1;
	
       /* 
        * In this implementation, we use a single fd for both inbound and
        * outbound traffic.  Try to connect to other side.  Current
        * implementation of this is synchronous--may be a problem?  If the
        * connections come up, then verify the level of protocol being
        * observed on the connections.  If incompatible, then turn off the
        * connection.
        */

 	if(!g_try_connecting(con,server_id) || 
	   con->status != CON_STARTING) {
		return;				/* If there we an error, */
						/* connection will have been */
						/* left CON_STOPPING with */
						/* possible errno set */
	}
	g_ver_oprotocol(con);
	if (con->status != CON_UP) {
		return;
	}

       /*
        * We've successfully started the connection, now mark
        * it for non-blocking I/O.  Also, update the high water
        * mark of fd's controlled by our system.
        */
	if(ioctl(con->in.fd, FIONBIO, (char *)&flag)== (-1)) {
			g_stop_with_errno(con);
			gdb_perror("gdb: ioctl for non-block failed");
			return;
	}
	if (con->in.fd +1 > gdb_mfd) 
			gdb_mfd = con->in.fd + 1;

	g_ask_server(conp, server_id, parms, responsep);	

	return;
}

\f
/************************************************************************/
/*	
/*			g_ask_server
/*	
/*	Called once we are in touch with the server and our physical
/*	transmission protocol is comprehensible.  This routine
/*	sends out a tuple containing the server i.d. and parameter
/*	strings and it returns a tuple received back from the server
/*	containing the server's response.
/*	
/************************************************************************/

int
g_ask_server(conp, server_id, parms, responsep)
CONNECTION *conp;
char *server_id;
char *parms;
TUPLE *responsep;
{
	register CONNECTION con = *conp;
	TUPLE out_tuple;
	int rc;
	/*----------------------------------------------------------*/
	/*	
	/*	Create a tuple to be sent out containing the
	/*	server_id and parms.
	/*	
	/*----------------------------------------------------------*/

	out_tuple = create_tuple(gdb_tosrv);	/* descriptor was pre- */
						/* built during */
						/* initialization*/

	(void) string_alloc((STRING *)FIELD_FROM_TUPLE(out_tuple, TSV_SERVER_ID),
		     strlen(server_id)+1);
	(void) strcpy(STRING_DATA(*((STRING *)FIELD_FROM_TUPLE(out_tuple,0))),
		       server_id);

	(void) string_alloc((STRING *)FIELD_FROM_TUPLE(out_tuple, TSV_PARMS),
		     strlen(parms)+1);
	(void) strcpy(STRING_DATA(*((STRING *)FIELD_FROM_TUPLE(out_tuple,1))),
		       parms);

	(void) string_alloc((STRING *)FIELD_FROM_TUPLE(out_tuple, TSV_HOST),
		     strlen(gdb_host)+1);
	(void) strcpy(STRING_DATA(*((STRING *)FIELD_FROM_TUPLE(out_tuple,
							       TSV_HOST))),
		       gdb_host);
	(void) string_alloc((STRING *)FIELD_FROM_TUPLE(out_tuple, TSV_USER),
		     strlen(gdb_uname)+1);
	(void) strcpy(STRING_DATA(*((STRING *)FIELD_FROM_TUPLE(out_tuple,TSV_USER))),
		       gdb_uname);

	/*----------------------------------------------------------*/
	/*	
	/*	Send the tuple to the server, and make sure that
	/*	we succeeded.
	/*	
	/*----------------------------------------------------------*/

	rc = send_object(con, (char *)&out_tuple, TUPLE_T);

	null_tuple_strings(out_tuple);
	delete_tuple(out_tuple);

	if (rc != OP_SUCCESS) {
		return;				/* cleanup from dying send */
						/* should have made this */
						/* CON_STOPPING with errno */
	}

	/*----------------------------------------------------------*/
	/*	
	/*	OK, we sent it out, now lets read back the response.
	/*	
	/*----------------------------------------------------------*/

	rc = receive_object(con, (char *)responsep, TUPLE_T);

	if (rc != OP_SUCCESS) {
		return;				/* cleanup from dying send */
						/* should have made this */
						/* CON_STOPPING with errno */
	}
}
\f
/************************************************************************/
/*	
/*			start_replying_to_client
/*	
/*	Queue an operation which will send a reply to the specified
/*	client.
/*	
/************************************************************************/

struct rtc_data {
	TUPLE reply_data;
	OPERATION tuple_send;
};

int g_irtc();
int g_i2rtc();

int
start_replying_to_client(op, con, disposition, serverid, parms)
OPERATION op;
CONNECTION con;
int disposition;
char *serverid;					/* null terminated */
char *parms;					/*   "     "       */
{
	register struct rtc_data *arg;
	register TUPLE t;

       /*
        * Make sure the supplied connection is a legal one
        */
	GDB_CHECK_CON(con, "start_replying_to_client")

	arg = (struct rtc_data *)db_alloc(sizeof(struct rtc_data));

       /*
        * create an empty operation and a tuple
        */
	arg->tuple_send = create_operation();
	arg->reply_data = create_tuple(gdb_fmsrv);
       /*
        * Fill in the response tuple
        */
	t = arg->reply_data;			/* quicker and easier here */

	*(int *)FIELD_FROM_TUPLE(t,FSV_DISPOSITION) = disposition;
	(void) string_alloc((STRING *)FIELD_FROM_TUPLE(t, FSV_SERVER_ID),
		     strlen(serverid)+1);
	(void) strcpy(STRING_DATA(*(STRING *)(FIELD_FROM_TUPLE(t, FSV_SERVER_ID))),
				       serverid);

	(void) string_alloc((STRING *)FIELD_FROM_TUPLE(t, FSV_PARMS),
		     strlen(parms)+1);
	(void) strcpy(STRING_DATA(*(STRING *)(FIELD_FROM_TUPLE(t, FSV_PARMS))),
				       parms);

       /*
        * Queue an operation ahead of us which will send the response tuple
        * to the client
        */
	start_sending_object(arg->tuple_send, con, (char *)&arg->reply_data,
			     TUPLE_T);
	
       /*
        * Now queue us behind it.  By the time we run our init routine,
        * a connection should have been acquired.
        */
	initialize_operation(op, g_irtc, (char *)arg, (int (*)())NULL);
	(void) queue_operation(con, CON_INPUT, op);
}

	/*----------------------------------------------------------*/
	/*	
	/*			g_irtc
	/*	
	/*	Init routine for replying to a client.  If all went
	/*	well, (or even if it didn't), then we are done.
	/*	All we have to do is clean up the stuff we've allocated.
	/*	
	/*----------------------------------------------------------*/

int
g_irtc(op, hcon, arg)
OPERATION op;
HALF_CONNECTION hcon;
struct rtc_data *arg;
{
	int rc;

       /*
        * Figure out the return information to our caller
        */
	rc = OP_STATUS(arg->tuple_send);

       /*
        * Release all transient data structures.
        */
	null_tuple_strings(arg->reply_data);
	delete_tuple(arg->reply_data);
	delete_operation(arg->tuple_send);
	db_free((char *)arg, sizeof(struct rtc_data));
	return rc;
}
Commit	Line	Data
5580185e	1	/*
	2	* $Source$
	3	* $Header$
	4	*/
	5
	6	#ifndef lint
	7	static char *rcsid_gdb_serv_c = "$Header$";
	8	#endif lint
	9
	10
	11
	12
	13
	14
	15
	16
	17
	18
	19
	20
	21
	22
	23
	24
	25
	26
	27
	28
	29
	30	/************************************************************************/
	31	/*
	32	/* gdb_serv.c
	33	/*
	34	/* GDB - Routines to implement the server/client model
	35	/* of connections.
	36	/*
	37	/* Author: Noah Mendelsohn
	38	/* Copyright: 1986 MIT Project Athena
	39	/*
	40	/************************************************************************/
	41
	42	#include <stdio.h>
	43	#include <strings.h>
	44	#include "gdb.h"
	45	#include <sys/ioctl.h>
	46
	47	/----------------------------------------------------------/
	48	/*
	49	/* The following field names and types describe the
	50	/* tuple sent from clients to servers during negotiation.
	51	/*
	52	/----------------------------------------------------------/
	53
	54	char *g_tsv_field_names[] = {"server_id",
	55	"parms",
	56	"host",
	57	"user"};
	58	FIELD_TYPE g_tsv_ftypes[] = {STRING_T,
	59	STRING_T,
	60	STRING_T,
	61	STRING_T};
	62
	63	#define TSV_FLDCOUNT 4
	64
65	#define TSV_SERVER_ID 0
66	#define TSV_PARMS 1
67	#define TSV_HOST 2
68	#define TSV_USER 3
69
70
71	/----------------------------------------------------------/
72	/*
73	/* The following field names and types describe the
74	/* tuple returned from the server to the client during
75	/* negotiation.
76	/*
77	/----------------------------------------------------------/
78
79	char *g_fsv_field_names[] = {"disposition",
80	"server_id",
81	"parms"};
82	FIELD_TYPE g_fsv_ftypes[] = {INTEGER_T,
83	STRING_T,
84	STRING_T};
85
86	#define FSV_FLDCOUNT 3
87
88	#define FSV_DISPOSITION 0
89	#define FSV_SERVER_ID 1
90	#define FSV_PARMS 2
91
92	\f
93	/************************************************************************/
94	/*
95	/* gdb_i_srv
96	/*
97	/* Initialize the server client layer.
98	/*
99	/* This routine is called during gdb_init to do the processing
100	/* common to all server/client handing.
101	/*
102	/* In particular, we build the tuple descriptors for the
103	/* messages used in negotiating the server/client startup.
104	/*
105	/************************************************************************/
106
107	int
108	gdb_i_srv()
109	{
110	gdb_tosrv = create_tuple_descriptor(TSV_FLDCOUNT, g_tsv_field_names,
111	g_tsv_ftypes);
112	gdb_fmsrv = create_tuple_descriptor(FSV_FLDCOUNT, g_fsv_field_names,
113	g_fsv_ftypes);
114	gdb_client_tuple = NULL;
115	gdb_socklen = sizeof(gdb_sockaddr_of_client);
116	}
117
118	\f
119	/************************************************************************/
120	/*
121	/* start_server_connection (start_server_connection)
122	/*
123	/* This routine is called from a client that wishes to make a
124	/* connection to a server. In the current implementation, the
125	/* string argument supplied is just the internet name of the
126	/* host on which the server runs. This will later be generalized
127	/* to a more flexible naming scheme.
128	/*
129	/* This routine builds a connection to the requested server,
130	/* sends the server i.d. and parms to the server (as strings),
131	/* and waits for a response indicating whether the server has
132	/* agreed to the connection. The server responds in one of three
133	/* ways (1) connection accepted (2) connection declined (3) redirect.
134	/* In this last case, the server returns a forwarding address to
135	/* be substituted for the server_id, and the whole process is tried
136	/* again repeatedly until a connection is established or a
137	/* retry limit is exceeded.
138	/*
139	/************************************************************************/
140
141	CONNECTION
142	start_server_connection(server_id, parms)
143	char *server_id;
144	char *parms;
145	{
146	CONNECTION con; /* the connection we're */
147	/* creating */
148	TUPLE response = NULL; /* each time we try a server */
149	/* it sends back its */
150	/* response here */
151	int retries = GDB_MAX_SERVER_RETRIES; /* number of servers we'll */
152	/* try before giving up in */
153	/* fear of a loop */
154
155	char serv_id[GDB_MAX_SERVER_ID_SIZE]; /* a place to store server */
156	/* id's. New ones go here */
157	/* when our request is */
158	/* forwarded */
159	char latest_parms[GDB_MAX_SERVER_PARMS_SIZE];
160	/* likewise for parms */
161
162	GDB_INIT_CHECK
163
164	/*
165	* Try to allocate a connection and fill it in with null values.
166	*/
167
168	con = g_make_con();
169
170	/*
171	* Loop asking different servers to accept our connection
172	* until one does or we are flatly refused.
173	*/
174
175	/*
176	* Allocate a buffer, if necessary, and reset buffer pointers
177	* so first request will result in a long read into the buffer
178	*/
179	g_allocate_connection_buffers(con);
180
181
182	g_try_server(&con, server_id, parms, &response);
183
184	while ((retries--) &&
185	con != NULL &&
186	response != NULL &&
187	(int )FIELD_FROM_TUPLE(response,FSV_DISPOSITION)==GDB_FORWARDED) {
188
189	(void) sever_connection(con);
190	con = g_make_con();
191	(void) strcpy(serv_id,
192	STRING_DATA((STRING )
193	(FIELD_FROM_TUPLE(response,
194	FSV_SERVER_ID))));
195	(void) strcpy(latest_parms,
196	STRING_DATA((STRING )
197	(FIELD_FROM_TUPLE(response,
198	FSV_PARMS))));
199	null_tuple_strings(response);
200	delete_tuple(response);
201	g_try_server(&con, serv_id, latest_parms, &response);
202	}
203
204	/*
205	* At this point, we are done trying servers, now find out
206	* whether we get to keep the connnection or whether it
207	* didn't work. First, see whether the connection is even up.
208	*/
209	if (con == NULL \|\|
210	connection_status(con) != CON_UP) {
211	return con;
212	}
213
214	/*
215	* We have at least some active connection, now see whether we
216	* are going to get to keep it
217	*/
218	if (response != NULL &&
219	(int )FIELD_FROM_TUPLE(response,FSV_DISPOSITION) == GDB_ACCEPTED) {
220	null_tuple_strings(response);
221	delete_tuple(response);
222	return con;
223	} else {
224	if (response != NULL) {
225	null_tuple_strings(response);
226	delete_tuple(response);
227	}
228	(void) sever_connection(con);
229	return NULL;
230	}
231	}
232	\f
233	/************************************************************************/
234	/*
235	/* g_try_server
236	/*
237	/* Builds a single connection to a server and returns status
238	/* to indicate whether the connection has been accepted, declined,
239	/* or is to be retried. This status is conveyed in a tuple received
240	/* back from the server.
241	/*
242	/************************************************************************/
243
244	int
245	g_try_server(conp, server_id, parms, responsep)
246	CONNECTION *conp;
247	char *server_id;
248	char *parms;
249	TUPLE *responsep;
250	{
251
252	register CONNECTION con = *conp;
253	int flag = 1;
254
255	/*
256	* In this implementation, we use a single fd for both inbound and
257	* outbound traffic. Try to connect to other side. Current
258	* implementation of this is synchronous--may be a problem? If the
259	* connections come up, then verify the level of protocol being
260	* observed on the connections. If incompatible, then turn off the
261	* connection.
262	*/
263
264	if(!g_try_connecting(con,server_id) \|\|
265	con->status != CON_STARTING) {
266	return; /* If there we an error, */
267	/* connection will have been */
268	/* left CON_STOPPING with */
269	/* possible errno set */
270	}
271	g_ver_oprotocol(con);
272	if (con->status != CON_UP) {
273	return;
274	}
275
276	/*
277	* We've successfully started the connection, now mark
278	* it for non-blocking I/O. Also, update the high water
279	* mark of fd's controlled by our system.
280	*/
281	if(ioctl(con->in.fd, FIONBIO, (char *)&flag)== (-1)) {
282	g_stop_with_errno(con);
283	gdb_perror("gdb: ioctl for non-block failed");
284	return;
285	}
286	if (con->in.fd +1 > gdb_mfd)
287	gdb_mfd = con->in.fd + 1;
288
289	g_ask_server(conp, server_id, parms, responsep);
290
291	return;
292	}
293
294	\f
295	/************************************************************************/
296	/*
297	/* g_ask_server
298	/*
299	/* Called once we are in touch with the server and our physical
300	/* transmission protocol is comprehensible. This routine
301	/* sends out a tuple containing the server i.d. and parameter
302	/* strings and it returns a tuple received back from the server
303	/* containing the server's response.
304	/*
305	/************************************************************************/
306
307	int
308	g_ask_server(conp, server_id, parms, responsep)
309	CONNECTION *conp;
310	char *server_id;
311	char *parms;
312	TUPLE *responsep;
313	{
314	register CONNECTION con = *conp;
315	TUPLE out_tuple;
316	int rc;
317	/----------------------------------------------------------/
318	/*
319	/* Create a tuple to be sent out containing the
320	/* server_id and parms.
321	/*
322	/----------------------------------------------------------/
323
324	out_tuple = create_tuple(gdb_tosrv); /* descriptor was pre- */
325	/* built during */
326	/* initialization*/
327
328	(void) string_alloc((STRING *)FIELD_FROM_TUPLE(out_tuple, TSV_SERVER_ID),
329	strlen(server_id)+1);
330	(void) strcpy(STRING_DATA(((STRING )FIELD_FROM_TUPLE(out_tuple,0))),
331	server_id);
332
333	(void) string_alloc((STRING *)FIELD_FROM_TUPLE(out_tuple, TSV_PARMS),
334	strlen(parms)+1);
335	(void) strcpy(STRING_DATA(((STRING )FIELD_FROM_TUPLE(out_tuple,1))),
336	parms);
337
338	(void) string_alloc((STRING *)FIELD_FROM_TUPLE(out_tuple, TSV_HOST),
339	strlen(gdb_host)+1);
340	(void) strcpy(STRING_DATA(((STRING )FIELD_FROM_TUPLE(out_tuple,
341	TSV_HOST))),
342	gdb_host);
343	(void) string_alloc((STRING *)FIELD_FROM_TUPLE(out_tuple, TSV_USER),
344	strlen(gdb_uname)+1);
345	(void) strcpy(STRING_DATA(((STRING )FIELD_FROM_TUPLE(out_tuple,TSV_USER))),
346	gdb_uname);
347
348	/----------------------------------------------------------/
349	/*
350	/* Send the tuple to the server, and make sure that
351	/* we succeeded.
352	/*
353	/----------------------------------------------------------/
354
355	rc = send_object(con, (char *)&out_tuple, TUPLE_T);
356
357	null_tuple_strings(out_tuple);
358	delete_tuple(out_tuple);
359
360	if (rc != OP_SUCCESS) {
361	return; /* cleanup from dying send */
362	/* should have made this */
363	/* CON_STOPPING with errno */
364	}
365
366	/----------------------------------------------------------/
367	/*
368	/* OK, we sent it out, now lets read back the response.
369	/*
370	/----------------------------------------------------------/
371
372	rc = receive_object(con, (char *)responsep, TUPLE_T);
373
374	if (rc != OP_SUCCESS) {
375	return; /* cleanup from dying send */
376	/* should have made this */
377	/* CON_STOPPING with errno */
378	}
379	}
380	\f
381	/************************************************************************/
382	/*
383	/* start_replying_to_client
384	/*
385	/* Queue an operation which will send a reply to the specified
386	/* client.
387	/*
388	/************************************************************************/
389
390	struct rtc_data {
391	TUPLE reply_data;
392	OPERATION tuple_send;
393	};
394
395	int g_irtc();
396	int g_i2rtc();
397
398	int
399	start_replying_to_client(op, con, disposition, serverid, parms)
400	OPERATION op;
401	CONNECTION con;
402	int disposition;
403	char serverid; / null terminated */
404	char parms; / " " */
405	{
406	register struct rtc_data *arg;
407	register TUPLE t;
408
409	/*
410	* Make sure the supplied connection is a legal one
411	*/
412	GDB_CHECK_CON(con, "start_replying_to_client")
413
414	arg = (struct rtc_data *)db_alloc(sizeof(struct rtc_data));
415
416	/*
417	* create an empty operation and a tuple
418	*/
419	arg->tuple_send = create_operation();
420	arg->reply_data = create_tuple(gdb_fmsrv);
421	/*
422	* Fill in the response tuple
423	*/
424	t = arg->reply_data; /* quicker and easier here */
425
426	(int )FIELD_FROM_TUPLE(t,FSV_DISPOSITION) = disposition;
427	(void) string_alloc((STRING *)FIELD_FROM_TUPLE(t, FSV_SERVER_ID),
428	strlen(serverid)+1);
429	(void) strcpy(STRING_DATA((STRING )(FIELD_FROM_TUPLE(t, FSV_SERVER_ID))),
430	serverid);
431
432	(void) string_alloc((STRING *)FIELD_FROM_TUPLE(t, FSV_PARMS),
433	strlen(parms)+1);
434	(void) strcpy(STRING_DATA((STRING )(FIELD_FROM_TUPLE(t, FSV_PARMS))),
435	parms);
436
437	/*
438	* Queue an operation ahead of us which will send the response tuple
439	* to the client
440	*/
441	start_sending_object(arg->tuple_send, con, (char *)&arg->reply_data,
442	TUPLE_T);
443
444	/*
445	* Now queue us behind it. By the time we run our init routine,
446	* a connection should have been acquired.
447	*/
448	initialize_operation(op, g_irtc, (char )arg, (int ()())NULL);
449	(void) queue_operation(con, CON_INPUT, op);
450	}
451
452	/----------------------------------------------------------/
453	/*
454	/* g_irtc
455	/*
456	/* Init routine for replying to a client. If all went
457	/* well, (or even if it didn't), then we are done.
458	/* All we have to do is clean up the stuff we've allocated.
459	/*
460	/----------------------------------------------------------/
461
462	int
463	g_irtc(op, hcon, arg)
464	OPERATION op;
465	HALF_CONNECTION hcon;
466	struct rtc_data *arg;
467	{
468	int rc;
469
470	/*
471	* Figure out the return information to our caller
472	*/
473	rc = OP_STATUS(arg->tuple_send);
474
475	/*
476	* Release all transient data structures.
477	*/
478	null_tuple_strings(arg->reply_data);
479	delete_tuple(arg->reply_data);
480	delete_operation(arg->tuple_send);
481	db_free((char *)arg, sizeof(struct rtc_data));
482	return rc;
483	}