8.2.x/src/fdlist.c

/*
 *  ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
 *
 *  Copyright (c) 1997-2014 ircd-hybrid development team
 *
 *  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
 */

/*! \file fdlist.c
 * \brief Maintains a list of file descriptors.
 * \version $Id$
 */

#include "stdinc.h"
#include "fdlist.h"
#include "client.h"  /* struct Client */
#include "event.h"
#include "ircd.h"    /* GlobalSetOptions */
#include "irc_string.h"
#include "s_bsd.h"   /* comm_setselect */
#include "conf.h"  /* ServerInfo */
#include "send.h"
#include "memory.h"
#include "numeric.h"
#include "misc.h"
#include "res.h"

fde_t *fd_hash[FD_HASH_SIZE];
fde_t *fd_next_in_loop = NULL;
int number_fd = LEAKED_FDS;
int hard_fdlimit = 0;


static int
set_fdlimit(void)
{
  int fdmax;
  struct rlimit limit;

  if (!getrlimit(RLIMIT_NOFILE, &limit))
  {
    limit.rlim_cur = limit.rlim_max;
    setrlimit(RLIMIT_NOFILE, &limit);
  }

  fdmax = getdtablesize();

  /* allow MAXCLIENTS_MIN clients even at the cost of MAX_BUFFER and
   * some not really LEAKED_FDS */
  fdmax = IRCD_MAX(fdmax, LEAKED_FDS + MAX_BUFFER + MAXCLIENTS_MIN);

  /* under no condition shall this raise over 65536
   * for example user ip heap is sized 2*hard_fdlimit */
  hard_fdlimit = IRCD_MIN(fdmax, 65536);

  return -1;
}

void
fdlist_init(void)
{
  set_fdlimit();
}

static inline unsigned int
hash_fd(int fd)
{
  return ((unsigned int)fd) % FD_HASH_SIZE;
}

fde_t *
lookup_fd(int fd)
{
  fde_t *F = fd_hash[hash_fd(fd)];

  while (F)
  {
    if (F->fd == fd)
      return F;
    F = F->hnext;
  }

  return NULL;
}

/* Called to open a given filedescriptor */
void
fd_open(fde_t *F, int fd, int is_socket, const char *desc)
{
  unsigned int hashv = hash_fd(fd);
  assert(fd >= 0);

  F->fd = fd;
  F->comm_index = -1;
  if (desc)
    strlcpy(F->desc, desc, sizeof(F->desc));
  /* Note: normally we'd have to clear the other flags,
   * but currently F is always cleared before calling us.. */
  F->flags.open = 1;
  F->flags.is_socket = is_socket;
  F->hnext = fd_hash[hashv];
  fd_hash[hashv] = F;

  number_fd++;
}

/* Called to close a given filedescriptor */
void
fd_close(fde_t *F)
{
  unsigned int hashv = hash_fd(F->fd);

  if (F == fd_next_in_loop)
    fd_next_in_loop = F->hnext;

  if (F->flags.is_socket)
    comm_setselect(F, COMM_SELECT_WRITE | COMM_SELECT_READ, NULL, NULL, 0);

  delete_resolver_queries(F);

#ifdef HAVE_LIBCRYPTO
  if (F->ssl)
    SSL_free(F->ssl);
#endif

  if (fd_hash[hashv] == F)
    fd_hash[hashv] = F->hnext;
  else {
    fde_t *prev;

    /* let it core if not found */
    for (prev = fd_hash[hashv]; prev->hnext != F; prev = prev->hnext)
      ;
    prev->hnext = F->hnext;
  }

  /* Unlike squid, we're actually closing the FD here! -- adrian */
  close(F->fd);
  number_fd--;

  memset(F, 0, sizeof(fde_t));
}

/*
 * fd_dump() - dump the list of active filedescriptors
 */
