[fwd] / identify.c

/* -*-c-*-
 *
 * $Id: identify.c,v 1.4 1999/07/27 18:30:53 mdw Exp $
 *
 * Identifies and logs the client of a connection
 *
 * (c) 1999 Straylight/Edgeware
 */

/*----- Licensing notice --------------------------------------------------* 
 *
 * This file is part of the `fw' port forwarder.
 *
 * `fw' is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * `fw' is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with `fw'; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

/*----- Revision history --------------------------------------------------* 
 *
 * $Log: identify.c,v $
 * Revision 1.4  1999/07/27 18:30:53  mdw
 * Various minor portability fixes.
 *
 * Revision 1.3  1999/07/26 23:26:21  mdw
 * Minor modifications for new design.
 *
 * Revision 1.2  1999/07/03 13:56:59  mdw
 * Log connections to syslog or stderr as appropriate.
 *
 * Revision 1.1.1.1  1999/07/01 08:56:23  mdw
 * Initial revision.
 *
 */

/*----- Header files ------------------------------------------------------*/

#include "config.h"

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#include <sys/types.h>
#include <sys/time.h>
#include <unistd.h>
#include <syslog.h>

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>

#include <mLib/alloc.h>
#include <mLib/conn.h>
#include <mLib/dstr.h>
#include <mLib/report.h>
#include <mLib/sel.h>
#include <mLib/selbuf.h>
#include <mLib/str.h>

#include "bres.h"
#include "fw.h"
#include "ident.h"
#include "identify.h"

/*----- Magic numbers -----------------------------------------------------*/

#define TIMEOUT 15			/* Seconds to wait for answers */

/*----- Data structures ---------------------------------------------------*/

/* --- Structure to track the progress of an identification --- */

typedef struct id {
  id_req q;				/* Copy of client's request block */
  time_t when;				/* When the connection occurred */
  conn c;				/* Connection selector */
  unsigned state;			/* Current state of the world */
  bres_client r;			/* Backgd resolver client block */
  char host[64];			/* Resolved hostname */
  char user[32];			/* Authenticated client user */
  sel_timer t;				/* Timeout selector */
  selbuf id;				/* Reader for the RFC931 client */
} id;

#define S_HOST 1u			/* Read the hostname from resolver */
#define S_USER 2u			/* Read the username from RFC931 */
#define S_UCONN 4u			/* Connected to remote RFC931 */
#define S_TIMER 8u			/* Timeout has completed */

/*----- Main code ---------------------------------------------------------*/

/* --- @id_done@ --- *
 *
 * Arguments:	@id *i@ = pointer to identification block
 *
 * Returns:	---
 *
 * Use:		Finishes with an identification block.
 */

static void id_done(id *i)
{
  /* --- Close down the various dependent bits --- */

  if (!(i->state & S_HOST))
    bres_abort(&i->r);
  if (!(i->state & S_UCONN))
    conn_kill(&i->c);
  else if (!(i->state & S_USER))
    selbuf_disable(&i->id);
  if (!(i->state & S_TIMER))
    sel_rmtimer(&i->t);

  /* --- Report the final result --- */

  fw_log(i->when, "[%s] %s from %s@%s [%s]",
	 i->q.desc, i->q.act,
	 i->user, i->host, inet_ntoa(i->q.rsin.sin_addr));

  /* --- Dispose of the block --- */

  REFFD_DEC(i->q.r);
  free(i);
}

/* --- @id_res@ --- *
 *
 * Arguments:	@const char *host@ = name of the resolved host
 *		@void *vp@ = pointer to identification block
 *
 * Returns:	---
 *
 * Use:		Responds to a completed reverse name resolution.
 */

static void id_res(const char *host, void *vp)
{
  id *i = vp;
  str_sanitize(i->host, host, sizeof(i->host));
  i->state |= S_HOST;
  if (i->state & S_USER)
    id_done(i);
}

/* --- @id_ident@ --- *
 *
 * Arguments:	@char *p@ = pointer to string read from server
 *		@void *vp@ = pointer to identification block
 *
 * Returns:	---
 *
 * Use:		Responds to a line read from the remote RFC931 server.
 */

static void id_ident(char *p, void *vp)
{
  id *i = vp;

  /* --- Get rid of the connection --- */

  i->state |= S_USER;
  selbuf_disable(&i->id);
  close(i->id.reader.fd);

  /* --- Read the information from the returned line --- */

  if (p) {
    ident idbuf;
    ident_parse(p, &idbuf);
    if (idbuf.type == ident_userid)
      str_sanitize(i->user, idbuf.u.userid.user, sizeof(i->user));
  }

  /* --- Maybe finish off this identification --- */

  if (i->state & S_HOST)
    id_done(i);
}

