daemon/auth.c

   1 /*
   2  *  Dolda Connect - Modular multiuser Direct Connect-style client
   3  *  Copyright (C) 2004 Fredrik Tolf <fredrik@dolda2000.com>
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18 */
  19 #include <wchar.h>
  20 #include <errno.h>
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25 #include "auth.h"
  26 #include "utils.h"
  27 #include "module.h"
  28 #include "conf.h"
  29
  30 struct authmech *mechs = NULL;
  31
  32 static int authless_inithandle(struct authhandle *auth, char *username)
  33 {
  34     return(0);
  35 }
  36
  37 static void authless_release(struct authhandle *auth)
  38 {
  39 }
  40
  41 static int authless_authenticate(struct authhandle *auth, struct socket *sk, char *data)
  42 {
  43     return(AUTH_SUCCESS);
  44 }
  45
  46 static int authless_succeed_1param(struct authhandle *auth)
  47 {
  48     return(AUTH_SUCCESS);
  49 }
  50
  51 static struct authmech authless =
  52 {
  53     .name = L"authless",
  54     .inithandle = authless_inithandle,
  55     .release = authless_release,
  56     .authenticate = authless_authenticate,
  57     .renewcred = authless_succeed_1param,
  58     .opensess = authless_succeed_1param,
  59     .closesess = authless_succeed_1param
  60 };
  61
  62 static struct authhandle *newhandle(void)
  63 {
  64     struct authhandle *auth;
  65
  66     auth = smalloc(sizeof(*auth));
  67     auth->refcount = 1;
  68     auth->mech = NULL;
  69     auth->text = NULL;
  70     auth->mechdata = NULL;
  71     return(auth);
  72 }
  73
  74 void authgethandle(struct authhandle *auth)
  75 {
  76     auth->refcount++;
  77 }
  78
  79 void authputhandle(struct authhandle *auth)
  80 {
  81     if(--auth->refcount)
  82         return;
  83     if(auth->text != NULL)
  84         free(auth->text);
  85     if(auth->mechdata != NULL)
  86         auth->mech->release(auth);
  87     free(auth);
  88 }
  89
  90 struct authhandle *initauth(wchar_t *mechname, char *username)
  91 {
  92     struct authmech *mech;
  93     struct authhandle *auth;
  94
  95     for(mech = mechs; mech != NULL; mech = mech->next)
  96     {
  97         if(mech->enabled && !wcscmp(mechname, mech->name))
  98             break;
  99     }
 100     if(mech == NULL)
 101     {
 102         errno = ENOENT;
 103         return(NULL);
 104     }
 105     auth = newhandle();
 106     auth->mech = mech;
 107     if(mech->inithandle(auth, username))
 108     {
 109         authputhandle(auth);
 110         return(NULL);
 111     }
 112     return(auth);
 113 }
 114
 115 int authenticate(struct authhandle *handle, struct socket *sk, char *data)
 116 {
 117     if(handle->mech == NULL)
 118         return(AUTH_ERR);
 119     return(handle->mech->authenticate(handle, sk, data));
 120 }
 121
 122 int authavailable(struct authmech *mech, struct socket *sk)
 123 {
 124     if(mech->available == NULL)
 125         return(1);
 126     return(mech->available(sk));
 127 }
 128
 129 int authrenewcred(struct authhandle *handle)
 130 {
 131     if((handle->mech == NULL) || (handle->mech->renewcred == NULL))
 132         return(AUTH_SUCCESS);
 133     return(handle->mech->renewcred(handle));
 134 }
 135
 136 int authopensess(struct authhandle *handle)
 137 {
 138     if((handle->mech == NULL) || (handle->mech->opensess == NULL))
 139         return(AUTH_SUCCESS);
 140     return(handle->mech->opensess(handle));
 141 }
 142
 143 int authclosesess(struct authhandle *handle)
 144 {
 145     if((handle->mech == NULL) || (handle->mech->closesess == NULL))
 146         return(AUTH_SUCCESS);
 147     return(handle->mech->closesess(handle));
 148 }
 149
 150 void regmech(struct authmech *mech)
 151 {
 152     mech->next = mechs;
 153     mechs = mech;
 154 }
 155
 156 static void preinit(int hup)
 157 {
 158     if(hup)
 159         return;
 160     regmech(&authless);
 161 }
 162
 163 static int init(int hup)
 164 {
 165     authless.enabled = confgetint("auth", "authless");
 166     return(0);
 167 }
 168
 169 static struct configvar myvars[] =
 170 {
 171     /** Specifies whether insecure authentication is to be allowed. If
 172      * you are not completely sure what you are doing, never turn this
 173      * on without also turning on net.onlylocal. */
 174     {CONF_VAR_BOOL, "authless", {.num = 0}},
 175     {CONF_VAR_END}
 176 };
 177
 178 static struct module me =
 179 {
 180     .name = "auth",
 181     .conf =
 182     {
 183         .vars = myvars
 184     },
 185     .preinit = preinit,
 186     .init = init
 187 };
 188
 189 MODULE(me)