trunk/src/fdlist.c

/*
 *  ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
 *
 *  Copyright (c) 1997-2018 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
 *  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"  /* ConfigServerInfo */
#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;


void
fdlist_init(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);
}

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);
  assert(!F->flags.open);

  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);

  assert(F->flags.open);

  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);

  if (tls_isusing(&F->ssl))
    tls_free(&F->ssl);

  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, int parc, char *parv[])
{
  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)
  {
    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)
{
  for (unsigned int i = 0; i < LOWEST_SAFE_FD; ++i)
  {
    close(i);

    if (open("/dev/null", O_RDWR) < 0)
      exit(EXIT_FAILURE); /* we're hosed if we can't even open /dev/null */
  }
}

void
close_fds(fde_t *one)
{
  for (unsigned int i = 0; i < FD_HASH_SIZE; ++i)
    for (fde_t *F = fd_hash[i]; F; F = F->hnext)
      if (F != one)
        close(F->fd);
}
Revision:	8279
Committed:	Tue Feb 20 19:30:13 2018 UTC (7 years, 6 months ago) by michael
Content type:	text/x-csrc
File size:	4766 byte(s)
Log Message:	- Update copyright years
#	User	Rev	Content
1	adx	30	/*
2	michael	2916	* ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
3	adx	30	*
4	michael	8279	* Copyright (c) 1997-2018 ircd-hybrid development team
5	adx	30	*
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	michael	4565	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
19	adx	30	* USA
20			*/
21	michael	1243
22	michael	2916	/*! \file fdlist.c
23			* \brief Maintains a list of file descriptors.
24			* \version $Id$
25			*/
26
27	adx	30	#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	michael	4340	#include "conf.h" /* ConfigServerInfo */
35	adx	30	#include "send.h"
36			#include "memory.h"
37			#include "numeric.h"
38	michael	3347	#include "misc.h"
39	michael	3322	#include "res.h"
40	adx	30
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	michael	4878	void
48			fdlist_init(void)
49	adx	30	{
50			int fdmax;
51			struct rlimit limit;
52
53	michael	1236	if (!getrlimit(RLIMIT_NOFILE, &limit))
54	adx	30	{
55			limit.rlim_cur = limit.rlim_max;
56	michael	1236	setrlimit(RLIMIT_NOFILE, &limit);
57	adx	30	}
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	michael	1736	hard_fdlimit = IRCD_MIN(fdmax, 65536);
68	adx	30	}
69
70			static inline unsigned int
71			hash_fd(int fd)
72			{
73	michael	2916	return ((unsigned int)fd) % FD_HASH_SIZE;
74	adx	30	}
75
76			fde_t *
77			lookup_fd(int fd)
78			{
79			fde_t *F = fd_hash[hash_fd(fd)];
80
81			while (F)
82			{
83			if (F->fd == fd)
84	michael	2916	return F;
85	adx	30	F = F->hnext;
86			}
87
88	michael	2916	return NULL;
89	adx	30	}
90
91			/* Called to open a given filedescriptor */
92			void
93			fd_open(fde_t F, int fd, int is_socket, const char desc)
94			{
95			unsigned int hashv = hash_fd(fd);
96	michael	5590
97	adx	30	assert(fd >= 0);
98	michael	5590	assert(!F->flags.open);
99	adx	30
100			F->fd = fd;
101			F->comm_index = -1;
102	michael	3602
103	adx	30	if (desc)
104			strlcpy(F->desc, desc, sizeof(F->desc));
105	michael	3602
106	adx	30	/* Note: normally we'd have to clear the other flags,
107			* but currently F is always cleared before calling us.. */
108			F->flags.open = 1;
109			F->flags.is_socket = is_socket;
110			F->hnext = fd_hash[hashv];
111			fd_hash[hashv] = F;
112
113			number_fd++;
114			}
115
116			/* Called to close a given filedescriptor */
117			void
118			fd_close(fde_t *F)
119			{
120			unsigned int hashv = hash_fd(F->fd);
121
122	michael	5590	assert(F->flags.open);
123
124	adx	30	if (F == fd_next_in_loop)
125			fd_next_in_loop = F->hnext;
126
127			if (F->flags.is_socket)
128			comm_setselect(F, COMM_SELECT_WRITE \| COMM_SELECT_READ, NULL, NULL, 0);
129
130	michael	992	delete_resolver_queries(F);
131	adx	30
132	michael	7105	if (tls_isusing(&F->ssl))
133			tls_free(&F->ssl);
134	adx	30
135			if (fd_hash[hashv] == F)
136			fd_hash[hashv] = F->hnext;
137	michael	3602	else
138			{
139	adx	30	fde_t *prev;
140
141			/* let it core if not found */
142			for (prev = fd_hash[hashv]; prev->hnext != F; prev = prev->hnext)
143			;
144			prev->hnext = F->hnext;
145			}
146
147			/* Unlike squid, we're actually closing the FD here! -- adrian */
148			close(F->fd);
149			number_fd--;
150	michael	436
151			memset(F, 0, sizeof(fde_t));
152	adx	30	}
153
154			/*
155			* fd_dump() - dump the list of active filedescriptors
156			*/
157			void
158	michael	4479	fd_dump(struct Client source_p, int parc, char parv[])
159	adx	30	{
160	michael	3589	for (unsigned int i = 0; i < FD_HASH_SIZE; ++i)
161			for (fde_t *F = fd_hash[i]; F; F = F->hnext)
162	michael	5583	sendto_one_numeric(source_p, &me, RPL_STATSDEBUG \| SND_EXPLICIT,
163	michael	3589	"F :fd %-5d desc '%s'", F->fd, F->desc);
164	adx	30	}
165
166			/*
167			* fd_note() - set the fd note
168			*
169			* Note: must be careful not to overflow fd_table[fd].desc when
170			* calling.
171			*/
172			void
173			fd_note(fde_t F, const char format, ...)
174			{
175			va_list args;
176
177	michael	3600	if (format)
178	adx	30	{
179			va_start(args, format);
180			vsnprintf(F->desc, sizeof(F->desc), format, args);
181			va_end(args);
182			}
183			else
184			F->desc[0] = '\0';
185			}
186
187			/* Make sure stdio descriptors (0-2) and profiler descriptor (3)
188			* always go somewhere harmless. Use -foreground for profiling
189			* or executing from gdb */
190			void
191			close_standard_fds(void)
192			{
193	michael	3600	for (unsigned int i = 0; i < LOWEST_SAFE_FD; ++i)
194	adx	30	{
195			close(i);
196	michael	3600
197	michael	1329	if (open("/dev/null", O_RDWR) < 0)
198	michael	6553	exit(EXIT_FAILURE); /* we're hosed if we can't even open /dev/null */
199	adx	30	}
200			}
201
202			void
203			close_fds(fde_t *one)
204			{
205	michael	3600	for (unsigned int i = 0; i < FD_HASH_SIZE; ++i)
206	michael	3602	for (fde_t *F = fd_hash[i]; F; F = F->hnext)
207	adx	30	if (F != one)
208			close(F->fd);
209			}