/* --- @id_conn@ --- *
 *
 * Arguments:	@int fd@ = file descriptor connected
 *		@void *vp@ = pointer to identification block
 *
 * Returns:	---
 *
 * Use:		Responds to a completed connection to the remote RFC931
 *		server.
 */

static void id_conn(int fd, void *vp)
{
  id *i = vp;

  if (fd == -1) {
    i->state |= S_USER | S_UCONN;
    if (i->state & S_HOST)
      id_done(i);
  } else {
    dstr d = DSTR_INIT;
    dstr_putf(&d, "%u, %u\n",
	      ntohs(i->q.rsin.sin_port), ntohs(i->q.lsin.sin_port));
    write(fd, d.buf, d.len);
    dstr_destroy(&d);
    i->state |= S_UCONN;
    selbuf_init(&i->id, sel, fd, id_ident, i);
  }
}

/* --- @id_timer@ --- *
 *
 * Arguments:	@struct timeval *tv@ = pointer to the current time
 *		@void *vp@ = pointer to identification block
 *
 * Returns:	---
 *
 * Use:		Times an identification job out.
 */

static void id_timer(struct timeval *tv, void *vp)
{
  id *i = vp;
  id_done(i);
}

/* --- @identify@ --- *
 *
 * Arguments:	@const id_req *q@ = pointer to request block
 *
 * Returns:	---
 *
 * Use:		Starts a background ident lookup and reverse-resolve job
 *		which will, eventually, report a message to the system log.
 */

void identify(const id_req *q)
{
  id *i;

  /* --- Initialize the block with stuff --- */

  i = xmalloc(sizeof(*i));
  i->q = *q;
  REFFD_INC(i->q.r);

  str_sanitize(i->host, inet_ntoa(q->rsin.sin_addr), sizeof(i->host));
  strcpy(i->user, "<ANONYMOUS>");
  i->state = 0;
  i->when = time(0);

  /* --- Set up the connection to the identity server --- */

  {
    int fd;
    struct sockaddr_in sin;

    if ((fd = socket(PF_INET, SOCK_STREAM, 0)) < 0)
      id_conn(-1, i);
    else {
      memset(&sin, 0, sizeof(sin));
      sin.sin_family = AF_INET;
      sin.sin_addr = q->lsin.sin_addr;
      sin.sin_port = 0;
      if (bind(fd, (struct sockaddr *)&sin, sizeof(sin))) {
	close(fd);
	id_conn(-1, i);
      } else {
	int opt = 1;
	sin.sin_family = AF_INET;
	sin.sin_addr = q->rsin.sin_addr;
	sin.sin_port = htons(113);
	setsockopt(fd, SOL_SOCKET, SO_OOBINLINE, &opt, sizeof(opt));
	conn_init(&i->c, sel, fd,
		  (struct sockaddr *)&sin, sizeof(sin),
		  id_conn, i);
      }
    }
  }

  /* --- Set up the name resolver --- */

  bres_resolve(&i->r, q->rsin.sin_addr, id_res, i);

  /* --- Set up the time limiter --- */

  {
    struct timeval tv;
    gettimeofday(&tv, 0);
    tv.tv_sec += TIMEOUT;
    sel_addtimer(sel, &i->t, &tv, id_timer, i);
  }
}

/*----- That's all, folks -------------------------------------------------*/
Commit	Line	Data
e82f7154	1	/* --c--
e82f7154	2	*
e0ce9d38	3	* $Id: identify.c,v 1.4 1999/07/27 18:30:53 mdw Exp $
e82f7154	4	*
	5	* Identifies and logs the client of a connection
	6	*
e5398e09	7	* (c) 1999 Straylight/Edgeware
e82f7154	8	*/
	9
	10	/----- Licensing notice --------------------------------------------------
	11	*
	12	* This file is part of the `fw' port forwarder.
	13	*
	14	* `fw' is free software; you can redistribute it and/or modify
	15	* it under the terms of the GNU General Public License as published by
	16	* the Free Software Foundation; either version 2 of the License, or
	17	* (at your option) any later version.
	18	*
	19	* `fw' is distributed in the hope that it will be useful,
	20	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	21	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	22	* GNU General Public License for more details.
	23	*
	24	* You should have received a copy of the GNU General Public License
	25	* along with `fw'; if not, write to the Free Software Foundation,
	26	* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	27	*/
	28
	29	/----- Revision history --------------------------------------------------
	30	*
	31	* $Log: identify.c,v $
e0ce9d38	32	* Revision 1.4 1999/07/27 18:30:53 mdw
	33	* Various minor portability fixes.
	34	*