void
fd_dump(struct Client *source_p)
{
  for (unsigned int i = 0; i < FD_HASH_SIZE; ++i)
    for (fde_t *F = fd_hash[i]; F; F = F->hnext)
      sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
                         "F :fd %-5d desc '%s'", F->fd, F->desc);
}

/*
 * fd_note() - set the fd note
 *
 * Note: must be careful not to overflow fd_table[fd].desc when
 *       calling.
 */
void
fd_note(fde_t *F, const char *format, ...)
{
  va_list args;

  if (format != NULL)
  {
    va_start(args, format);
    vsnprintf(F->desc, sizeof(F->desc), format, args);
    va_end(args);
  }
  else
    F->desc[0] = '\0';
}

/* Make sure stdio descriptors (0-2) and profiler descriptor (3)
 * always go somewhere harmless.  Use -foreground for profiling
 * or executing from gdb */
void
close_standard_fds(void)
{
  int i;

  for (i = 0; i < LOWEST_SAFE_FD; i++)
  {
    close(i);
    if (open("/dev/null", O_RDWR) < 0)
      exit(-1); /* we're hosed if we can't even open /dev/null */
  }
}

void
close_fds(fde_t *one)
{
  int i;
  fde_t *F;

  for (i = 0; i < FD_HASH_SIZE; i++)
    for (F = fd_hash[i]; F != NULL; F = F->hnext)
      if (F != one)
        close(F->fd);
}
Revision:	3590
Committed:	Sun May 18 15:25:09 2014 UTC (9 years, 11 months ago) by michael
Content type:	text/x-csrc
File size:	4756 byte(s)
Log Message:	- Use sendto_one_numeric() everywhere
#	Content
1	/*
2	* ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
3	*
4	* Copyright (c) 1997-2014 ircd-hybrid development team
5	*
6	* This program is free software; you can redistribute it and/or modify
7	* it under the terms of the GNU General Public License as 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307
19	* USA
20	*/
21
22	/*! \file fdlist.c
23	* \brief Maintains a list of file descriptors.
24	* \version $Id$
25	*/
26
27	#include "stdinc.h"
28	#include "fdlist.h"
29	#include "client.h" /* struct Client */
30	#include "event.h"
31	#include "ircd.h" /* GlobalSetOptions */
32	#include "irc_string.h"
33	#include "s_bsd.h" /* comm_setselect */
34	#include "conf.h" /* ServerInfo */
35	#include "send.h"
36	#include "memory.h"
37	#include "numeric.h"
38	#include "misc.h"
39	#include "res.h"
40
41	fde_t *fd_hash[FD_HASH_SIZE];
42	fde_t *fd_next_in_loop = NULL;
43	int number_fd = LEAKED_FDS;
44	int hard_fdlimit = 0;
45
46
47	static int
48	set_fdlimit(void)
49	{
50	int fdmax;
51	struct rlimit limit;
52
53	if (!getrlimit(RLIMIT_NOFILE, &limit))
54	{
55	limit.rlim_cur = limit.rlim_max;
56	setrlimit(RLIMIT_NOFILE, &limit);
57	}
58
59	fdmax = getdtablesize();
60
61	/* allow MAXCLIENTS_MIN clients even at the cost of MAX_BUFFER and
62	* some not really LEAKED_FDS */
63	fdmax = IRCD_MAX(fdmax, LEAKED_FDS + MAX_BUFFER + MAXCLIENTS_MIN);
64
65	/* under no condition shall this raise over 65536
66	* for example user ip heap is sized 2hard_fdlimit /
67	hard_fdlimit = IRCD_MIN(fdmax, 65536);
68
69	return -1;
70	}
71
72	void
73	fdlist_init(void)
74	{
75	set_fdlimit();
76	}
77
78	static inline unsigned int
79	hash_fd(int fd)
80	{
81	return ((unsigned int)fd) % FD_HASH_SIZE;
82	}
83
84	fde_t *
85	lookup_fd(int fd)
86	{
87	fde_t *F = fd_hash[hash_fd(fd)];
88
89	while (F)
90	{
91	if (F->fd == fd)
92	return F;
93	F = F->hnext;
94	}
95
96	return NULL;
97	}
98
99	/* Called to open a given filedescriptor */
100	void
101	fd_open(fde_t F, int fd, int is_socket, const char desc)
102	{
103	unsigned int hashv = hash_fd(fd);
104	assert(fd >= 0);
105
106	F->fd = fd;
107	F->comm_index = -1;
108	if (desc)
109	strlcpy(F->desc, desc, sizeof(F->desc));
110	/* Note: normally we'd have to clear the other flags,
111	* but currently F is always cleared before calling us.. */
112	F->flags.open = 1;
113	F->flags.is_socket = is_socket;
114	F->hnext = fd_hash[hashv];
115	fd_hash[hashv] = F;
116
117	number_fd++;
118	}
119
120	/* Called to close a given filedescriptor */
121	void
122	fd_close(fde_t *F)
123	{
124	unsigned int hashv = hash_fd(F->fd);
125
126	if (F == fd_next_in_loop)
127	fd_next_in_loop = F->hnext;
128
129	if (F->flags.is_socket)
130	comm_setselect(F, COMM_SELECT_WRITE \| COMM_SELECT_READ, NULL, NULL, 0);
131
132	delete_resolver_queries(F);
133
134	#ifdef HAVE_LIBCRYPTO
135	if (F->ssl)
136	SSL_free(F->ssl);
137	#endif
138
139	if (fd_hash[hashv] == F)
140	fd_hash[hashv] = F->hnext;
141	else {
142	fde_t *prev;
143
144	/* let it core if not found */
145	for (prev = fd_hash[hashv]; prev->hnext != F; prev = prev->hnext)
146	;
147	prev->hnext = F->hnext;
148	}
149
150	/* Unlike squid, we're actually closing the FD here! -- adrian */
151	close(F->fd);
152	number_fd--;
153
154	memset(F, 0, sizeof(fde_t));
155	}
156
157	/*
158	* fd_dump() - dump the list of active filedescriptors
159	*/
160	void
161	fd_dump(struct Client *source_p)
162	{
163	for (unsigned int i = 0; i < FD_HASH_SIZE; ++i)
164	for (fde_t *F = fd_hash[i]; F; F = F->hnext)
165	sendto_one_numeric(source_p, &me, RPL_STATSDEBUG\|SND_EXPLICIT,
166	"F :fd %-5d desc '%s'", F->fd, F->desc);
167	}
168
169	/*
170	* fd_note() - set the fd note
171	*
172	* Note: must be careful not to overflow fd_table[fd].desc when
173	* calling.
174	*/
175	void
176	fd_note(fde_t F, const char format, ...)
177	{
178	va_list args;
179
180	if (format != NULL)
181	{
182	va_start(args, format);
183	vsnprintf(F->desc, sizeof(F->desc), format, args);
184	va_end(args);
185	}
186	else
187	F->desc[0] = '\0';
188	}
189
190	/* Make sure stdio descriptors (0-2) and profiler descriptor (3)
191	* always go somewhere harmless. Use -foreground for profiling
192	* or executing from gdb */
193	void
194	close_standard_fds(void)
195	{
196	int i;
197
198	for (i = 0; i < LOWEST_SAFE_FD; i++)
199	{
200	close(i);
201	if (open("/dev/null", O_RDWR) < 0)
202	exit(-1); /* we're hosed if we can't even open /dev/null */
203	}
204	}
205
206	void
207	close_fds(fde_t *one)
208	{
209	int i;
210	fde_t *F;
211
212	for (i = 0; i < FD_HASH_SIZE; i++)
213	for (F = fd_hash[i]; F != NULL; F = F->hnext)
214	if (F != one)
215	close(F->fd);
216	}