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: authcookie.C,v 1.3 2007-07-21 13:23:21 pippijn Exp $";

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

list_t authcookie_list;

void
authcookie_init (void)
{
#if 0
  authcookie_heap = BlockHeapCreate (sizeof (authcookie_t), 1024);
#endif
}

/*
 * 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 = new authcookie_t;

  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);
  sfree (ac->ticket);
  delete 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.4
Committed:	Tue Aug 28 17:08:12 2007 UTC (19 years, 1 month ago) by pippijn
Content type:	text/plain
Branch:	MAIN
Changes since 1.3:	+7 -12 lines
Log Message:	- changed name - updated the example config to the new system - added more documentation - enhanced documentation generators - added a link to the pdf to the website - added an RSS feed generator - transitioned hooks to c++ callbacks - did various merges with upstream along the way - added const where appropriate - removed the old block allocator - fixed most memory leaks - transitioned some dictionaries to std::map - transitioned some lists to std::vector - made some free functions members where appropriate - renamed string to dynstr and added a static string ststr - use NOW instead of time (NULL) if possible - completely reworked database backends, crypto handlers and protocol handlers to use an object factory - removed the old module system. ermyth does not do any dynamic loading anymore - fixed most of the build system - reworked how protocol commands work
#	User	Rev	Content
1	pippijn	1.1	/*
2			* authcookie.C: Remote authentication ticket management
3	pippijn	1.2	* Rights to this code are documented in doc/pod/license.pod.
4	pippijn	1.1	*
5	pippijn	1.4	* Copyright © 2005-2007 Atheme Project (http://www.atheme.org)
6	pippijn	1.1	*/
7
8	pippijn	1.4	static char const rcsid[] = "$Id: authcookie.C,v 1.3 2007-07-21 13:23:21 pippijn Exp $";
9	pippijn	1.1
10			#include "atheme.h"
11			#include "authcookie.h"
12
13			list_t authcookie_list;
14
15			void
16			authcookie_init (void)
17			{
18	pippijn	1.4	#if 0
19	pippijn	1.1	authcookie_heap = BlockHeapCreate (sizeof (authcookie_t), 1024);
20	pippijn	1.4	#endif
21	pippijn	1.1	}
22
23			/*
24			* authcookie_create()
25			*
26			* Inputs:
27			* account associated with the authcookie
28			*
29			* Outputs:
30			* pointer to new authcookie
31			*
32			* Side Effects:
33			* an authcookie ticket is created, and validated.
34			*/
35			authcookie_t *
36			authcookie_create (myuser_t *mu)
37			{
38	pippijn	1.4	authcookie_t *au = new authcookie_t;
39	pippijn	1.1
40			au->ticket = gen_pw (20);
41			au->myuser = mu;
42			au->expire = NOW + 3600;
43
44			node_add (au, &au->node, &authcookie_list);
45
46			return au;
47			}
48
49			/*
50			* authcookie_find()
51			*
52			* Inputs:
53			* either the ticket string, the myuser_t it is associated with, or both
54			*
55			* Outputs:
56			* the authcookie ticket for this object, if any
57			*
58			* Side Effects:
59			* none
60			*/
61			authcookie_t *
62			authcookie_find (char ticket, myuser_t myuser)
63			{
64			node_t *n;
65			authcookie_t *ac;
66
67			/* at least one must be specified */
68			return_val_if_fail (ticket != NULL \|\| myuser != NULL, NULL);
69
70			if (!myuser) /* must have ticket */
71			{
72			LIST_FOREACH (n, authcookie_list.head)
73			{
74			ac = static_cast<authcookie_t *> (n->data);
75
76			if (!strcmp (ac->ticket, ticket))
77			return ac;
78			}
79			}
80			else if (!ticket) /* must have myuser */
81			{
82			LIST_FOREACH (n, authcookie_list.head)
83			{
84			ac = static_cast<authcookie_t *> (n->data);
85
86			if (ac->myuser == myuser)
87			return ac;
88			}
89			}
90			else /* must have both */
91			{
92			LIST_FOREACH (n, authcookie_list.head)
93			{
94			ac = static_cast<authcookie_t *> (n->data);
95
96			if (ac->myuser == myuser && !strcmp (ac->ticket, ticket))
97			return ac;
98			}
99			}
100
101			return NULL;
102			}
103
104			/*
105			* authcookie_destroy()
106			*
107			* Inputs:
108			* an authcookie to destroy
109			*
110			* Outputs:
111			* none
112			*
113			* Side Effects:
114			* an authcookie is destroyed
115			*/
116			void
117			authcookie_destroy (authcookie_t *ac)
118			{
119			return_if_fail (ac != NULL);
120
121			node_del (&ac->node, &authcookie_list);
122	pippijn	1.4	sfree (ac->ticket);
123			delete ac;
124	pippijn	1.1	}
125
126			/*
127			* authcookie_destroy_all()
128			*
129			* Inputs:
130			* a myuser_t pointer
131			*
132			* Outputs:
133			* none
134			*
135			* Side Effects:
136			* all authcookies for the user are destroyed
137			*/
138			void
139			authcookie_destroy_all (myuser_t *mu)
140			{
141			node_t n, tn;
142			authcookie_t *ac;
143
144			LIST_FOREACH_SAFE (n, tn, authcookie_list.head)
145			{
146			ac = static_cast<authcookie_t *> (n->data);
147
148			if (ac->myuser == mu)
149			authcookie_destroy (ac);
150			}
151			}
152
153			/*
154			* authcookie_expire()
155			*
156			* Inputs:
157			* unused arg because this is an event function
158			*
159			* Outputs:
160			* none
161			*
162			* Side Effects:
163			* expired authcookies are destroyed
164			*/
165			void
166			authcookie_expire (void *arg)
167			{
168			authcookie_t *ac;
169			node_t n, tn;
170
171			(void) arg;
172			LIST_FOREACH_SAFE (n, tn, authcookie_list.head)
173			{
174			ac = static_cast<authcookie_t *> (n->data);
175
176			if (ac->expire <= NOW)
177			authcookie_destroy (ac);
178			}
179			}
180
181			/*
182			* authcookie_validate()
183			*
184			* Inputs:
185			* a ticket and myuser pair that needs to be validated
186			*
187			* Outputs:
188			* true if the authcookie is valid,
189			* otherwise false
190			*
191			* Side Effects:
192			* expired authcookies are destroyed here
193			*/
194			bool
195			authcookie_validate (char ticket, myuser_t myuser)
196			{
197			authcookie_t *ac = authcookie_find (ticket, myuser);
198
199			if (ac == NULL)
200			return false;
201
202			if (ac->expire <= NOW)
203			{
204			authcookie_destroy (ac);
205			return false;
206			}
207
208			return true;
209			}
210
211			/* vim:cinoptions=>s,e0,n0,f0,{0,}0,^0,=s,ps,t0,c3,+s,(2s,us,)20,*30,gs,hs
212			* vim:ts=8
213			* vim:sw=8
214			* vim:noexpandtab
215			*/