trunk/src/userhost.c

/*
 *  ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
 *
 *  Copyright (c) 2003-2015 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 userhost.c
 * \brief Global user limits.
 * \version $Id$
 */

#include "list.h"
#include "hash.h"
#include "client.h"
#include "userhost.h"
#include "mempool.h"
#include "irc_string.h"


static mp_pool_t *userhost_pool;
static mp_pool_t *namehost_pool;


void
userhost_init(void)
{
  userhost_pool = mp_pool_new(sizeof(struct UserHost), MP_CHUNK_SIZE_USERHOST);
  namehost_pool = mp_pool_new(sizeof(struct NameHost), MP_CHUNK_SIZE_NAMEHOST);
}

/* userhost_count()
 *
 * inputs       - user name
 *              - hostname
 *              - int flag 1 if global, 0 if local
 *              - pointer to where global count should go
 *              - pointer to where local count should go
 *              - pointer to where identd count should go (local clients only)
 * output       - none
 * side effects -
 */
void
userhost_count(const char *user, const char *host, unsigned int *global_p,
               unsigned int *local_p, unsigned int *icount_p)
{
  dlink_node *node = NULL;
  struct UserHost *found_userhost;

  if ((found_userhost = hash_find_userhost(host)) == NULL)
    return;

  DLINK_FOREACH(node, found_userhost->list.head)
  {
    struct NameHost *nameh = node->data;

    if (!irccmp(user, nameh->name))
    {
      if (global_p)
        *global_p = nameh->gcount;
      if (local_p)
        *local_p  = nameh->lcount;
      if (icount_p)
        *icount_p = nameh->icount;

      return;
    }
  }
}

/* userhost_find_or_add()
 *
 * inputs       - host name
 * output       - none
 * side effects - find UserHost * for given host name
 */
static struct UserHost *
userhost_find_or_add(const char *host)
{
  struct UserHost *userhost = NULL;

  if ((userhost = hash_find_userhost(host)))
    return userhost;

  userhost = mp_pool_get(userhost_pool);

  strlcpy(userhost->host, host, sizeof(userhost->host));
  hash_add_userhost(userhost);

  return userhost;
}

/* userhost_add()
 *
 * inputs       - user name
 *              - hostname
 *              - int flag 1 if global, 0 if local
 * output       - none
 * side effects - add given user@host to hash tables
 */
void
userhost_add(const char *user, const char *host, int global)
{
  dlink_node *node = NULL;
  struct UserHost *found_userhost;
  struct NameHost *nameh;
  unsigned int hasident = 1;

  if (*user == '~')
  {
    hasident = 0;
    ++user;
  }

  if ((found_userhost = userhost_find_or_add(host)) == NULL)
    return;

  DLINK_FOREACH(node, found_userhost->list.head)
  {
    nameh = node->data;

    if (!irccmp(user, nameh->name))
    {
      nameh->gcount++;

      if (!global)
      {
        if (hasident)
          nameh->icount++;
        nameh->lcount++;
      }

      return;
    }
  }

  nameh = mp_pool_get(namehost_pool);
  nameh->gcount = 1;
  strlcpy(nameh->name, user, sizeof(nameh->name));

  if (!global)
  {
    if (hasident)
      nameh->icount = 1;

    nameh->lcount = 1;
  }

  dlinkAdd(nameh, &nameh->node, &found_userhost->list);
}

/* userhost_del()
 *
 * inputs       - user name
 *              - hostname
 *              - int flag 1 if global, 0 if local
 * output       - none
 * side effects - delete given user@host to hash tables
 */
