Context Navigation

source: trunk/src/sh_socket.c@ 185

Last change on this file since 185 was 177, checked in by katerina, 16 years ago
Fix for compile failure on Fedora 9 (ticket #115).
File size: 27.2 KB

Line
1	/* SAMHAIN file system integrity testing */
2	/* Copyright (C) 2003,2005 Rainer Wichmann */
3	/* */
4	/* This program is free software; you can redistribute it */
5	/* and/or modify */
6	/* it under the terms of the GNU General Public License as */
7	/* published by */
8	/* the Free Software Foundation; either version 2 of the License, or */
9	/* (at your option) any later version. */
10	/* */
11	/* This program is distributed in the hope that it will be useful, */
12	/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
13	/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
14	/* GNU General Public License for more details. */
15	/* */
16	/* You should have received a copy of the GNU General Public License */
17	/* along with this program; if not, write to the Free Software */
18	/* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
19
20	#include "config_xor.h"
21
22	/* define if you want debug info
23	* #define SH_DEBUG_SOCKET
24	*/
25	#if defined(SH_WITH_SERVER) && defined(__linux__)
26	#define _GNU_SOURCE
27	#endif
28
29	#include <stdio.h>
30	#include <stdlib.h>
31	#include <stddef.h>
32	#include <string.h>
33
34	#include "samhain.h"
35	#include "sh_socket.h"
36	#include "sh_error.h"
37	#include "sh_unix.h"
38	#include "sh_calls.h"
39
40	#undef FIL__
41	#define FIL__ _("sh_socket.c")
42
43	#if defined (SH_WITH_CLIENT)
44
45	#include <signal.h>
46
47	void sh_socket_server_cmd(const char * srvcmd)
48	{
49	SL_ENTER(_("sh_tools_server_cmd"));
50
51	if ((srvcmd == NULL) \|\| (srvcmd[0] == '\0') \|\| (sl_strlen(srvcmd) < 4))
52	{
53	SL_RET0(_("sh_socket_server_cmd"));
54	}
55	if ((srvcmd[0] == 'S') \|\| (srvcmd[1] == 'T') \|\|
56	(srvcmd[2] == 'O') \|\| (srvcmd[3] == 'P'))
57	{
58	TPT((0, FIL__, __LINE__, _("msg=<stop command from server>\n")));
59	#ifdef SIGQUIT
60	raise(SIGQUIT);
61	#else
62	TPT((0, FIL__, __LINE__, _("msg=<sigquit not defined>\n")));
63	#endif
64	}
65	else if ((srvcmd[0] == 'R') \|\| (srvcmd[1] == 'E') \|\|
66	(srvcmd[2] == 'L') \|\| (srvcmd[3] == 'O') \|\|
67	(srvcmd[4] == 'A') \|\| (srvcmd[5] == 'D'))
68	{
69	TPT((0, FIL__, __LINE__, _("msg=<reload command from server>\n")));
70	#ifdef SIGHUP
71	raise(SIGHUP);
72	#else
73	TPT((0, FIL__, __LINE__, _("msg=<sighup not defined>\n")));
74	#endif
75	}
76	else
77	{
78	sh_error_handle(SH_ERR_INFO, FIL__, __LINE__, 0, MSG_E_SUBGEN,
79	srvcmd,
80	_("sh_socket_server_cmd"));
81	}
82	SL_RET0(_("sh_socket_server_cmd"));
83	}
84	/* #if defined (SH_WITH_CLIENT)
85	*/
86	#endif
87
88	#if defined(SH_WITH_SERVER)
89	#include <errno.h>
90
91	#include <sys/types.h>
92	#include <sys/stat.h>
93
94	#include <unistd.h>
95	#include <fcntl.h>
96
97	#include <time.h>
98
99	#include <sys/socket.h>
100	#include <sys/un.h>
101
102
103	#ifdef HAVE_SYS_UIO_H
104	#include <sys/uio.h>
105	#endif
106	#if !defined(HAVE_GETPEEREID) && !defined(SO_PEERCRED)
107	#if defined(HAVE_STRUCT_CMSGCRED) \|\| defined(HAVE_STRUCT_FCRED) \|\| defined(HAVE_STRUCT_SOCKCRED)
108	#include <sys/param.h>
109	#include <sys/ucred.h>
110	#endif
111	#endif
112
113
114	int pf_unix_fd = -1;
115	static char * sh_sockname = NULL;
116	static char sh_sockpass_real[SOCKPASS_MAX+1];
117
118	struct socket_cmd {
119	char cmd[SH_MAXMSGLEN];
120	char clt[SH_MAXMSGLEN];
121	char cti[81];
122	struct socket_cmd * next;
123	};
124
125	#if !defined(O_NONBLOCK)
126	#if defined(O_NDELAY)
127	#define O_NONBLOCK O_NDELAY
128	#else
129	#define O_NONBLOCK 0
130	#endif
131	#endif
132
133	#if !defined(AF_FILE)
134	#define AF_FILE AF_UNIX
135	#endif
136
137	static struct socket_cmd * cmdlist = NULL;
138	static struct socket_cmd * runlist = NULL;
139
140	static int sh_socket_flaguse = S_FALSE;
141	static int sh_socket_flaguid = 0;
142
143	#include "sh_utils.h"
144
145
146	struct reload_cmd {
147	char clt[SH_MAXMSGLEN];
148	time_t cti;
149	struct reload_cmd * next;
150	};
151	static struct reload_cmd * reloadlist = NULL;
152
153	void sh_socket_add2reload (const char * clt)
154	{
155	struct reload_cmd * new = reloadlist;
156
157	while (new)
158	{
159	if (0 == sl_strcmp(new->clt, clt))
160	{
161	sl_strlcpy (new->clt, clt, SH_MAXMSGLEN);
162	new->cti = time(NULL);
163	return;
164	}
165	new = new->next;
166	}
167
168	new = SH_ALLOC(sizeof(struct reload_cmd));
169	sl_strlcpy (new->clt, clt, SH_MAXMSGLEN);
170	new->cti = time(NULL);
171
172	new->next = reloadlist;
173	reloadlist = new;
174
175	return;
176	}
177
178	#include "zAVLTree.h"
179	#include "sh_html.h"
180	#include "sh_tools.h"
181	static void sh_socket_add2list (struct socket_cmd * in);
182
183	static void sh_socket_probe4reload (void)
184	{
185	struct reload_cmd * new;
186	struct socket_cmd cmd;
187
188	zAVLCursor avlcursor;
189	client_t * item;
190	extern zAVLTree * all_clients;
191
192	char * file;
193	unsigned long dummy;
194	struct stat buf;
195
196	for (item = (client_t *) zAVLFirst(&avlcursor, all_clients); item;
197	item = (client_t *) zAVLNext(&avlcursor))
198	{
199	if (item->status_now != CLT_INACTIVE)
200	{
201	file = get_client_conf_file (item->hostname, &dummy);
202
203	if (0 == stat (file, &buf))
204	{
205	new = reloadlist;
206	while (new)
207	{
208	if (0 == sl_strcmp(new->clt, item->hostname))
209	{
210	if (buf.st_mtime > new->cti)
211	{
212	/* reload */
213	sl_strlcpy(cmd.cmd, _("RELOAD"), SH_MAXMSGLEN);
214	sl_strlcpy(cmd.clt, item->hostname, SH_MAXMSGLEN);
215	sh_socket_add2list (&cmd);
216	}
217	break;
218	}
219	new = new->next;
220	}
221	}
222	}
223	}
224	return;
225	}
226
227	char * sh_get_sockpass (void)
228	{
229	size_t j = 0;
230
231	while (skey->sh_sockpass[2*j] != '\0' && j < sizeof(sh_sockpass_real))
232	{
233	sh_sockpass_real[j] = skey->sh_sockpass[2*j];
234	++j;
235	}
236	sh_sockpass_real[j] = '\0';
237
238	return sh_sockpass_real;
239	}
240
241	void sh_set_sockpass (void)
242	{
243	int j;
244	for (j = 0; j < 15; ++j)
245	{
246	sh_sockpass_real[j] = '\0';
247	}
248	}
249
250	int sh_socket_use (const char * c)
251	{
252	return sh_util_flagval(c, &sh_socket_flaguse);
253	}
254
255	int sh_socket_remove ()
256	{
257	int retval = 0;
258	#ifdef S_ISSOCK
259	struct stat sbuf;
260	#endif
261
262	SL_ENTER(_("sh_socket_remove"));
263
264	if (NULL == sh_sockname)
265	{
266	SL_RETURN((retval),_("sh_socket_remove"));
267	}
268
269	if (0 != tf_trust_check (DEFAULT_PIDDIR, SL_YESPRIV))
270	{
271	SL_RETURN((-1),_("sh_socket_remove"));
272	}
273
274	if ( (retry_lstat(FIL__, __LINE__, sh_sockname, &sbuf) == 0) &&
275	(sbuf.st_uid == getuid()))
276	{
277	#ifdef S_ISSOCK
278	if (S_ISSOCK (sbuf.st_mode))
279	{
280	retval = retry_aud_unlink (FIL__, __LINE__, sh_sockname);
281	}
282	#else
283	retval = retry_aud_unlink (FIL__, __LINE__, sh_sockname);
284	#endif
285	}
286	SL_RETURN((retval),_("sh_socket_remove"));
287	}
288
289	#if !defined(HAVE_GETPEEREID) && !defined(SO_PEERCRED) && !defined(HAVE_STRUCT_CMSGCRED) && !defined(HAVE_STRUCT_FCRED) && !(defined(HAVE_STRUCT_SOCKCRED) && defined(LOCAL_CREDS))
290
291	#define NEED_PASSWORD_AUTH
292
293	#endif
294
295	int sh_socket_uid (const char * c)
296	{
297	uid_t val = (uid_t) strtol (c, (char **)NULL, 10);
298	sh_socket_flaguid = val;
299	#if defined(NEED_PASSWORD_AUTH)
300	sh_error_handle(SH_ERR_WARN, FIL__, __LINE__, errno, MSG_E_SUBGEN,
301	_("Config option SetSocketAllowUID not supported, use SetSocketPassword"),
302	_("sh_socket_uid"));
303	#endif
304	return 0;
305	}
306
307	int sh_socket_password (const char * c)
308	{
309	#if defined(NEED_PASSWORD_AUTH)
310	int j, i;
311
312	#define LCG(n) ((69069 * n) & 0xffffffffUL)
313
314	i = sl_strlen(c);
315	if (i > SOCKPASS_MAX) {
316	return -1;
317	}
318	for (j = 0; j < (2*SOCKPASS_MAX+1); ++j)
319	{
320	skey->sh_sockpass[j] = '\0';
321	}
322	for (j = 0; j < i; ++j)
323	{
324	skey->sh_sockpass[2*j] = c[j];
325	skey->sh_sockpass[(2*j)+1] = (LCG(c[j]) % 256);
326	}
327	return 0;
328	#else
329	sh_error_handle(SH_ERR_WARN, FIL__, __LINE__, errno, MSG_E_SUBGEN,
330	_("Config option SetSocketPassword not supported, use SetSocketAllowUID"),
331	_("sh_socket_password"));
332	(void) c;
333	return 0;
334	#endif
335	}
336
337
338	int sh_socket_open_int ()
339	{
340	struct sockaddr_un name;
341	size_t size;
342	int flags;
343	#if defined(SO_PASSCRED)
344	socklen_t optval = 1;
345	#endif
346	struct stat buf;
347	char errbuf[SH_ERRBUF_SIZE];
348
349	SL_ENTER(_("sh_socket_open_int"));
350
351	if (sh_socket_flaguse == S_FALSE)
352	{
353	SL_RETURN(0, _("sh_socket_open_int"));
354	}
355
356	if (sh_sockname == NULL)
357	{
358	size = sl_strlen(DEFAULT_PIDDIR) + 1 + sl_strlen(SH_INSTALL_NAME) + 6;
359	sh_sockname = SH_ALLOC(size); /* compile-time constant */
360	sl_strlcpy(sh_sockname, DEFAULT_PIDDIR, size);
361	sl_strlcat(sh_sockname, "/", size);
362	sl_strlcat(sh_sockname, SH_INSTALL_NAME, size);
363	sl_strlcat(sh_sockname, _(".sock"), size);
364	}
365
366	pf_unix_fd = socket (PF_UNIX, SOCK_STREAM, 0);
367	if ((pf_unix_fd) < 0)
368	{
369	sh_error_handle ((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
370	sh_error_message (errno, errbuf, sizeof(errbuf)),
371	_("sh_socket_open_int: socket"));
372	SL_RETURN( (-1), _("sh_socket_open_int"));
373	}
374
375	if (sizeof(name.sun_path) < (1 + sl_strlen(sh_sockname)))
376	{
377	close(pf_unix_fd); pf_unix_fd = -1;
378	sh_error_handle ((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
379	_("PID dir path too long"),
380	_("sh_socket_open_int"));
381	SL_RETURN( (-1), _("sh_socket_open_int"));
382	}
383
384	name.sun_family = AF_FILE;
385	sl_strlcpy (name.sun_path, sh_sockname, sizeof(name.sun_path));
386
387	size = (offsetof (struct sockaddr_un, sun_path)
388	+ strlen (name.sun_path) + 1);
389
390	flags = retry_lstat (FIL__, __LINE__, sh_sockname, &buf);
391
392	if (flags == 0)
393	{
394	sh_error_handle(SH_ERR_INFO, FIL__, __LINE__, -1, MSG_E_SUBGEN,
395	_("Socket exists, trying to unlink it"),
396	_("sh_socket_open_int"));
397	if (sh_socket_remove() < 0)
398	{
399	close(pf_unix_fd); pf_unix_fd = -1;
400	sh_error_handle ((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
401	_("Unlink of socket failed, maybe path not trusted"),
402	_("sh_socket_open_int"));
403	SL_RETURN( (-1), _("sh_socket_open_int"));
404	}
405	}
406
407	if (bind ((pf_unix_fd), (struct sockaddr *) &name, size) < 0)
408	{
409	close(pf_unix_fd); pf_unix_fd = -1;
410	sh_error_handle ((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
411	sh_error_message (errno, errbuf, sizeof(errbuf)),
412	_("sh_socket_open_int: bind"));
413	SL_RETURN( (-1), _("sh_socket_open_int"));
414	}
415
416	#ifdef SO_PASSCRED
417	if (0 != setsockopt(pf_unix_fd, SOL_SOCKET, SO_PASSCRED,
418	&optval, sizeof(optval)))
419	{
420	close(pf_unix_fd); pf_unix_fd = -1;
421	sh_error_handle ((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
422	sh_error_message (errno, errbuf, sizeof(errbuf)),
423	_("sh_socket_open_int: setsockopt"));
424	SL_RETURN( (-1), _("sh_socket_open_int"));
425	}
426	#endif
427
428	flags = fcntl((pf_unix_fd), F_GETFL);
429	if (flags < 0)
430	{
431	close(pf_unix_fd); pf_unix_fd = -1;
432	sh_error_handle ((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
433	sh_error_message (errno, errbuf, sizeof(errbuf)),
434	_("sh_socket_open_int: fcntl1"));
435	SL_RETURN( (-1), _("sh_socket_open_int"));
436	}
437
438	flags = fcntl((pf_unix_fd), F_SETFL, flags\|O_NONBLOCK);
439	if (flags < 0)
440	{
441	close(pf_unix_fd); pf_unix_fd = -1;
442	sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
443	sh_error_message (errno, errbuf, sizeof(errbuf)),
444	_("sh_socket_open_int: fcntl2"));
445	SL_RETURN( (-1), _("sh_socket_open_int"));
446	}
447
448	if (0 != listen(pf_unix_fd, 5))
449	{
450	close(pf_unix_fd); pf_unix_fd = -1;
451	sh_error_handle ((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
452	sh_error_message (errno, errbuf, sizeof(errbuf)),
453	_("sh_socket_open_int: listen"));
454	SL_RETURN( (-1), _("sh_socket_open_int"));
455	}
456	SL_RETURN( (0), _("sh_socket_open_int"));
457	}
458	/* #if !defined(HAVE_CMSGCRED) \|\| !defined(SO_PEERCRED) */
459	/* #endif */
460
461	/*
462	#if !defined(HAVE_GETPEEREID) && !defined(SO_PEERCRED) && !defined(HAVE_STRUCT_CMSGCRED) && !defined(HAVE_STRUCT_FCRED) && !(defined(HAVE_STRUCT_SOCKCRED) && defined(LOCAL_CREDS))
463	static
464	int sh_socket_read (struct socket_cmd * srvcmd)
465	{
466	srvcmd->cmd[0] = '\0';
467	srvcmd->clt[0] = '\0';
468	return 0;
469	}
470	#else
471	*/
472
473	/*
474	* Parts of the socket authentication code is copied from PostgreSQL:
475	*
476	* PostgreSQL Database Management System
477	* (formerly known as Postgres, then as Postgres95)
478	*
479	* Portions Copyright (c) 1996-2001, The PostgreSQL Global Development Group
480	*
481	* Portions Copyright (c) 1994, The Regents of the University of California
482	*
483	* Permission to use, copy, modify, and distribute this software and its
484	* documentation for any purpose, without fee, and without a written agreement
485	* is hereby granted, provided that the above copyright notice and this
486	* paragraph and the following two paragraphs appear in all copies.
487	*
488	* IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR
489	* DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING
490	* LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS
491	* DOCUMENTATION, EVEN IF THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE
492	* POSSIBILITY OF SUCH DAMAGE.
493	*
494	* THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
495	* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
496	* AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
497	* ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATIONS TO
498	* PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
499	*/
500	static
501	int sh_socket_read (struct socket_cmd * srvcmd)
502	{
503	struct socket_cmd * list_cmd;
504	char message[SH_MAXMSG];
505	struct sockaddr_un name;
506	int size;
507	int nbytes;
508	int talkfd;
509	int retry = 0;
510
511	char * cmd = NULL;
512	char * clt = NULL;
513
514	int client_uid = -1;
515	char errbuf[SH_ERRBUF_SIZE];
516
517
518	struct msghdr msg;
519	struct iovec iov;
520
521	#if defined(NEED_PASSWORD_AUTH)
522	char * eopw = NULL;
523	char * goodpassword = NULL;
524	#endif
525
526	#if defined(HAVE_GETPEEREID)
527	uid_t peer_uid;
528	gid_t peer_gid;
529	#elif defined(SO_PEERCRED)
530	struct ucred cr;
531	#ifdef HAVE_SOCKLEN_T
532	socklen_t cl = sizeof(cr);
533	#else
534	int cl = sizeof(cr);
535	#endif
536
537	#elif defined(HAVE_STRUCT_CMSGCRED) \|\| defined(HAVE_STRUCT_FCRED) \|\| (defined(HAVE_STRUCT_SOCKCRED) && defined(LOCAL_CREDS))
538
539	#ifdef HAVE_STRUCT_CMSGCRED
540	typedef struct cmsgcred Cred;
541	#define CRED_UID cmcred_uid
542
543	#elif HAVE_STRUCT_FCRED
544	typedef struct fcred Cred;
545	#define CRED_UID fc_uid
546
547	#elif HAVE_STRUCT_SOCKCRED
548	typedef struct sockcred Cred;
549	#define CRED_UID sc_uid
550
551	#endif
552	Cred *cred;
553
554	/* Compute size without padding */
555	char cmsgmem[ALIGN(sizeof(struct cmsghdr)) + ALIGN(sizeof(Cred))];
556	/* for NetBSD */
557
558	/* Point to start of first structure */
559	struct cmsghdr cmsg = (struct cmsghdr ) cmsgmem;
560	#endif
561
562	if (pf_unix_fd < 0)
563	{
564	return 0;
565	}
566
567	iov.iov_base = (char *) &message;
568	iov.iov_len = sizeof(message);
569
570	memset (&msg, 0, sizeof (msg));
571	msg.msg_iov = &iov;
572	msg.msg_iovlen = 1;
573
574	#if !defined(SO_PEERCRED) && !defined(HAVE_GETPEEREID)
575	#if defined(HAVE_STRUCT_CMSGCRED) \|\| defined(HAVE_STRUCT_FCRED) \|\| (defined(HAVE_STRUCT_SOCKCRED) && defined(LOCAL_CREDS))
576	msg.msg_control = (char *) cmsg;
577	msg.msg_controllen = sizeof (cmsgmem);
578	memset (cmsg, 0, sizeof (cmsgmem));
579	#endif
580	#endif
581
582	/* the socket is non-blocking
583	* 'name' is the address of the sender socket
584	*/
585	size = sizeof (name);
586	talkfd = retry_accept(FIL__, __LINE__,
587	pf_unix_fd, (struct sockaddr *) & name, &size);
588	if ((talkfd < 0) && (errno == EAGAIN))
589	{
590	return 0;
591	}
592	else if (talkfd < 0)
593	{
594	sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
595	sh_error_message (errno, errbuf, sizeof(errbuf)),
596	_("sh_socket_read: accept"));
597	return -1;
598	}
599
600
601	#if defined(LOCAL_CREDS) && !defined(SO_PEERCRED) && !defined(HAVE_GETPEEREID)
602	/* Set the socket to receive credentials on the next message
603	*/
604	{
605	int on = 1;
606	if (setsockopt (talkfd, 0, LOCAL_CREDS, &on, sizeof (on)) < 0)
607	{
608	sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
609	sh_error_message (errno, errbuf, sizeof(errbuf)),
610	_("sh_socket_read: setsockopt"));
611	close(talkfd);
612	return -1;
613	}
614	}
615	#endif
616
617	do {
618	nbytes = recvmsg (talkfd, &msg, 0);
619	if ((nbytes < 0) && (errno != EAGAIN))
620	{
621	sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
622	sh_error_message (errno, errbuf, sizeof(errbuf)),
623	_("sh_socket_read: recvmsg"));
624	close(talkfd);
625	return -1;
626	}
627	else if (nbytes < 0)
628	{
629	++retry;
630	retry_msleep(0, 1);
631	}
632	} while ((nbytes < 0) && (retry < 3));
633
634	#ifdef SH_DEBUG_SOCKET
635	fprintf(stderr, "%d bytes received\n", nbytes);
636	#endif
637
638	/* msg.msg_iov.iov_base, filled by recvmsg
639	*/
640	message[sizeof(message)-1] = '\0';
641
642	if (nbytes < 0)
643	{
644	if (errno == EAGAIN)
645	{
646	/* no data */
647	close(talkfd);
648	return 0;
649	}
650	sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
651	sh_error_message (errno, errbuf, sizeof(errbuf)),
652	_("sh_socket_read: recvfrom"));
653	close(talkfd);
654	return -1;
655	}
656
657	#if defined(HAVE_GETPEEREID)
658	if (0 != getpeereid(talkfd, &peer_uid, &peer_gid))
659	{
660	sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
661	sh_error_message (errno, errbuf, sizeof(errbuf)),
662	_("sh_socket_read: getpeereid"));
663	close(talkfd);
664	return -1;
665	}
666	client_uid = peer_uid;
667	cmd = message;
668	#elif defined(SO_PEERCRED)
669	if (0 != getsockopt(talkfd, SOL_SOCKET, SO_PEERCRED, &cr, &cl))
670	{
671	sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
672	sh_error_message (errno, errbuf, sizeof(errbuf)),
673	_("sh_socket_read: getsockopt"));
674	close(talkfd);
675	return -1;
676	}
677	client_uid = cr.uid;
678	cmd = message;
679	#elif defined(HAVE_STRUCT_CMSGCRED) \|\| defined(HAVE_STRUCT_FCRED) \|\| (defined(HAVE_STRUCT_SOCKCRED) && defined(LOCAL_CREDS))
680	if (cmsg->cmsg_len < sizeof (cmsgmem) \|\| cmsg->cmsg_type != SCM_CREDS)
681	{
682	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_E_SUBGEN,
683	_("Message from recvmsg() was not SCM_CREDS"),
684	_("sh_socket_read"));
685
686	/* Check for file descriptors sent using SCM_RIGHTS, and
687	* close them. If MSG_CTRUNC is set, the buffer was too small,
688	* and no fds are duped.
689	*/
690	if (msg.msg_controllen >= sizeof(struct cmsghdr) &&
691	(msg.msg_flags & MSG_CTRUNC) == 0)
692	{
693	unsigned int data_size;
694	unsigned int data_i;
695	int fdcount, fdmax;
696	struct cmsghdr * cmptr;
697	int fdsbuf[1 + (sizeof(cmsgmem)/sizeof(int))];
698
699	for (cmptr = CMSG_FIRSTHDR(&msg); cmptr != NULL;
700	cmptr = CMSG_NXTHDR(&msg, cmptr))
701	{
702	if (cmptr->cmsg_len > sizeof (cmsgmem) \|\|
703	cmptr->cmsg_level != SOL_SOCKET \|\|
704	cmptr->cmsg_type != SCM_RIGHTS)
705	continue;
706
707	/* Crappy way of finding the data length.
708	* cmptr->cmsg_len includes both header and padding,
709	* how are you supposed to find the data length?
710	* cmptr->cmsg_len - ALIGN(sizeof(struct cmsghdr)) ?
711	*/
712	data_size = 0;
713
714	for (data_i = 0; data_i < cmptr->cmsg_len; ++data_i)
715	{
716	if (CMSG_LEN(data_i) == cmptr->cmsg_len)
717	{
718	data_size = data_i;
719	break;
720	}
721	}
722	memcpy(fdsbuf, CMSG_DATA(cmptr), data_size);
723	fdmax = data_size / sizeof(int);
724	for (fdcount = 0; fdcount < fdmax; ++fdcount)
725	(void) close(fdsbuf[fdcount]);
726	}
727	}
728
729	close(talkfd);
730	return -1;
731	}
732	cred = (Cred *) CMSG_DATA (cmsg);
733	client_uid = cred->CRED_UID;
734	cmd = message;
735	#elif defined(NEED_PASSWORD_AUTH)
736	goodpassword = sh_get_sockpass();
737	eopw = strchr(message, '@');
738	if (eopw)
739	*eopw = '\0';
740	/*
741	* message is null-terminated and >> goodpassword
742	*/
743	if (0 == strcmp(goodpassword, message) &&
744	strlen(goodpassword) < (sizeof(message)/2))
745	{
746	client_uid = sh_socket_flaguid;
747	cmd = &message[strlen(goodpassword)+1];
748	sh_set_sockpass();
749	}
750	else
751	{
752	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_E_SUBGEN,
753	_("Bad password"),
754	_("sh_socket_read"));
755	sh_set_sockpass();
756	close(talkfd);
757	return -1;
758	}
759	#else
760	sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
761	_("Socket credentials not supported on this OS"),
762	_("sh_socket_read"));
763	close(talkfd);
764	return -1;
765	#endif
766
767	#ifdef SH_DEBUG_SOCKET
768	fprintf(stderr, "Peer uid=%d, required=%d\n",
769	client_uid, sh_socket_flaguid);
770	#endif
771
772	if (client_uid != sh_socket_flaguid)
773	{
774	sh_error_handle((-1), FIL__, __LINE__, client_uid, MSG_E_SUBGEN,
775	_("client does not have required uid"),
776	_("sh_socket_read: getsockopt"));
777	close(talkfd);
778	return -1;
779	}
780
781
782	/* Give a diagnostic message.
783	*/
784	#ifdef SH_DEBUG_SOCKET
785	fprintf (stderr, "Server: got message: %s\n", cmd);
786	#endif
787
788	clt = strchr(cmd, ':');
789	if (clt != NULL)
790	{
791	*clt = '\0'; ++clt;
792	if (sl_strlen(cmd) >= SH_MAXMSGLEN)
793	{
794	sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
795	_("Bad message format: command too long"),
796	_("sh_socket_read"));
797	close(talkfd);
798	return -1;
799	}
800	else if (sl_strlen(clt) >= SH_MAXMSGLEN)
801	{
802	sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
803	_("Bad message format: hostname too long"),
804	_("sh_socket_read"));
805	close(talkfd);
806	return -1;
807	}
808	if (cmd[0] == 'L' && cmd[1] == 'I' &&
809	cmd[2] == 'S' && cmd[3] == 'T')
810	{
811	goto list_all;
812	}
813	else if (cmd[0] == 'P' && cmd[1] == 'R' &&
814	cmd[2] == 'O' && cmd[3] == 'B' && cmd[4] == 'E')
815	{
816	sh_socket_probe4reload();
817	cmd[0] = 'L'; cmd[1] = 'I'; cmd[2] = 'S'; cmd[3] = 'T';cmd[4] = '\0';
818	goto list_all;
819	}
820	sl_strlcpy (srvcmd->cmd, cmd, SH_MAXMSGLEN);
821	sl_strlcpy (srvcmd->clt, clt, SH_MAXMSGLEN);
822	--clt; *clt = ':';
823	}
824	else
825	{
826	sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
827	_("Bad message format"),
828	_("sh_socket_read"));
829	close(talkfd);
830	return -1;
831	}
832
833	/* Bounce the message back to the sender.
834	* 'name' is the receiver address; it has been been filled
835	* with the sender address in the recvfrom call
836	*/
837	#ifdef SH_DEBUG_SOCKET
838	fprintf (stderr, "Server: send message: %s to %s\n",
839	cmd, name.sun_path);
840	#endif
841	/*
842	nbytes = sendto (pf_unix_fd, message, nbytes, 0,
843	(struct sockaddr *) & name, size);
844	*/
845	nbytes = send (talkfd, cmd, strlen(cmd) + 1, 0);
846	close(talkfd);
847	if (nbytes < 0)
848	{
849	sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
850	sh_error_message (errno, errbuf, sizeof(errbuf)),
851	_("sh_socket_read: send"));
852	return -1;
853	}
854	#ifdef SH_DEBUG_SOCKET
855	fprintf (stderr, "Server: message is out\n");
856	#endif
857	return nbytes;
858
859	list_all:
860	#ifdef SH_DEBUG_SOCKET
861	fprintf (stderr, "Server: list all\n");
862	#endif
863	if (cmd[4] == 'A' && cmd[5] == 'L' && cmd[6] == 'L')
864	{
865	list_cmd = runlist;
866	while (list_cmd)
867	{
868	sl_snprintf(message, sizeof(message), _("SENT %8s %32s %s"),
869	list_cmd->cmd, list_cmd->clt, list_cmd->cti);
870	/*
871	sl_strlcpy(message, _("DONE"), SH_MAXMSG);
872	sl_strlcat(message, " ", SH_MAXMSG);
873	sl_strlcat(message, list_cmd->cmd, SH_MAXMSG);
874	sl_strlcat(message, " ", SH_MAXMSG);
875	sl_strlcat(message, list_cmd->clt, SH_MAXMSG);
876	sl_strlcat(message, " ", SH_MAXMSG);
877	sl_strlcat(message, list_cmd->cti, SH_MAXMSG);
878	*/
879	nbytes = send (talkfd, message, sl_strlen(message) + 1, 0);
880	if (nbytes < 0)
881	{
882	sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
883	sh_error_message (errno, errbuf, sizeof(errbuf)),
884	_("sh_socket_read: sendto"));
885	close(talkfd);
886	return -1;
887	}
888	list_cmd = list_cmd->next;
889	}
890	}
891
892	list_cmd = cmdlist;
893	while (list_cmd)
894	{
895	sl_snprintf(message, sizeof(message), _(">>>> %8s %32s %s"),
896	list_cmd->cmd, list_cmd->clt, list_cmd->cti);
897	/*
898	sl_strlcpy(message, _(">>>>"), SH_MAXMSG);
899	sl_strlcat(message, " ", SH_MAXMSG);
900	sl_strlcat(message, list_cmd->cmd, SH_MAXMSG);
901	sl_strlcat(message, " ", SH_MAXMSG);
902	sl_strlcat(message, list_cmd->clt, SH_MAXMSG);
903	sl_strlcat(message, " ", SH_MAXMSG);
904	sl_strlcat(message, list_cmd->cti, SH_MAXMSG);
905	*/
906	/*
907	nbytes = sendto (pf_unix_fd, message, sl_strlen(message) + 1, 0,
908	(struct sockaddr *) & name, size);
909	*/
910	nbytes = send (talkfd, message, sl_strlen(message) + 1, 0);
911	if (nbytes < 0)
912	{
913	sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
914	sh_error_message (errno, errbuf, sizeof(errbuf)),
915	_("sh_socket_read: sendto"));
916	close(talkfd);
917	return -1;
918	}
919	list_cmd = list_cmd->next;
920	}
921
922	/*
923	nbytes = sendto (pf_unix_fd, _("END"), 4, 0,
924	(struct sockaddr *) & name, size);
925	*/
926	nbytes = send (talkfd, _("END"), 4, 0);
927	close(talkfd);
928	return 0;
929	}
930	/* #if !defined(HAVE_CMSGCRED) \|\| !defined(SO_PEERCRED) */
931	/* #endif */
932
933	static void sh_socket_add2list (struct socket_cmd * in)
934	{
935	struct socket_cmd * new;
936
937	new = SH_ALLOC(sizeof(struct socket_cmd));
938	sl_strlcpy (new->cmd, in->cmd, sizeof(new->cmd));
939	sl_strlcpy (new->clt, in->clt, sizeof(new->clt));
940	(void) sh_unix_time(0, new->cti, sizeof(new->cti));
941	new->next = cmdlist;
942	cmdlist = new;
943
944	return;
945	}
946
947	static void sh_socket_add2run (struct socket_cmd * in)
948	{
949	struct socket_cmd * new = runlist;
950	char * client_name = in->clt;
951
952	while (new)
953	{
954	if (0 == sl_strcmp(new->clt, client_name))
955	{
956	sl_strlcpy (new->cmd, in->cmd, sizeof(new->cmd));
957	sl_strlcpy (new->clt, in->clt, sizeof(new->clt));
958	(void) sh_unix_time(0, new->cti, sizeof(new->cti));
959	return;
960	}
961	new = new->next;
962	}
963
964	new = SH_ALLOC(sizeof(struct socket_cmd));
965	sl_strlcpy (new->cmd, in->cmd, sizeof(new->cmd));
966	sl_strlcpy (new->clt, in->clt, sizeof(new->clt));
967	(void) sh_unix_time(0, new->cti, sizeof(new->cti));
968	new->next = runlist;
969	runlist = new;
970
971	return;
972	}
973
974
975
976	static void sh_socket_rm2list (const char * client_name)
977	{
978	struct socket_cmd * old = cmdlist;
979	struct socket_cmd * new = cmdlist;
980
981	while (new)
982	{
983	if (0 == sl_strcmp(new->clt, client_name))
984	{
985	if ((new == cmdlist) && (new->next == NULL))
986	{
987	cmdlist = NULL;
988	SH_FREE(new);
989	return;
990	}
991	else if (new == cmdlist)
992	{
993	cmdlist = new->next;
994	SH_FREE(new);
995	return;
996	}
997	else
998	{
999	old->next = new->next;
1000	SH_FREE(new);
1001	return;
1002	}
1003	}
1004	old = new;
1005	new = new->next;
1006	}
1007	return;
1008	}
1009
1010	/* poll the socket to gather input
1011	*/
1012	int sh_socket_poll()
1013	{
1014	struct socket_cmd cmd;
1015	char cancel_cmd[SH_MAXMSGLEN];
1016
1017	/* struct pollfd sh_poll = { pf_unix_fd, POLLIN, 0 }; */
1018
1019	if (pf_unix_fd < 0)
1020	{
1021	return 0;
1022	}
1023
1024	sl_strlcpy(cancel_cmd, _("CANCEL"), sizeof(cancel_cmd));
1025
1026	while (sh_socket_read (&cmd) > 0)
1027	{
1028	if (0 == sl_strcmp(cmd.cmd, cancel_cmd))
1029	{
1030	sh_socket_rm2list (cmd.clt);
1031	}
1032	else
1033	{
1034	sh_socket_rm2list (cmd.clt);
1035	sh_socket_add2list (&cmd);
1036	}
1037	}
1038	return 0;
1039	}
1040
1041	/* return the command associated with client_name
1042	and remove the corresponding entry
1043	*/
1044	char * sh_socket_check(const char * client_name)
1045	{
1046	struct socket_cmd * old = cmdlist;
1047	struct socket_cmd * new = cmdlist;
1048	static char out[SH_MAXMSGLEN];
1049
1050	while (new)
1051	{
1052	if (0 == sl_strcmp(new->clt, client_name))
1053	{
1054	sl_strlcpy(out, new->cmd, sizeof(out));
1055	sh_socket_add2run (new);
1056	sh_socket_rm2list (client_name);
1057	return out;
1058	}
1059	old = new;
1060	new = new->next;
1061	}
1062	return NULL;
1063	}
1064
1065	/* #if defined (SH_WITH_SERVER)
1066	*/
1067	#endif
1068

Note: See TracBrowser for help on using the repository browser.

Download in other formats: