ermyth/src/authcookie.C

/*
 * authcookie.C: Remote authentication ticket management
 * Rights to this code are documented in doc/pod/license.pod.
 *
 * Copyright © 2005-2007 Atheme Project (http://www.atheme.org)           
 */

static char const rcsid[] = "$Id$";

#include "atheme.h"
#include "authcookie.h"

list_t authcookie_list;
static BlockHeap *authcookie_heap;

void
authcookie_init (void)
{
  authcookie_heap = BlockHeapCreate (sizeof (authcookie_t), 1024);

  if (!authcookie_heap)
    {
      slog (LG_ERROR, "authcookie_init(): cannot initialize block allocator.");
      exit (EXIT_FAILURE);
    }
}

/*
 * authcookie_create()
 *
 * Inputs:
 *       account associated with the authcookie
 *
 * Outputs:
 *       pointer to new authcookie
 *
 * Side Effects:
 *       an authcookie ticket is created, and validated.
 */
authcookie_t *
authcookie_create (myuser_t *mu)
{
  authcookie_t *au = static_cast<authcookie_t *> (BlockHeapAlloc (authcookie_heap));

  au->ticket = gen_pw (20);
  au->myuser = mu;
  au->expire = NOW + 3600;

  node_add (au, &au->node, &authcookie_list);

  return au;
}

/*
 * authcookie_find()
 *
 * Inputs:
 *       either the ticket string, the myuser_t it is associated with, or both
 *
 * Outputs:
 *       the authcookie ticket for this object, if any
 *
 * Side Effects:
 *       none
 */
authcookie_t *
authcookie_find (char *ticket, myuser_t *myuser)
{
  node_t *n;
  authcookie_t *ac;

  /* at least one must be specified */
  return_val_if_fail (ticket != NULL || myuser != NULL, NULL);

  if (!myuser)                  /* must have ticket */
    {
      LIST_FOREACH (n, authcookie_list.head)
      {
        ac = static_cast<authcookie_t *> (n->data);

        if (!strcmp (ac->ticket, ticket))
          return ac;
      }
    }
  else if (!ticket)             /* must have myuser */
    {
      LIST_FOREACH (n, authcookie_list.head)
      {
        ac = static_cast<authcookie_t *> (n->data);

        if (ac->myuser == myuser)
          return ac;
      }
    }
  else                          /* must have both */
    {
      LIST_FOREACH (n, authcookie_list.head)
      {
        ac = static_cast<authcookie_t *> (n->data);

        if (ac->myuser == myuser && !strcmp (ac->ticket, ticket))
          return ac;
      }
    }

  return NULL;
}

/*
 * authcookie_destroy()
 *
 * Inputs:
 *       an authcookie to destroy
 *
 * Outputs:
 *       none
 *
 * Side Effects:
 *       an authcookie is destroyed
 */
void
authcookie_destroy (authcookie_t *ac)
{
  return_if_fail (ac != NULL);

  node_del (&ac->node, &authcookie_list);
  free (ac->ticket);
  BlockHeapFree (authcookie_heap, ac);
}

/*
 * authcookie_destroy_all()
 *
 * Inputs:
 *       a myuser_t pointer
 *
 * Outputs:
 *       none
 *
 * Side Effects:
 *       all authcookies for the user are destroyed
 */
void
authcookie_destroy_all (myuser_t *mu)
{
  node_t *n, *tn;
  authcookie_t *ac;

  LIST_FOREACH_SAFE (n, tn, authcookie_list.head)
  {
    ac = static_cast<authcookie_t *> (n->data);

    if (ac->myuser == mu)
      authcookie_destroy (ac);
  }
}

/*
 * authcookie_expire()
 *
 * Inputs:
 *       unused arg because this is an event function
 *
 * Outputs:
 *       none
 *
 * Side Effects:
 *       expired authcookies are destroyed
 */
void
authcookie_expire (void *arg)
{
  authcookie_t *ac;
  node_t *n, *tn;

  (void) arg;
  LIST_FOREACH_SAFE (n, tn, authcookie_list.head)
  {
    ac = static_cast<authcookie_t *> (n->data);

    if (ac->expire <= NOW)
      authcookie_destroy (ac);
  }
}

/*
 * authcookie_validate()
 *
 * Inputs:
 *       a ticket and myuser pair that needs to be validated
 *
 * Outputs:
 *       true if the authcookie is valid,
 *       otherwise false
 *
 * Side Effects:
 *       expired authcookies are destroyed here
 */
bool
authcookie_validate (char *ticket, myuser_t *myuser)
{
  authcookie_t *ac = authcookie_find (ticket, myuser);

  if (ac == NULL)
    return false;

  if (ac->expire <= NOW)
    {
      authcookie_destroy (ac);
      return false;
    }

  return true;
}

/* vim:cinoptions=>s,e0,n0,f0,{0,}0,^0,=s,ps,t0,c3,+s,(2s,us,)20,*30,gs,hs
 * vim:ts=8
 * vim:sw=8
 * vim:noexpandtab
 */
