Context Navigation

source: trunk/src/sh_socket.c@ 23

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

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

Download in other formats: