ircd-hybrid/src/whowas.c

/*
 *  ircd-hybrid: an advanced Internet Relay Chat Daemon(ircd).
 *  whowas.c: WHOWAS user cache.
 *
 *  Copyright (C) 2005 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 "whowas.h"
#include "client.h"
#include "common.h"
#include "hash.h"
#include "ircd.h"
#include "ircd_defs.h"
#include "numeric.h"
#include "s_serv.h"
#include "s_user.h"
#include "send.h"
#include "s_conf.h"

static struct Whowas WHOWAS[NICKNAMEHISTORYLENGTH];
dlink_list WHOWASHASH[HASHSIZE];

void
add_history(struct Client *client_p, int online)
{
  static unsigned int whowas_next = 0;
  struct Whowas *who = &WHOWAS[whowas_next];

  if (++whowas_next == NICKNAMEHISTORYLENGTH)
    whowas_next = 0;

  assert(client_p != NULL);

  /* XXX when is this possible? Looks like it could happen
   * (with a half registered client.)
   * and what is the correct action here? - Dianora
   */
  if (client_p->servptr == NULL)
    return;

  if (who->hashv != -1)
  {
   if (who->online)
      dlinkDelete(&who->cnode, &who->online->whowas);

    dlinkDelete(&who->tnode, &WHOWASHASH[who->hashv]);
  }

  who->hashv  = strhash(client_p->name);
  who->logoff = CurrentTime;

  /* NOTE: strcpy ok here, the sizes in the client struct MUST
   * match the sizes in the whowas struct
   */
  strlcpy(who->name, client_p->name, sizeof(who->name));
  strcpy(who->username, client_p->username);
  strcpy(who->hostname, client_p->host);
  strcpy(who->realname, client_p->info);

  strlcpy(who->servername, client_p->servptr->name, sizeof(who->servername));

  if (online)
  {
    who->online = client_p;
    dlinkAdd(who, &who->cnode, &client_p->whowas);
  }
  else
    who->online = NULL;

  dlinkAdd(who, &who->tnode, &WHOWASHASH[who->hashv]);
}

void
off_history(struct Client *client_p)
{
  dlink_node *ptr = NULL, *ptr_next = NULL;

  DLINK_FOREACH_SAFE(ptr, ptr_next, client_p->whowas.head)
  {
    struct Whowas *temp = ptr->data;
    temp->online = NULL;
    dlinkDelete(&temp->cnode, &client_p->whowas);
  }
}

struct Client *
get_history(const char *nick, time_t timelimit)
{
  dlink_node *ptr = NULL;

  timelimit = CurrentTime - timelimit;

  DLINK_FOREACH(ptr, WHOWASHASH[strhash(nick)].head) {
    struct Whowas *temp = ptr->data;

    if (irccmp(nick, temp->name))
      continue;
    if (temp->logoff < timelimit)
      continue;
    return temp->online;
  }

  return NULL;
}