Revision:	1.3
Committed:	Sat Jul 21 13:23:21 2007 UTC (16 years, 10 months ago) by pippijn
Content type:	text/plain
Branch:	MAIN
Changes since 1.2:	+1 -1 lines
Log Message:	- added rcsid to some files - more documentation tweaks - made most protocol commands local to phandler.C - added ircd metadata (inspircd only for now) - added inspircd swhois support
#	Content
1	/*
2	* authcookie.C: Remote authentication ticket management
3	* Rights to this code are documented in doc/pod/license.pod.
4	*
5	* Copyright © 2005-2007 Atheme Project (http://www.atheme.org)
6	*/
7
8	static char const rcsid[] = "$Id$";
9
10	#include "atheme.h"
11	#include "authcookie.h"
12
13	list_t authcookie_list;
14	static BlockHeap *authcookie_heap;
15
16	void
17	authcookie_init (void)
18	{
19	authcookie_heap = BlockHeapCreate (sizeof (authcookie_t), 1024);
20
21	if (!authcookie_heap)
22	{
23	slog (LG_ERROR, "authcookie_init(): cannot initialize block allocator.");
24	exit (EXIT_FAILURE);
25	}
26	}
27
28	/*
29	* authcookie_create()
30	*
31	* Inputs:
32	* account associated with the authcookie
33	*
34	* Outputs:
35	* pointer to new authcookie
36	*
37	* Side Effects:
38	* an authcookie ticket is created, and validated.
39	*/
40	authcookie_t *
41	authcookie_create (myuser_t *mu)
42	{
43	authcookie_t au = static_cast<authcookie_t > (BlockHeapAlloc (authcookie_heap));
44
45	au->ticket = gen_pw (20);
46	au->myuser = mu;
47	au->expire = NOW + 3600;
48
49	node_add (au, &au->node, &authcookie_list);
50
51	return au;
52	}
53
54	/*
55	* authcookie_find()
56	*
57	* Inputs:
58	* either the ticket string, the myuser_t it is associated with, or both
59	*
60	* Outputs:
61	* the authcookie ticket for this object, if any
62	*
63	* Side Effects:
64	* none
65	*/
66	authcookie_t *
67	authcookie_find (char ticket, myuser_t myuser)
68	{
69	node_t *n;
70	authcookie_t *ac;
71
72	/* at least one must be specified */
73	return_val_if_fail (ticket != NULL \|\| myuser != NULL, NULL);
74
75	if (!myuser) /* must have ticket */
76	{
77	LIST_FOREACH (n, authcookie_list.head)
78	{
79	ac = static_cast<authcookie_t *> (n->data);
80
81	if (!strcmp (ac->ticket, ticket))
82	return ac;
83	}
84	}
85	else if (!ticket) /* must have myuser */
86	{
87	LIST_FOREACH (n, authcookie_list.head)
88	{
89	ac = static_cast<authcookie_t *> (n->data);
90
91	if (ac->myuser == myuser)
92	return ac;
93	}
94	}
95	else /* must have both */
96	{
97	LIST_FOREACH (n, authcookie_list.head)
98	{
99	ac = static_cast<authcookie_t *> (n->data);
100
101	if (ac->myuser == myuser && !strcmp (ac->ticket, ticket))
102	return ac;
103	}
104	}
105
106	return NULL;
107	}
108
109	/*
110	* authcookie_destroy()
111	*
112	* Inputs:
113	* an authcookie to destroy
114	*
115	* Outputs:
116	* none
117	*
118	* Side Effects:
119	* an authcookie is destroyed
120	*/
121	void
122	authcookie_destroy (authcookie_t *ac)
123	{
124	return_if_fail (ac != NULL);
125
126	node_del (&ac->node, &authcookie_list);
127	free (ac->ticket);
128	BlockHeapFree (authcookie_heap, ac);
129	}
130
131	/*
132	* authcookie_destroy_all()
133	*
134	* Inputs:
135	* a myuser_t pointer
136	*
137	* Outputs:
138	* none
139	*
140	* Side Effects:
141	* all authcookies for the user are destroyed
142	*/
143	void
144	authcookie_destroy_all (myuser_t *mu)
145	{
146	node_t n, tn;
147	authcookie_t *ac;
148
149	LIST_FOREACH_SAFE (n, tn, authcookie_list.head)
150	{
151	ac = static_cast<authcookie_t *> (n->data);
152
153	if (ac->myuser == mu)
154	authcookie_destroy (ac);
155	}
156	}
157
158	/*
159	* authcookie_expire()
160	*
161	* Inputs:
162	* unused arg because this is an event function
163	*
164	* Outputs:
165	* none
166	*
167	* Side Effects:
168	* expired authcookies are destroyed
169	*/
170	void
171	authcookie_expire (void *arg)
172	{
173	authcookie_t *ac;
174	node_t n, tn;
175
176	(void) arg;
177	LIST_FOREACH_SAFE (n, tn, authcookie_list.head)
178	{
179	ac = static_cast<authcookie_t *> (n->data);
180
181	if (ac->expire <= NOW)
182	authcookie_destroy (ac);
183	}
184	}
185
186	/*
187	* authcookie_validate()
188	*
189	* Inputs:
190	* a ticket and myuser pair that needs to be validated
191	*
192	* Outputs:
193	* true if the authcookie is valid,
194	* otherwise false
195	*
196	* Side Effects:
197	* expired authcookies are destroyed here
198	*/
199	bool
200	authcookie_validate (char ticket, myuser_t myuser)
201	{
202	authcookie_t *ac = authcookie_find (ticket, myuser);
203
204	if (ac == NULL)
205	return false;
206
207	if (ac->expire <= NOW)
208	{
209	authcookie_destroy (ac);
210	return false;
211	}
212
213	return true;
214	}
215
216	/* vim:cinoptions=>s,e0,n0,f0,{0,}0,^0,=s,ps,t0,c3,+s,(2s,us,)20,*30,gs,hs
217	* vim:ts=8
218	* vim:sw=8
219	* vim:noexpandtab
220	*/