viewcvs.cgi/contrib/recode.c

/*
 *  ircd-hybrid: an advanced Internet Relay Chat Daemon(ircd).
 *  recode.c: Adds codepage option to listen{} blocks.
 *
 *  Copyright (C) 2006 by the past and present ircd coders, and others.
 *
 *  This program 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.
 *
 *  This program 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 this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
 *  USA
 *
 *  $Id: $
 */

#include "stdinc.h"
#include "client.h"
#include "listener.h"
#include "packet.h"
#include "send.h"
#include "conf/conf.h"

struct Conversion
{
  unsigned short port;
  char first;
  void *to_utf8;
  void *from_utf8;
  struct Conversion *hnext;
};

/*
 * Hashing doesn't affect performance here, as we are almost guaranteed
 * to have at most 1 entry per bucket.  Using 65536 as CONVSIZE would just
 * be a waste of 1 MB on 64-bit.
 */

#define CONVSIZE 1024

static struct Conversion *convtab[CONVSIZE];
static dlink_node *hreset, *hiorecv, *hiosend;
static struct ConfSection *section;
static struct ConfField *codepage;
static char *last_codepage = NULL;
static struct ConfField *port;
static CONFF_HANDLER *old_port_handler;

extern void *iconv_open(const char *, const char *);
extern size_t iconv(void *, const char **, size_t *, char **, size_t *);
extern int iconv_close(void *);

/*
 * free_convtab()
 *
 * Deletes all used recode entries and clears the TCP port hash table.
 *
 * inputs: none
 * output: none
 */
static void
free_convtab(void)
{
  int i;
  struct Conversion *p;

  for (i = 0; i < CONVSIZE; i++)
    while ((p = convtab[i]) != NULL)
    {
      if (p->first)
      {
        iconv_close(p->to_utf8);
        iconv_close(p->from_utf8);
      }

      convtab[i] = p->hnext;
      MyFree(p);
    }
}

/*
 * reset_convtab()
 *
 * Wrapper around free_convtab(), used as reset_conf handler.
 *
 * inputs: none
 * output: none
 */
static void *
reset_convtab(va_list args)
{
  free_convtab();

  return pass_callback(hreset);
}

/*
 * my_port_handler()
 *
 * Overrides default port= handler, adding a conversion if requested.
 *
 * inputs:
 *   list  -  pointer to dlink_list of longs
 *   var   -  where to write it
 * output: none
 */
static void
my_port_handler(void *list, void *var)
{
  if (last_codepage != NULL)
  {
    dlink_node *ptr;
    void *to_utf8 = iconv_open("UTF-8", last_codepage);
    void *from_utf8 = iconv_open(last_codepage, "UTF-8");

    if (to_utf8 == (void *) -1 || from_utf8 == (void *) -1)
    {
      parse_error("Unable to open character set [%s]: %s",
        last_codepage, strerror(errno));

      if (to_utf8 != (void *) -1)
        iconv_close(to_utf8);
      if (from_utf8 != (void *) -1)
        iconv_close(from_utf8);
    }
    else
    {
      char first = YES;

      DLINK_FOREACH(ptr, ((dlink_list *) list)->head)
      {
        unsigned short port = (unsigned short) (long) ptr->data;
        struct Conversion *conv = MyMalloc(sizeof(struct Conversion));

        conv->port = port;
        conv->first = first;
        conv->to_utf8 = to_utf8;
        conv->from_utf8 = from_utf8;
        conv->hnext = convtab[port % CONVSIZE];

        convtab[port % CONVSIZE] = conv;
        first = NO;
      }
    }

    MyFree(last_codepage);
    last_codepage = NULL;
  }

  old_port_handler(list, port);
}

/*
 * my_iorecv()
 *
 * Called when data is received from the network.
 *
 * inputs:
 *   client_p  -  the client we get input from
 *   length    -  amound of data read
 *   buf       -  data buffer
 * output: none
 */