void
init_whowas(void)
{
  unsigned int i;

  for (i = 0; i < NICKNAMEHISTORYLENGTH; ++i)
  {
    memset(&WHOWAS[i], 0, sizeof(struct Whowas));
    WHOWAS[i].hashv = -1;
  }

  /*
   * Global variables are always 0 initialized,
   * but we do this anyway.
   */
  memset(WHOWASHASH, 0, sizeof(WHOWASHASH));
}
Revision:	194
Committed:	Thu Oct 27 18:56:46 2005 UTC (20 years, 9 months ago) by michael
Content type:	text/x-csrc
File size:	3439 byte(s)
Log Message:	- Fixed several compiletime warnings
#	User	Rev	Content
1	adx	30	/*
2			* ircd-hybrid: an advanced Internet Relay Chat Daemon(ircd).
3			* whowas.c: WHOWAS user cache.
4			*
5			* Copyright (C) 2005 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	knight	31	* $Id$
23	adx	30	*/
24
25			#include "stdinc.h"
26			#include "whowas.h"
27			#include "client.h"
28			#include "common.h"
29			#include "hash.h"
30			#include "ircd.h"
31			#include "ircd_defs.h"
32			#include "numeric.h"
33			#include "s_serv.h"
34			#include "s_user.h"
35			#include "send.h"
36			#include "s_conf.h"
37
38	michael	191	static struct Whowas WHOWAS[NICKNAMEHISTORYLENGTH];
39	michael	194	dlink_list WHOWASHASH[HASHSIZE];
40	adx	30
41			void
42			add_history(struct Client *client_p, int online)
43			{
44	michael	191	static unsigned int whowas_next = 0;
45	adx	30	struct Whowas *who = &WHOWAS[whowas_next];
46
47	michael	191	if (++whowas_next == NICKNAMEHISTORYLENGTH)
48			whowas_next = 0;
49
50	adx	30	assert(client_p != NULL);
51
52			/* XXX when is this possible? Looks like it could happen
53			* (with a half registered client.)
54			* and what is the correct action here? - Dianora
55			*/
56			if (client_p->servptr == NULL)
57			return;
58
59			if (who->hashv != -1)
60			{
61	michael	191	if (who->online)
62			dlinkDelete(&who->cnode, &who->online->whowas);
63
64			dlinkDelete(&who->tnode, &WHOWASHASH[who->hashv]);
65	adx	30	}
66
67			who->hashv = strhash(client_p->name);
68			who->logoff = CurrentTime;
69
70			/* NOTE: strcpy ok here, the sizes in the client struct MUST
71			* match the sizes in the whowas struct
72			*/
73			strlcpy(who->name, client_p->name, sizeof(who->name));
74			strcpy(who->username, client_p->username);
75			strcpy(who->hostname, client_p->host);
76			strcpy(who->realname, client_p->info);
77
78			strlcpy(who->servername, client_p->servptr->name, sizeof(who->servername));
79
80			if (online)
81			{
82			who->online = client_p;
83	michael	191	dlinkAdd(who, &who->cnode, &client_p->whowas);
84	adx	30	}
85			else
86			who->online = NULL;
87
88	michael	191	dlinkAdd(who, &who->tnode, &WHOWASHASH[who->hashv]);
89	adx	30	}
90
91			void
92			off_history(struct Client *client_p)
93			{
94	michael	191	dlink_node ptr = NULL, ptr_next = NULL;
95	adx	30
96	michael	191	DLINK_FOREACH_SAFE(ptr, ptr_next, client_p->whowas.head)
97	adx	30	{
98	michael	191	struct Whowas *temp = ptr->data;
99	adx	30	temp->online = NULL;
100	michael	191	dlinkDelete(&temp->cnode, &client_p->whowas);
101	adx	30	}
102			}
103
104			struct Client *
105			get_history(const char *nick, time_t timelimit)
106			{
107	michael	191	dlink_node *ptr = NULL;
108	adx	30
109			timelimit = CurrentTime - timelimit;
110
111	michael	191	DLINK_FOREACH(ptr, WHOWASHASH[strhash(nick)].head) {
112			struct Whowas *temp = ptr->data;
113
114	adx	30	if (irccmp(nick, temp->name))
115			continue;
116			if (temp->logoff < timelimit)
117			continue;
118	michael	191	return temp->online;
119	adx	30	}
120
121	michael	191	return NULL;
122	adx	30	}
123
124			void
125			init_whowas(void)
126			{
127	michael	191	unsigned int i;
128	adx	30
129	michael	191	for (i = 0; i < NICKNAMEHISTORYLENGTH; ++i)
130	adx	30	{
131			memset(&WHOWAS[i], 0, sizeof(struct Whowas));
132			WHOWAS[i].hashv = -1;
133			}
134
135	michael	191	/*
136			* Global variables are always 0 initialized,
137			* but we do this anyway.
138			*/
139			memset(WHOWASHASH, 0, sizeof(WHOWASHASH));
140	adx	30	}