[moira.git] / update / client.c

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

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

/*
 * MODULE IDENTIFICATION:
 *	$Header$
 *	Copyright 1987 MIT Project Athena.
 * DESCRIPTION:
 *	This code handles the actual distribution of data files
 *	to servers in the SMS server-update program.
 * AUTHOR:
 *	Ken Raeburn (spook@athena.MIT.EDU),
 *		MIT Project Athena/MIT Information Systems.
 * DEFINED VALUES:
 *	conn
 *	update_info
 *	sms_update_server
 * VERSION HISTORY:
 *	$Log$
 *	Revision 1.1  1987-08-22 17:53:46  wesommer
 *	Initial revision
 *
 */

#include <stdio.h>
#include <strings.h>
#include "gdb.h"
#include <sys/stat.h>
#include <sys/file.h>
#include <sys/param.h>
#include "update.h"
#include <errno.h>
#include "sms_update_int.h"
#include "smsu_int.h"
#include <krb.h>

extern char *malloc(), *error_message();
extern int errno;

/* XXX */
#include "kludge.h"
/* XXX */

static char buf[BUFSIZ];

CONNECTION conn;
struct update_desc *info;

static int code;

/*
 * FUNCTION:
 *	initialize()
 * DESCRIPTION:
 *	Insures that various libraries have a chance to get
 *	initialized.
 * INPUT:
 * OUTPUT:
 * RETURN VALUE:
 *	void
 * SIDE EFFECTS:
 *	Initializes GDB library and SMSU error table.
 * PROBLEMS:
 *
 */
static
void
initialize()
{
    static int initialized = 0;
    if (!initialized) {
	gdb_init();
	init_smsU_err_tbl();
	initialized++;
    }
}

/*
 * FUNCTION:
 *	sms_update_server(info)
 * DESCRIPTION:
 *	Attempts to perform an update based on the information
 *	contained in the data structure pointed to by "info".
 *	Errors in performing the update are logged with the
 *	sms_log* routines; the 'override' field may be updated
 *	to cause updates to occur other than on the regular
 *	schedule (generally to force an earlier retry).
 * INPUT:
 *	info->service_name
 *		Name of service to be updated; used to find
 *		the source data file in the SMS data directory.
 *	info->host_name
 *	info->target_path
 *		Location to install the file.
 *	info->enable
 *		Must be non-zero.
 *	info->instructions
 *		Sequence of commands to execute on remote
 *		machine to effect the installation.
 * OUTPUT:
 *	info->last_time
 *		Set to the current time if the update was
 *		attempted.
 *	info->success
 *		Set to non-zero if the update succeeded, set
 *		to zero otherwise.
 *	info->override
 *		Set to -1 if the update succeeds, to (possibly)
 *		some other value otherwise.
 * RETURN VALUE:
 *	int:
 *		Error code, or zero if no error was detected
 *		in the data supplied to this routine.
 * SIDE EFFECTS:
 *	May write information to logs.
 * PROBLEMS:
 *
 */