static void *
my_iorecv(va_list args)
{
  struct Client *client_p = va_arg(args, struct Client *);
  size_t inlen = va_arg(args, int);
  size_t saved_inlen = inlen;
  const char *inbuf = va_arg(args, char *);
  struct Listener *li = client_p->localClient->listener;
  struct Conversion *conv;

  if (li != NULL)
    for (conv = convtab[li->port % CONVSIZE]; conv != NULL; conv = conv->hnext)
      if (conv->port == li->port)
      {
        char transbuf[2 * READBUF_SIZE];
        size_t outlen = sizeof(transbuf);
        char *outbuf = transbuf;

        iconv(conv->to_utf8, NULL, NULL, NULL, NULL);
        iconv(conv->to_utf8, &inbuf, &inlen, &outbuf, &outlen);

        if ((inlen = outbuf - transbuf) > 0)
          inbuf = transbuf;
        else
          inlen = saved_inlen;
      }

  return pass_callback(hiorecv, client_p, inlen, inbuf);
}

/*
 * my_iosend()
 *
 * Called when data is to be sent over the network.
 *
 * inputs:
 *   client_p  -  the client we write to
 *   length    -  amount of output data
 *   buf       -  data buffer
 * output: none
 */
static void *
my_iosend(va_list args)
{
  struct Client *client_p = va_arg(args, struct Client *);
  size_t inlen = va_arg(args, int);
  size_t saved_inlen = inlen;
  const char *inbuf = va_arg(args, char *);
  struct Listener *li = client_p->localClient->listener;
  struct Conversion *conv;

  if (li != NULL)
    for (conv = convtab[li->port % CONVSIZE]; conv != NULL; conv = conv->hnext)
      if (conv->port == li->port)
      {
        char transbuf[2 * IRCD_BUFSIZE];
        size_t outlen = sizeof(transbuf);
        char *outbuf = transbuf;

        iconv(conv->from_utf8, NULL, NULL, NULL, NULL);
        iconv(conv->from_utf8, &inbuf, &inlen, &outbuf, &outlen);

        if ((inlen = outbuf - transbuf) > 0)
          inbuf = transbuf;
        else
          inlen = saved_inlen;
      }

  return pass_callback(hiosend, client_p, inlen, inbuf);
}

/*
 * Module entry point.
 */
INIT_MODULE(recode, "$Revision: $")
{
  memset(&convtab, 0, sizeof(convtab));

  hreset = install_hook(reset_conf, reset_convtab);

  section = find_conf_section("listen");
  codepage = add_conf_field(section, "codepage", CT_STRING, NULL,
    &last_codepage);

  port = find_conf_field(section, "port");
  old_port_handler = port->handler;
  port->handler = my_port_handler;

  hiorecv = install_hook(iorecv_cb, my_iorecv);
  hiosend = install_hook(iosend_cb, my_iosend);
}

/*
 * Module uninstaller.
 */