e5398e09	35	* Revision 1.3 1999/07/26 23:26:21 mdw
	36	* Minor modifications for new design.
	37	*
793f69cd	38	* Revision 1.2 1999/07/03 13:56:59 mdw
	39	* Log connections to syslog or stderr as appropriate.
	40	*
	41	* Revision 1.1.1.1 1999/07/01 08:56:23 mdw
	42	* Initial revision.
e82f7154	43	*
	44	*/
	45
	46	/----- Header files ------------------------------------------------------/
	47
	48	#include "config.h"
	49
	50	#include <errno.h>
	51	#include <stdio.h>
	52	#include <stdlib.h>
	53	#include <string.h>
	54	#include <time.h>
	55
	56	#include <sys/types.h>
	57	#include <sys/time.h>
	58	#include <unistd.h>
	59	#include <syslog.h>
	60
	61	#include <sys/socket.h>
	62	#include <netinet/in.h>
	63	#include <arpa/inet.h>
	64	#include <netdb.h>
	65
	66	#include <mLib/alloc.h>
	67	#include <mLib/conn.h>
	68	#include <mLib/dstr.h>
	69	#include <mLib/report.h>
	70	#include <mLib/sel.h>
	71	#include <mLib/selbuf.h>
	72	#include <mLib/str.h>
	73
	74	#include "bres.h"
	75	#include "fw.h"
	76	#include "ident.h"
	77	#include "identify.h"
	78
	79	/----- Magic numbers -----------------------------------------------------/
	80
	81	#define TIMEOUT 15 /* Seconds to wait for answers */
	82
	83	/----- Data structures ---------------------------------------------------/
	84
	85	/* --- Structure to track the progress of an identification --- */
	86
	87	typedef struct id {
	88	id_req q; /* Copy of client's request block */
e82f7154	89	time_t when; /* When the connection occurred */
	90	conn c; /* Connection selector */
	91	unsigned state; /* Current state of the world */
	92	bres_client r; /* Backgd resolver client block */
	93	char host[64]; /* Resolved hostname */
	94	char user[32]; /* Authenticated client user */
	95	sel_timer t; /* Timeout selector */
	96	selbuf id; /* Reader for the RFC931 client */
	97	} id;
	98
	99	#define S_HOST 1u /* Read the hostname from resolver */
	100	#define S_USER 2u /* Read the username from RFC931 */
	101	#define S_UCONN 4u /* Connected to remote RFC931 */
	102	#define S_TIMER 8u /* Timeout has completed */
	103
	104	/----- Main code ---------------------------------------------------------/
	105
	106	/* --- @id_done@ --- *
	107	*
	108	* Arguments: @id *i@ = pointer to identification block
	109	*
	110	* Returns: ---
	111	*
	112	* Use: Finishes with an identification block.
	113	*/
	114
	115	static void id_done(id *i)
	116	{
e82f7154	117	/* --- Close down the various dependent bits --- */
	118
	119	if (!(i->state & S_HOST))
	120	bres_abort(&i->r);
	121	if (!(i->state & S_UCONN))
	122	conn_kill(&i->c);
	123	else if (!(i->state & S_USER))
	124	selbuf_disable(&i->id);
	125	if (!(i->state & S_TIMER))
	126	sel_rmtimer(&i->t);
	127
	128	/* --- Report the final result --- */
	129
e5398e09	130	fw_log(i->when, "[%s] %s from %s@%s [%s]",
	131	i->q.desc, i->q.act,
	132	i->user, i->host, inet_ntoa(i->q.rsin.sin_addr));
e82f7154	133
	134	/* --- Dispose of the block --- */
	135
e5398e09	136	REFFD_DEC(i->q.r);
e82f7154	137	free(i);
	138	}
	139
	140	/* --- @id_res@ --- *
	141	*
	142	* Arguments: @const char *host@ = name of the resolved host
	143	* @void *vp@ = pointer to identification block
	144	*
	145	* Returns: ---
	146	*
	147	* Use: Responds to a completed reverse name resolution.
	148	*/
	149
	150	static void id_res(const char host, void vp)
	151	{
	152	id *i = vp;
	153	str_sanitize(i->host, host, sizeof(i->host));
	154	i->state \|= S_HOST;
	155	if (i->state & S_USER)
	156	id_done(i);
	157	}
	158
	159	/* --- @id_ident@ --- *
	160	*
	161	* Arguments: @char *p@ = pointer to string read from server
	162	* @void *vp@ = pointer to identification block
	163	*
	164	* Returns: ---
	165	*
	166	* Use: Responds to a line read from the remote RFC931 server.
	167	*/
	168
	169	static void id_ident(char p, void vp)
	170	{
	171	id *i = vp;
	172
	173	/* --- Get rid of the connection --- */
	174
	175	i->state \|= S_USER;
	176	selbuf_disable(&i->id);
	177	close(i->id.reader.fd);
	178
	179	/* --- Read the information from the returned line --- */
	180
	181	if (p) {
	182	ident idbuf;
	183	ident_parse(p, &idbuf);
	184	if (idbuf.type == ident_userid)
	185	str_sanitize(i->user, idbuf.u.userid.user, sizeof(i->user));
	186	}
	187
	188	/* --- Maybe finish off this identification --- */
	189
	190	if (i->state & S_HOST)
	191	id_done(i);
	192	}
	193
	194	/* --- @id_conn@ --- *
	195	*
	196	* Arguments: @int fd@ = file descriptor connected
	197	* @void *vp@ = pointer to identification block
	198	*
	199	* Returns: ---
	200	*
201	* Use: Responds to a completed connection to the remote RFC931
202	* server.
203	*/
204
205	static void id_conn(int fd, void *vp)
206	{
207	id *i = vp;
208
209	if (fd == -1) {
210	i->state \|= S_USER \| S_UCONN;
211	if (i->state & S_HOST)
212	id_done(i);
213	} else {
214	dstr d = DSTR_INIT;
215	dstr_putf(&d, "%u, %u\n",
216	ntohs(i->q.rsin.sin_port), ntohs(i->q.lsin.sin_port));
217	write(fd, d.buf, d.len);
218	dstr_destroy(&d);
219	i->state \|= S_UCONN;
220	selbuf_init(&i->id, sel, fd, id_ident, i);
221	}
222	}
223
224	/* --- @id_timer@ --- *
225	*
226	* Arguments: @struct timeval *tv@ = pointer to the current time
227	* @void *vp@ = pointer to identification block
228	*
229	* Returns: ---
230	*
231	* Use: Times an identification job out.
232	*/
233
234	static void id_timer(struct timeval tv, void vp)
235	{
236	id *i = vp;
237	id_done(i);
238	}
239
240	/* --- @identify@ --- *
241	*
242	* Arguments: @const id_req *q@ = pointer to request block
e82f7154	243	*
	244	* Returns: ---
	245	*
	246	* Use: Starts a background ident lookup and reverse-resolve job
	247	* which will, eventually, report a message to the system log.
	248	*/
	249