int
sms_update_server(update_info, pathname)
    struct update_desc *update_info;
    char *pathname;
{
#define ASSERT(condition,amsg) \
    if (!(condition)) { msg = amsg; code = 0; goto local_error; }
#define NONNULL(str) \
    (((str) != (char *)NULL) && ((size = strlen(str)) != 0))
#define	IO_ERROR(msg) \
    {log_priority=log_ERROR;com_err(whoami,connection_errno(conn),msg);goto io_error;}

    char *service_address;
    char *service_updated;
    char *msg;
    register char *cp;
    STRING string_data, string2;
    int size, num;
    int fd = -1;
    struct stat statb;
    
    /* variable initializations */
    code = 0;
    info = update_info;
    service_updated = (char *)NULL;
    STRING_DATA(string_data) = (char *)NULL;

    /* pessimism */
    info->success = 0;

    /* some sanity checking of arguments while we build data */
    strcpy(buf, "???:???");
    ASSERT(NONNULL(info->host_name), "null host name");
    /* XXX -- check length here */
    strcpy(buf, info->host_name);
    for (cp = buf; *cp; cp++)
	;
    strcpy(cp, ":???");
    ASSERT(NONNULL(info->service_name), "null service name");
    /* XXX -- check length here */
    strcpy(++cp, info->service_name);
    service_updated = malloc(strlen(buf)+1);
    /* XXX -- check allocation succeeded */
    strcpy(service_updated, buf);
    service_address = malloc(strlen(SERVICE_NAME)+strlen(info->host_name)+1);
    if (!service_address) {
	code = errno;
	info->override = -1;
	return(code);
    }
    strcpy(service_address, info->host_name);
    strcat(service_address, ":");
    strcat(service_address, SERVICE_NAME);
    ASSERT(info->enable, "server is disabled");
    ASSERT(NONNULL(info->target_path), "null target pathname");
    ASSERT(size < MAXPATHLEN, "target pathname too long");
    ASSERT(info->target_path[0] == '/', "non-absolute pathname supplied");
    
    initialize();
    
    string_alloc(&string2, BUFSIZ);
    
    sprintf(buf, "starting update for %s", service_updated);
    sms_log_info(buf);
    
    fd = open(pathname, O_RDONLY, 0);
    if (fd < 0) {
	code = errno;
	msg = pathname;
	goto local_error;
    }
    if (fstat(fd, &statb)) {
	code = errno;
	close(fd); fd = -1;
	strcat(buf, ": can't fstat:");
	strcat(buf, error_message(code));
	sms_log_error(buf);
	goto error_exit;
    }
    size = statb.st_size;
    
    /* open connection */
    conn = start_server_connection(service_address, 0);
    if (!conn) {
	com_err(whoami, 0, "can't connect to update %s", service_address);
    connect_failed:
	if (info->override<0 || info->override>INTERVAL_connection_failed)
	    info->override = INTERVAL_connection_failed;
	return(0);
    }
    else if (connection_status(conn) == CON_STOPPED) {
	com_err(whoami, connection_errno(conn), ": can't connect to update %s",
		service_address);
	goto connect_failed;
    }
    
    
    /* send authenticators */
    code = send_auth();
    if (code) {
	sprintf(buf, "authorization attempt to %s failed: %s\n",
		service_updated, error_message(code));
	goto update_failed;
    }
    
    /* send file over */
    fd = open(pathname, O_RDONLY, 0);
    if (fd < 0) {
	code = errno;
	msg = pathname;
	goto local_error;
    }
    sprintf(STRING_DATA(string2), "XFER_002 %d %d %s",
	    size, checksum_fd(fd), info->target_path);
    code = send_object(conn, (char *)&string2, STRING_T);
    if (code)
	IO_ERROR("%s: sending XFER_002 request");
    code = receive_object(conn, (char *)&num, INTEGER_T);
    if (code)
	IO_ERROR("%s: getting reply from XFER_002 request");
    if (num) {
	sprintf(buf, "transfer request to %s (XFER_002) rejected: %s",
		service_updated, error_message(num));
    update_failed:
	sms_log_error(buf);
	/*
	 * 	   * if the update fails, something is probably wrong on
	 * 	   * the remote side; we'll have to let a maintainer
	 * 	   * take care of it.  don't bother trying again any sooner
	 * 	   * than INTERVAL_update_failed minutes
	 * 	   */
    update_failed_1:
	if (info->override < INTERVAL_update_failed && info->override != -1)
	    info->override = INTERVAL_update_failed;
	goto do_quit;
    }
    /* send actual data */
    code = send_file(pathname, size);
    if (code)
	goto update_failed_1;
    string_free(&string_data);
    close(fd);
    
    /* send instructions for installation */
    strcpy(buf, "/tmp/sms-update.XXXXXX");
    mktemp(buf);
    fd = open(info->instructions, O_RDONLY, 0);
    if (fd < 0) {
	code = errno;
	log_priority = log_ERROR;
	com_err(whoami, code, ": can't open %s", info->instructions);
	send_quit();
	info->override = INTERVAL_local_error;
	goto error_exit;
    }
    if (fstat(fd, &statb)) {
	code = errno;
	close(fd);
	fd = -1;
	log_priority = log_ERROR;
	com_err(whoami, code, ": can't fstat %s", info->instructions);
	goto error_exit;
    }
    sprintf(STRING_DATA(string2), "XFER_002 %d %d %s",
	    statb.st_size, checksum_fd(fd), buf);
    code = send_object(conn, (char *)&string2, STRING_T);
    if (code)
	IO_ERROR("%s: sending request for transfer of instructions");
    code = receive_object(conn, (char *)&num, INTEGER_T);
    if (code)
	IO_ERROR("%s: lost reply from installation script request");
    if (num) {
	com_err(whoami, num, ": transfer request rejected for %s", buf);
	goto update_failed_1;
    }
    code = send_file(info->instructions, statb.st_size);
    if (code)
	goto update_failed_1;
    
    /* perform installation */
    code = execute(buf);
    if (code) {
	sprintf(buf, "installation of %s failed: %s", service_updated,
		error_message(code));
	sms_log_error(buf);
    }
    
    /* clear override timer and indicate success */
    info->override = -1;
    info->success = 1;

    /* finished updates */
do_quit:
    send_quit();
    
    /* fall through */
EGRESS:
    code = 0;
error_exit:
    info->last_time = time((long *)0);
    if (STRING_DATA(string2))
	string_free(&string2);
    if (STRING_DATA(string_data))
	string_free(&string_data);
    conn = sever_connection(conn);
    return(code);
    
local_error:
    log_priority = log_ERROR;
    com_err(whoami, code, code ? ": %s" : "%s", msg);
    return(SMSU_INTERNAL_ERROR);
    
io_error:
    sms_log_error(buf);
    if (info->override== -1 || info->override > INTERVAL_connection_lost)
	info->override = INTERVAL_connection_lost;
    goto EGRESS;
    
#undef IO_ERROR
#undef NONNULL
#undef ASSERT
}