void
userhost_del(const char *user, const char *host, int global)
{
  dlink_node *node = NULL;
  struct UserHost *found_userhost = NULL;
  unsigned int hasident = 1;

  if (*user == '~')
  {
    hasident = 0;
    ++user;
  }

  if ((found_userhost = hash_find_userhost(host)) == NULL)
    return;

  DLINK_FOREACH(node, found_userhost->list.head)
  {
    struct NameHost *nameh = node->data;

    if (!irccmp(user, nameh->name))
    {
      if (nameh->gcount > 0)
        nameh->gcount--;

      if (!global)
      {
        if (nameh->lcount > 0)
          nameh->lcount--;

        if (hasident && nameh->icount > 0)
          nameh->icount--;
      }

      if (nameh->gcount == 0 && nameh->lcount == 0)
      {
        dlinkDelete(&nameh->node, &found_userhost->list);
        mp_pool_release(nameh);
      }

      if (dlink_list_length(&found_userhost->list) == 0)
      {
        hash_del_userhost(found_userhost);
        mp_pool_release(found_userhost);
      }

      return;
    }
  }
}
Revision:	6441
Committed:	Thu Aug 27 17:04:15 2015 UTC (10 years ago) by michael
Content type:	text/x-csrc
File size:	5045 byte(s)
Log Message:	- Rename functions in userhost.c to comply with naming convention
#	User	Rev	Content
1	michael	6393	/*
2			* ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
3			*
4			* Copyright (c) 2003-2015 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
19			* USA
20			*/
21
22			/*! \file userhost.c
23			* \brief Global user limits.
24			* \version $Id$
25			*/
26
27			#include "list.h"
28			#include "hash.h"
29			#include "client.h"
30			#include "userhost.h"
31			#include "mempool.h"
32			#include "irc_string.h"
33
34
35			static mp_pool_t *userhost_pool;
36			static mp_pool_t *namehost_pool;
37
38
39			void
40			userhost_init(void)
41			{
42			userhost_pool = mp_pool_new(sizeof(struct UserHost), MP_CHUNK_SIZE_USERHOST);
43			namehost_pool = mp_pool_new(sizeof(struct NameHost), MP_CHUNK_SIZE_NAMEHOST);
44			}
45
46	michael	6441	/* userhost_count()
47	michael	6393	*
48			* inputs - user name
49			* - hostname
50			* - int flag 1 if global, 0 if local
51			* - pointer to where global count should go
52			* - pointer to where local count should go
53			* - pointer to where identd count should go (local clients only)
54			* output - none
55			* side effects -
56			*/
57			void
58	michael	6441	userhost_count(const char user, const char host, unsigned int *global_p,
59			unsigned int local_p, unsigned int icount_p)
60	michael	6393	{
61			dlink_node *node = NULL;
62			struct UserHost *found_userhost;
63
64			if ((found_userhost = hash_find_userhost(host)) == NULL)
65			return;
66
67			DLINK_FOREACH(node, found_userhost->list.head)
68			{
69			struct NameHost *nameh = node->data;
70
71			if (!irccmp(user, nameh->name))
72			{
73			if (global_p)
74			*global_p = nameh->gcount;
75			if (local_p)
76			*local_p = nameh->lcount;
77			if (icount_p)
78			*icount_p = nameh->icount;
79
80			return;
81			}
82			}
83			}
84
85	michael	6441	/* userhost_find_or_add()
86	michael	6393	*
87			* inputs - host name
88			* output - none
89			* side effects - find UserHost * for given host name
90			*/
91			static struct UserHost *
92	michael	6441	userhost_find_or_add(const char *host)
93	michael	6393	{
94			struct UserHost *userhost = NULL;
95
96			if ((userhost = hash_find_userhost(host)))
97			return userhost;
98
99			userhost = mp_pool_get(userhost_pool);
100
101			strlcpy(userhost->host, host, sizeof(userhost->host));
102			hash_add_userhost(userhost);
103
104			return userhost;
105			}
106
107	michael	6441	/* userhost_add()
108	michael	6393	*
109			* inputs - user name
110			* - hostname
111			* - int flag 1 if global, 0 if local
112			* output - none
113			* side effects - add given user@host to hash tables
114			*/
115			void
116	michael	6441	userhost_add(const char user, const char host, int global)
117	michael	6393	{
118			dlink_node *node = NULL;
119			struct UserHost *found_userhost;
120			struct NameHost *nameh;
121			unsigned int hasident = 1;
122
123			if (*user == '~')
124			{
125			hasident = 0;
126			++user;
127			}
128
129	michael	6441	if ((found_userhost = userhost_find_or_add(host)) == NULL)
130	michael	6393	return;
131
132			DLINK_FOREACH(node, found_userhost->list.head)
133			{
134			nameh = node->data;
135
136			if (!irccmp(user, nameh->name))
137			{
138			nameh->gcount++;
139
140			if (!global)
141			{
142			if (hasident)
143			nameh->icount++;
144			nameh->lcount++;
145			}
146
147			return;
148			}
149			}
150
151			nameh = mp_pool_get(namehost_pool);
152			nameh->gcount = 1;
153			strlcpy(nameh->name, user, sizeof(nameh->name));
154
155			if (!global)
156			{
157			if (hasident)
158			nameh->icount = 1;
159
160			nameh->lcount = 1;
161			}
162
163			dlinkAdd(nameh, &nameh->node, &found_userhost->list);
164			}
165
166	michael	6441	/* userhost_del()
167	michael	6393	*
168			* inputs - user name
169			* - hostname
170			* - int flag 1 if global, 0 if local
171			* output - none
172			* side effects - delete given user@host to hash tables
173			*/
174			void
175	michael	6441	userhost_del(const char user, const char host, int global)
176	michael	6393	{
177			dlink_node *node = NULL;
178			struct UserHost *found_userhost = NULL;
179			unsigned int hasident = 1;
180
181			if (*user == '~')
182			{
183			hasident = 0;
184			++user;
185			}
186
187			if ((found_userhost = hash_find_userhost(host)) == NULL)
188			return;
189
190			DLINK_FOREACH(node, found_userhost->list.head)
191			{
192			struct NameHost *nameh = node->data;
193
194			if (!irccmp(user, nameh->name))
195			{
196			if (nameh->gcount > 0)
197			nameh->gcount--;
198
199			if (!global)
200			{
201			if (nameh->lcount > 0)
202			nameh->lcount--;
203
204			if (hasident && nameh->icount > 0)
205			nameh->icount--;
206			}
207
208			if (nameh->gcount == 0 && nameh->lcount == 0)
209			{
210			dlinkDelete(&nameh->node, &found_userhost->list);
211			mp_pool_release(nameh);
212			}
213
214			if (dlink_list_length(&found_userhost->list) == 0)
215			{
216			hash_del_userhost(found_userhost);
217			mp_pool_release(found_userhost);
218			}
219
220			return;
221			}
222			}
223			}