e5398e09	250	void identify(const id_req *q)
e82f7154	251	{
	252	id *i;
	253
	254	/* --- Initialize the block with stuff --- */
	255
	256	i = xmalloc(sizeof(*i));
	257	i->q = *q;
e5398e09	258	REFFD_INC(i->q.r);
e82f7154	259
	260	str_sanitize(i->host, inet_ntoa(q->rsin.sin_addr), sizeof(i->host));
	261	strcpy(i->user, "<ANONYMOUS>");
	262	i->state = 0;
	263	i->when = time(0);
	264
	265	/* --- Set up the connection to the identity server --- */
	266
	267	{
	268	int fd;
	269	struct sockaddr_in sin;
	270
	271	if ((fd = socket(PF_INET, SOCK_STREAM, 0)) < 0)
	272	id_conn(-1, i);
	273	else {
e0ce9d38	274	memset(&sin, 0, sizeof(sin));
e82f7154	275	sin.sin_family = AF_INET;
	276	sin.sin_addr = q->lsin.sin_addr;
	277	sin.sin_port = 0;
	278	if (bind(fd, (struct sockaddr *)&sin, sizeof(sin))) {
	279	close(fd);
	280	id_conn(-1, i);
	281	} else {
e5398e09	282	int opt = 1;
e82f7154	283	sin.sin_family = AF_INET;
	284	sin.sin_addr = q->rsin.sin_addr;
	285	sin.sin_port = htons(113);
e5398e09	286	setsockopt(fd, SOL_SOCKET, SO_OOBINLINE, &opt, sizeof(opt));
e82f7154	287	conn_init(&i->c, sel, fd,
	288	(struct sockaddr *)&sin, sizeof(sin),
	289	id_conn, i);
	290	}
	291	}
	292	}
	293
	294	/* --- Set up the name resolver --- */
	295
	296	bres_resolve(&i->r, q->rsin.sin_addr, id_res, i);
	297
	298	/* --- Set up the time limiter --- */
	299
	300	{
	301	struct timeval tv;
	302	gettimeofday(&tv, 0);
	303	tv.tv_sec += TIMEOUT;
	304	sel_addtimer(sel, &i->t, &tv, id_timer, i);
	305	}
	306	}
	307
	308	/----- That's all, folks -------------------------------------------------/