static
send_auth()
{
    KTEXT_ST ticket_st;
    KTEXT ticket = &ticket_st;
    STRING data;
    register int code;
    int response;
    
    code = get_sms_update_ticket(info->host_name, ticket);
    if (code) {
	return(code);
    }
    STRING_DATA(data) = "AUTH_001";
    MAX_STRING_SIZE(data) = 9;
    code = send_object(conn, (char *)&data, STRING_T);
    if (code) {
	return(connection_errno(conn));
    }
    code = receive_object(conn, (char *)&response, INTEGER_T);
    if (code) {
	return(connection_errno(conn));
    }
    if (response) {
	return(response);
    }
    STRING_DATA(data) = (char *)ticket->dat;
    MAX_STRING_SIZE(data) = ticket->length;
    code = send_object(conn, (char *)&data, STRING_T);
    if (code) {
	return(connection_errno(conn));
    }
    code = receive_object(conn, (char *)&response, INTEGER_T);
    if (code) {
	return(connection_errno(conn));
    }
    if (response) {
	return(response);
    }
    return(0);
}

static
execute(path)
    char *path;
{
    int response;
    STRING data;
    register int code;
    
    string_alloc(&data, BUFSIZ);
    sprintf(STRING_DATA(data), "EXEC_002 %s", path);
    code = send_object(conn, (char *)&data, STRING_T);
    if (code)
	return(connection_errno(conn));
    code = receive_object(conn, (char *)&response, INTEGER_T);
    if (code)
	return(connection_errno(conn));
    if (response)
	return(response);
    return(0);
}