CLEANUP_MODULE
{
  uninstall_hook(iorecv_cb, my_iorecv);
  uninstall_hook(iosend_cb, my_iosend);

  port->handler = old_port_handler;

  delete_conf_field(section, codepage);

  uninstall_hook(reset_conf, reset_convtab);

  free_convtab();
}
Revision:	812
Committed:	Thu Sep 7 09:41:54 2006 UTC (20 years, 1 month ago) by michael
Content type:	text/x-csrc
File size:	6744 byte(s)
Log Message:	- Imported contrib/
#	Content
1	/*
2	* ircd-hybrid: an advanced Internet Relay Chat Daemon(ircd).
3	* recode.c: Adds codepage option to listen{} blocks.
4	*
5	* Copyright (C) 2006 by the past and present ircd coders, and others.
6	*
7	* This program is free software; you can redistribute it and/or modify
8	* it under the terms of the GNU General Public License as published by
9	* the Free Software Foundation; either version 2 of the License, or
10	* (at your option) any later version.
11	*
12	* This program is distributed in the hope that it will be useful,
13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	* GNU General Public License for more details.
16	*
17	* You should have received a copy of the GNU General Public License
18	* along with this program; if not, write to the Free Software
19	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
20	* USA
21	*
22	* $Id: $
23	*/
24
25	#include "stdinc.h"
26	#include "client.h"
27	#include "listener.h"
28	#include "packet.h"
29	#include "send.h"
30	#include "conf/conf.h"
31
32	struct Conversion
33	{
34	unsigned short port;
35	char first;
36	void *to_utf8;
37	void *from_utf8;
38	struct Conversion *hnext;
39	};
40
41	/*
42	* Hashing doesn't affect performance here, as we are almost guaranteed
43	* to have at most 1 entry per bucket. Using 65536 as CONVSIZE would just
44	* be a waste of 1 MB on 64-bit.
45	*/
46
47	#define CONVSIZE 1024
48
49	static struct Conversion *convtab[CONVSIZE];
50	static dlink_node hreset, hiorecv, *hiosend;
51	static struct ConfSection *section;
52	static struct ConfField *codepage;
53	static char *last_codepage = NULL;
54	static struct ConfField *port;
55	static CONFF_HANDLER *old_port_handler;
56
57	extern void iconv_open(const char , const char *);
58	extern size_t iconv(void , const char , size_t , char *, size_t );
59	extern int iconv_close(void *);
60
61	/*
62	* free_convtab()
63	*
64	* Deletes all used recode entries and clears the TCP port hash table.
65	*
66	* inputs: none
67	* output: none
68	*/
69	static void
70	free_convtab(void)
71	{
72	int i;
73	struct Conversion *p;
74
75	for (i = 0; i < CONVSIZE; i++)
76	while ((p = convtab[i]) != NULL)
77	{
78	if (p->first)
79	{
80	iconv_close(p->to_utf8);
81	iconv_close(p->from_utf8);
82	}
83
84	convtab[i] = p->hnext;
85	MyFree(p);
86	}
87	}
88
89	/*
90	* reset_convtab()
91	*
92	* Wrapper around free_convtab(), used as reset_conf handler.
93	*
94	* inputs: none
95	* output: none
96	*/
97	static void *
98	reset_convtab(va_list args)
99	{
100	free_convtab();
101
102	return pass_callback(hreset);
103	}
104
105	/*
106	* my_port_handler()
107	*
108	* Overrides default port= handler, adding a conversion if requested.
109	*
110	* inputs:
111	* list - pointer to dlink_list of longs
112	* var - where to write it
113	* output: none
114	*/
115	static void
116	my_port_handler(void list, void var)
117	{
118	if (last_codepage != NULL)
119	{
120	dlink_node *ptr;
121	void *to_utf8 = iconv_open("UTF-8", last_codepage);
122	void *from_utf8 = iconv_open(last_codepage, "UTF-8");
123
124	if (to_utf8 == (void ) -1 \|\| from_utf8 == (void ) -1)
125	{
126	parse_error("Unable to open character set [%s]: %s",
127	last_codepage, strerror(errno));
128
129	if (to_utf8 != (void *) -1)
130	iconv_close(to_utf8);
131	if (from_utf8 != (void *) -1)
132	iconv_close(from_utf8);
133	}
134	else
135	{
136	char first = YES;
137
138	DLINK_FOREACH(ptr, ((dlink_list *) list)->head)
139	{
140	unsigned short port = (unsigned short) (long) ptr->data;
141	struct Conversion *conv = MyMalloc(sizeof(struct Conversion));
142
143	conv->port = port;
144	conv->first = first;
145	conv->to_utf8 = to_utf8;
146	conv->from_utf8 = from_utf8;
147	conv->hnext = convtab[port % CONVSIZE];
148
149	convtab[port % CONVSIZE] = conv;
150	first = NO;
151	}
152	}
153
154	MyFree(last_codepage);
155	last_codepage = NULL;
156	}
157
158	old_port_handler(list, port);
159	}
160
161	/*
162	* my_iorecv()
163	*
164	* Called when data is received from the network.
165	*
166	* inputs:
167	* client_p - the client we get input from
168	* length - amound of data read
169	* buf - data buffer
170	* output: none
171	*/
172	static void *
173	my_iorecv(va_list args)
174	{
175	struct Client client_p = va_arg(args, struct Client );
176	size_t inlen = va_arg(args, int);
177	size_t saved_inlen = inlen;
178	const char inbuf = va_arg(args, char );
179	struct Listener *li = client_p->localClient->listener;
180	struct Conversion *conv;
181
182	if (li != NULL)
183	for (conv = convtab[li->port % CONVSIZE]; conv != NULL; conv = conv->hnext)
184	if (conv->port == li->port)
185	{
186	char transbuf[2 * READBUF_SIZE];
187	size_t outlen = sizeof(transbuf);
188	char *outbuf = transbuf;
189
190	iconv(conv->to_utf8, NULL, NULL, NULL, NULL);
191	iconv(conv->to_utf8, &inbuf, &inlen, &outbuf, &outlen);
192
193	if ((inlen = outbuf - transbuf) > 0)
194	inbuf = transbuf;
195	else
196	inlen = saved_inlen;
197	}
198
199	return pass_callback(hiorecv, client_p, inlen, inbuf);
200	}
201
202	/*
203	* my_iosend()
204	*
205	* Called when data is to be sent over the network.
206	*
207	* inputs:
208	* client_p - the client we write to
209	* length - amount of output data
210	* buf - data buffer
211	* output: none
212	*/
213	static void *
214	my_iosend(va_list args)
215	{
216	struct Client client_p = va_arg(args, struct Client );
217	size_t inlen = va_arg(args, int);
218	size_t saved_inlen = inlen;
219	const char inbuf = va_arg(args, char );
220	struct Listener *li = client_p->localClient->listener;
221	struct Conversion *conv;
222
223	if (li != NULL)
224	for (conv = convtab[li->port % CONVSIZE]; conv != NULL; conv = conv->hnext)
225	if (conv->port == li->port)
226	{
227	char transbuf[2 * IRCD_BUFSIZE];
228	size_t outlen = sizeof(transbuf);
229	char *outbuf = transbuf;
230
231	iconv(conv->from_utf8, NULL, NULL, NULL, NULL);
232	iconv(conv->from_utf8, &inbuf, &inlen, &outbuf, &outlen);
233
234	if ((inlen = outbuf - transbuf) > 0)
235	inbuf = transbuf;
236	else
237	inlen = saved_inlen;
238	}
239
240	return pass_callback(hiosend, client_p, inlen, inbuf);
241	}
242
243	/*
244	* Module entry point.
245	*/
246	INIT_MODULE(recode, "$Revision: $")
247	{
248	memset(&convtab, 0, sizeof(convtab));
249
250	hreset = install_hook(reset_conf, reset_convtab);
251
252	section = find_conf_section("listen");
253	codepage = add_conf_field(section, "codepage", CT_STRING, NULL,
254	&last_codepage);
255
256	port = find_conf_field(section, "port");
257	old_port_handler = port->handler;
258	port->handler = my_port_handler;
259
260	hiorecv = install_hook(iorecv_cb, my_iorecv);
261	hiosend = install_hook(iosend_cb, my_iosend);
262	}
263
264	/*
265	* Module uninstaller.
266	*/
267	CLEANUP_MODULE
268	{
269	uninstall_hook(iorecv_cb, my_iorecv);
270	uninstall_hook(iosend_cb, my_iosend);
271
272	port->handler = old_port_handler;
273
274	delete_conf_field(section, codepage);
275
276	uninstall_hook(reset_conf, reset_convtab);
277
278	free_convtab();
279	}