send_quit()
{
    STRING str;
    if (!conn)
	return;
    string_alloc(&str, 5);
    (void) strcpy(STRING_DATA(str), "quit");
    (void) send_object(conn, (char *)&str, STRING_T);
    string_free(&str);
}
Commit	Line	Data
de56407f	1	/*
	2	* $Source$
	3	* $Header$
	4	*/
	5
	6	#ifndef lint
	7	static char *rcsid_client2_c = "$Header$";
	8	#endif lint
	9
	10	/*
	11	* MODULE IDENTIFICATION:
	12	* $Header$
	13	* Copyright 1987 MIT Project Athena.
	14	* DESCRIPTION:
	15	* This code handles the actual distribution of data files
	16	* to servers in the SMS server-update program.
	17	* AUTHOR:
	18	* Ken Raeburn (spook@athena.MIT.EDU),
	19	* MIT Project Athena/MIT Information Systems.
	20	* DEFINED VALUES:
	21	* conn
	22	* update_info
	23	* sms_update_server
	24	* VERSION HISTORY:
	25	* $Log$
	26	* Revision 1.1 1987-08-22 17:53:46 wesommer
	27	* Initial revision
	28	*
	29	*/
	30
	31	#include <stdio.h>
	32	#include <strings.h>
	33	#include "gdb.h"
	34	#include <sys/stat.h>
	35	#include <sys/file.h>
	36	#include <sys/param.h>
	37	#include "update.h"
	38	#include <errno.h>
	39	#include "sms_update_int.h"
	40	#include "smsu_int.h"
	41	#include <krb.h>
	42
	43	extern char malloc(), error_message();
	44	extern int errno;
	45
	46	/* XXX */
	47	#include "kludge.h"
	48	/* XXX */
	49
	50	static char buf[BUFSIZ];
	51
	52	CONNECTION conn;
	53	struct update_desc *info;
	54
	55	static int code;
	56
	57	/*
	58	* FUNCTION:
	59	* initialize()
	60	* DESCRIPTION:
	61	* Insures that various libraries have a chance to get
	62	* initialized.
	63	* INPUT:
	64	* OUTPUT:
65	* RETURN VALUE:
66	* void
67	* SIDE EFFECTS:
68	* Initializes GDB library and SMSU error table.
69	* PROBLEMS:
70	*
71	*/
72	static
73	void
74	initialize()
75	{
76	static int initialized = 0;
77	if (!initialized) {
78	gdb_init();
79	init_smsU_err_tbl();
80	initialized++;
81	}
82	}
83
84	/*
85	* FUNCTION:
86	* sms_update_server(info)
87	* DESCRIPTION:
88	* Attempts to perform an update based on the information
89	* contained in the data structure pointed to by "info".
90	* Errors in performing the update are logged with the
91	* sms_log* routines; the 'override' field may be updated
92	* to cause updates to occur other than on the regular
93	* schedule (generally to force an earlier retry).
94	* INPUT:
95	* info->service_name
96	* Name of service to be updated; used to find
97	* the source data file in the SMS data directory.
98	* info->host_name
99	* info->target_path
100	* Location to install the file.
101	* info->enable
102	* Must be non-zero.
103	* info->instructions
104	* Sequence of commands to execute on remote
105	* machine to effect the installation.
106	* OUTPUT:
107	* info->last_time
108	* Set to the current time if the update was
109	* attempted.
110	* info->success
111	* Set to non-zero if the update succeeded, set
112	* to zero otherwise.
113	* info->override
114	* Set to -1 if the update succeeds, to (possibly)
115	* some other value otherwise.
116	* RETURN VALUE:
117	* int:
118	* Error code, or zero if no error was detected
119	* in the data supplied to this routine.
120	* SIDE EFFECTS:
121	* May write information to logs.
122	* PROBLEMS:
123	*
124	*/
125
126	int
127	sms_update_server(update_info, pathname)
128	struct update_desc *update_info;
129	char *pathname;
130	{
131	#define ASSERT(condition,amsg) \
132	if (!(condition)) { msg = amsg; code = 0; goto local_error; }
133	#define NONNULL(str) \
134	(((str) != (char *)NULL) && ((size = strlen(str)) != 0))
135	#define IO_ERROR(msg) \
136	{log_priority=log_ERROR;com_err(whoami,connection_errno(conn),msg);goto io_error;}
137
138	char *service_address;
139	char *service_updated;
140	char *msg;
141	register char *cp;
142	STRING string_data, string2;
143	int size, num;
144	int fd = -1;
145	struct stat statb;
146
147	/* variable initializations */
148	code = 0;
149	info = update_info;
150	service_updated = (char *)NULL;
151	STRING_DATA(string_data) = (char *)NULL;
152
153	/* pessimism */
154	info->success = 0;
155
156	/* some sanity checking of arguments while we build data */
157	strcpy(buf, "???:???");
158	ASSERT(NONNULL(info->host_name), "null host name");
159	/* XXX -- check length here */
160	strcpy(buf, info->host_name);
161	for (cp = buf; *cp; cp++)
162	;
163	strcpy(cp, ":???");
164	ASSERT(NONNULL(info->service_name), "null service name");
165	/* XXX -- check length here */
166	strcpy(++cp, info->service_name);
167	service_updated = malloc(strlen(buf)+1);
168	/* XXX -- check allocation succeeded */
169	strcpy(service_updated, buf);
170	service_address = malloc(strlen(SERVICE_NAME)+strlen(info->host_name)+1);
171	if (!service_address) {
172	code = errno;
173	info->override = -1;
174	return(code);
175	}
176	strcpy(service_address, info->host_name);
177	strcat(service_address, ":");
178	strcat(service_address, SERVICE_NAME);
179	ASSERT(info->enable, "server is disabled");
180	ASSERT(NONNULL(info->target_path), "null target pathname");
181	ASSERT(size < MAXPATHLEN, "target pathname too long");
182	ASSERT(info->target_path[0] == '/', "non-absolute pathname supplied");
183
184	initialize();
185
186	string_alloc(&string2, BUFSIZ);
187
188	sprintf(buf, "starting update for %s", service_updated);
189	sms_log_info(buf);
190
191	fd = open(pathname, O_RDONLY, 0);
192	if (fd < 0) {
193	code = errno;
194	msg = pathname;
195	goto local_error;
196	}
197	if (fstat(fd, &statb)) {
198	code = errno;
199	close(fd); fd = -1;
200	strcat(buf, ": can't fstat:");
201	strcat(buf, error_message(code));
202	sms_log_error(buf);
203	goto error_exit;
204	}
205	size = statb.st_size;
206
207	/* open connection */
208	conn = start_server_connection(service_address, 0);
209	if (!conn) {
210	com_err(whoami, 0, "can't connect to update %s", service_address);
211	connect_failed:
212	if (info->override<0 \|\| info->override>INTERVAL_connection_failed)
213	info->override = INTERVAL_connection_failed;
214	return(0);
215	}
216	else if (connection_status(conn) == CON_STOPPED) {
217	com_err(whoami, connection_errno(conn), ": can't connect to update %s",
218	service_address);
219	goto connect_failed;
220	}
221
222
223	/* send authenticators */
224	code = send_auth();
225	if (code) {
226	sprintf(buf, "authorization attempt to %s failed: %s\n",
227	service_updated, error_message(code));
228	goto update_failed;
229	}
230
231	/* send file over */
232	fd = open(pathname, O_RDONLY, 0);
233	if (fd < 0) {
234	code = errno;
235	msg = pathname;
236	goto local_error;
237	}
238	sprintf(STRING_DATA(string2), "XFER_002 %d %d %s",
239	size, checksum_fd(fd), info->target_path);
240	code = send_object(conn, (char *)&string2, STRING_T);
241	if (code)
242	IO_ERROR("%s: sending XFER_002 request");
243	code = receive_object(conn, (char *)&num, INTEGER_T);
244	if (code)
245	IO_ERROR("%s: getting reply from XFER_002 request");
246	if (num) {
247	sprintf(buf, "transfer request to %s (XFER_002) rejected: %s",
248	service_updated, error_message(num));
249	update_failed:
250	sms_log_error(buf);
251	/*
252	* * if the update fails, something is probably wrong on
253	* * the remote side; we'll have to let a maintainer
254	* * take care of it. don't bother trying again any sooner
255	* * than INTERVAL_update_failed minutes
256	* */
257	update_failed_1:
258	if (info->override < INTERVAL_update_failed && info->override != -1)
259	info->override = INTERVAL_update_failed;
260	goto do_quit;
261	}
262	/* send actual data */
263	code = send_file(pathname, size);
264	if (code)
265	goto update_failed_1;
266	string_free(&string_data);
267	close(fd);
268
269	/* send instructions for installation */
270	strcpy(buf, "/tmp/sms-update.XXXXXX");
271	mktemp(buf);
272	fd = open(info->instructions, O_RDONLY, 0);
273	if (fd < 0) {
274	code = errno;
275	log_priority = log_ERROR;
276	com_err(whoami, code, ": can't open %s", info->instructions);
277	send_quit();
278	info->override = INTERVAL_local_error;
279	goto error_exit;
280	}
281	if (fstat(fd, &statb)) {
282	code = errno;
283	close(fd);
284	fd = -1;
285	log_priority = log_ERROR;
286	com_err(whoami, code, ": can't fstat %s", info->instructions);
287	goto error_exit;
288	}
289	sprintf(STRING_DATA(string2), "XFER_002 %d %d %s",
290	statb.st_size, checksum_fd(fd), buf);
291	code = send_object(conn, (char *)&string2, STRING_T);
292	if (code)
293	IO_ERROR("%s: sending request for transfer of instructions");
294	code = receive_object(conn, (char *)&num, INTEGER_T);
295	if (code)
296	IO_ERROR("%s: lost reply from installation script request");
297	if (num) {
298	com_err(whoami, num, ": transfer request rejected for %s", buf);
299	goto update_failed_1;
300	}
301	code = send_file(info->instructions, statb.st_size);
302	if (code)
303	goto update_failed_1;
304
305	/* perform installation */
306	code = execute(buf);
307	if (code) {
308	sprintf(buf, "installation of %s failed: %s", service_updated,
309	error_message(code));
310	sms_log_error(buf);
311	}
312
313	/* clear override timer and indicate success */
314	info->override = -1;
315	info->success = 1;
316
317	/* finished updates */
318	do_quit:
319	send_quit();
320
321	/* fall through */
322	EGRESS:
323	code = 0;
324	error_exit:
325	info->last_time = time((long *)0);
326	if (STRING_DATA(string2))
327	string_free(&string2);
328	if (STRING_DATA(string_data))
329	string_free(&string_data);
330	conn = sever_connection(conn);
331	return(code);
332
333	local_error:
334	log_priority = log_ERROR;
335	com_err(whoami, code, code ? ": %s" : "%s", msg);
336	return(SMSU_INTERNAL_ERROR);
337
338	io_error:
339	sms_log_error(buf);
340	if (info->override== -1 \|\| info->override > INTERVAL_connection_lost)
341	info->override = INTERVAL_connection_lost;
342	goto EGRESS;
343
344	#undef IO_ERROR
345	#undef NONNULL
346	#undef ASSERT
347	}
348
349	static
350	send_auth()
351	{
352	KTEXT_ST ticket_st;
353	KTEXT ticket = &ticket_st;
354	STRING data;
355	register int code;
356	int response;
357
358	code = get_sms_update_ticket(info->host_name, ticket);
359	if (code) {
360	return(code);
361	}
362	STRING_DATA(data) = "AUTH_001";
363	MAX_STRING_SIZE(data) = 9;
364	code = send_object(conn, (char *)&data, STRING_T);
365	if (code) {
366	return(connection_errno(conn));
367	}
368	code = receive_object(conn, (char *)&response, INTEGER_T);
369	if (code) {
370	return(connection_errno(conn));
371	}
372	if (response) {
373	return(response);
374	}
375	STRING_DATA(data) = (char *)ticket->dat;
376	MAX_STRING_SIZE(data) = ticket->length;
377	code = send_object(conn, (char *)&data, STRING_T);
378	if (code) {
379	return(connection_errno(conn));
380	}
381	code = receive_object(conn, (char *)&response, INTEGER_T);
382	if (code) {
383	return(connection_errno(conn));
384	}
385	if (response) {
386	return(response);
387	}
388	return(0);
389	}
390
391	static
392	execute(path)
393	char *path;
394	{
395	int response;
396	STRING data;
397	register int code;
398
399	string_alloc(&data, BUFSIZ);
400	sprintf(STRING_DATA(data), "EXEC_002 %s", path);
401	code = send_object(conn, (char *)&data, STRING_T);
402	if (code)
403	return(connection_errno(conn));
404	code = receive_object(conn, (char *)&response, INTEGER_T);
405	if (code)
406	return(connection_errno(conn));
407	if (response)
408	return(response);
409	return(0);
410	}
411
412	send_quit()
413	{
414	STRING str;
415	if (!conn)
416	return;
417	string_alloc(&str, 5);
418	(void) strcpy(STRING_DATA(str), "quit");
419	(void) send_object(conn, (char *)&str, STRING_T);
420	string_free(&str);
421	}