#include "genstamp.h"
#include "threads.h"
#include "citadel_ldap.h"
+#include "context.h"
#include "ctdl_module.h"
int chkpwd_write_pipe[2];
int chkpwd_read_pipe[2];
+
+INLINE long cutuserkey(char *username) {
+ long len;
+ len = strlen(username);
+ if (len >= USERNAME_SIZE)
+ {
+ CtdlLogPrintf (CTDL_EMERG, "Username to long: %s", username);
+ cit_backtrace ();
+ len = USERNAME_SIZE - 1;
+ ((char*)username)[USERNAME_SIZE - 1]='\0';
+ }
+ return len;
+}
+
/*
* makeuserkey() - convert a username into the format used as a database key
* (it's just the username converted into lower case)
*/
-INLINE void makeuserkey(char *key, char *username) {
- int i, len;
+INLINE void makeuserkey(char *key, const char *username, long len) {
+ int i;
- len = strlen(username);
if (len >= USERNAME_SIZE)
{
CtdlLogPrintf (CTDL_EMERG, "Username to long: %s", username);
cit_backtrace ();
len = USERNAME_SIZE - 1;
- username[USERNAME_SIZE - 1]='\0';
}
for (i=0; i<=len; ++i) {
key[i] = tolower(username[i]);
* CtdlGetUser() - retrieve named user into supplied buffer.
* returns 0 on success
*/
-int CtdlGetUser(struct ctdluser *usbuf, char name[])
+int CtdlGetUserLen(struct ctdluser *usbuf, const char *name, long len)
{
char usernamekey[USERNAME_SIZE];
memset(usbuf, 0, sizeof(struct ctdluser));
}
- makeuserkey(usernamekey, name);
+ makeuserkey(usernamekey, name, len);
cdbus = cdb_fetch(CDB_USERS, usernamekey, strlen(usernamekey));
if (cdbus == NULL) { /* user not found */
}
+int CtdlGetUser(struct ctdluser *usbuf, char *name)
+{
+ return CtdlGetUserLen(usbuf, name, cutuserkey(name));
+}
+
+
/*
* CtdlGetUserLock() - same as getuser() but locks the record
*/
{
char usernamekey[USERNAME_SIZE];
- makeuserkey(usernamekey, usbuf->fullname);
+ makeuserkey(usernamekey,
+ usbuf->fullname,
+ cutuserkey(usbuf->fullname));
usbuf->version = REV_LEVEL;
cdb_store(CDB_USERS,
*
*/
int rename_user(char *oldname, char *newname) {
- struct CitContext *cptr;
int retcode = RENAMEUSER_OK;
struct ctdluser usbuf;
char oldnamekey[USERNAME_SIZE];
char newnamekey[USERNAME_SIZE];
- /* We cannot rename a user who is currently logged in */
- for (cptr = ContextList; cptr != NULL; cptr = cptr->next) {
- if (!strcasecmp(cptr->user.fullname, oldname)) {
- return(RENAMEUSER_LOGGED_IN);
- }
- }
-
/* Create the database keys... */
- makeuserkey(oldnamekey, oldname);
- makeuserkey(newnamekey, newname);
+ makeuserkey(oldnamekey, oldname, cutuserkey(oldname));
+ makeuserkey(newnamekey, newname, cutuserkey(newname));
/* Lock up and get going */
begin_critical_section(S_USERS);
+ /* We cannot rename a user who is currently logged in */
+ if (CtdlIsUserLoggedIn(oldname)) {
+ end_critical_section(S_USERS);
+ return RENAMEUSER_LOGGED_IN;
+ }
+
if (CtdlGetUser(&usbuf, newname) == 0) {
retcode = RENAMEUSER_ALREADY_EXISTS;
}
*/
int is_aide(void)
{
- if (CC->user.axlevel >= 6)
+ if (CC->user.axlevel >= AxAideU)
return (1);
else
return (0);
return (0);
}
- if ((CC->user.axlevel >= 6)
+ if ((CC->user.axlevel >= AxAideU)
|| (CC->room.QRroomaide == CC->user.usernum)) {
return (1);
} else {
*
* NOTE: "authname" should only be used if we are attempting to use the "master user" feature
*/
-int CtdlLoginExistingUser(char *authname, char *trythisname)
+int CtdlLoginExistingUser(char *authname, const char *trythisname)
{
char username[SIZ];
int found_user;
+ long len;
CtdlLogPrintf(9, "CtdlLoginExistingUser(%s, %s)\n", authname, trythisname);
}
/* Continue attempting user validation... */
- safestrncpy(username, trythisname, USERNAME_SIZE);
+ safestrncpy(username, trythisname, sizeof (username));
striplt(username);
+ len = cutuserkey(username);
if (IsEmptyStr(username)) {
return login_not_found;
CtdlLogPrintf(CTDL_DEBUG, "found it: uid=%ld, gecos=%s here: %d\n",
(long)pd.pw_uid, pd.pw_gecos, found_user);
if (found_user != 0) {
- create_user(username, 0);
+ len = cutuserkey(username);
+ create_user(username, len, 0);
found_user = getuserbyuid(&CC->user, pd.pw_uid);
}
found_user = getuserbyuid(&CC->user, ldap_uid);
if (found_user != 0) {
- create_user(trythisname, 0);
+ create_user(username, len, 0);
found_user = getuserbyuid(&CC->user, ldap_uid);
}
/* Did we find something? */
if (found_user == 0) {
- if (((CC->nologin)) && (CC->user.axlevel < 6)) {
+ if (((CC->nologin)) && (CC->user.axlevel < AxAideU)) {
return login_too_many_users;
} else {
safestrncpy(CC->curr_user, CC->user.fullname,
* (as specified in setup), automatically assign access level 6.
*/
if (!strcasecmp(CC->user.fullname, config.c_sysadm)) {
- CC->user.axlevel = 6;
+ CC->user.axlevel = AxAideU;
}
/* If we're authenticating off the host system, automatically give
*/
if (config.c_auth_mode == AUTHMODE_HOST) {
if (CC->user.uid == 0) {
- CC->user.axlevel = 6;
+ CC->user.axlevel = AxAideU;
}
}
*/
void logout(void)
{
- struct CitContext *CCC = CC; /* CachedCitContext - performance boost */
+ CtdlUserLogout();
+}
+
+
+void CtdlUserLogout(void)
+{
+ CitContext *CCC = CC; /* CachedCitContext - performance boost */
/*
* If there is a download in progress, abort it.
*/
CCC->logged_in = 0;
/* Check to see if the user was deleted whilst logged in and purge them if necessary */
- if ((CCC->user.axlevel == 0) && (CCC->user.usernum))
+ if ((CCC->user.axlevel == AxDeleted) && (CCC->user.usernum))
purge_user(CCC->user.fullname);
/* Free any output buffers */
}
-int CtdlTryPassword(char *password)
+int CtdlTryPassword(const char *password, long len)
{
int code;
else {
/* native auth mode */
+ char *pw;
- strproc(password);
+ pw = (char*) malloc(len + 1);
+ memcpy(pw, password, len + 1);
+ strproc(pw);
strproc(CC->user.password);
- code = strcasecmp(CC->user.password, password);
- strproc(password);
+ code = strcasecmp(CC->user.password, pw);
+ strproc(pw);
strproc(CC->user.password);
- code = strcasecmp(CC->user.password, password);
+ code = strcasecmp(CC->user.password, pw);
}
if (!code) {
void cmd_pass(char *buf)
{
- char password[256];
+ char password[SIZ];
int a;
+ long len;
memset(password, 0, sizeof(password));
- extract_token(password, buf, 0, '|', sizeof password);
- a = CtdlTryPassword(password);
+ len = extract_token(password, buf, 0, '|', sizeof password);
+ a = CtdlTryPassword(password, len);
switch (a) {
case pass_already_logged_in:
char filename[64];
struct ctdluser usbuf;
char usernamekey[USERNAME_SIZE];
- struct CitContext *ccptr;
- int user_is_logged_in = 0;
- makeuserkey(usernamekey, pname);
+ makeuserkey(usernamekey, pname, cutuserkey(pname));
/* If the name is empty we can't find them in the DB any way so just return */
if (IsEmptyStr(pname))
* set the access level to 0, and let the account get swept up
* during the next purge.
*/
- user_is_logged_in = 0;
- begin_critical_section(S_SESSION_TABLE);
- for (ccptr = ContextList; ccptr != NULL; ccptr = ccptr->next) {
- if (ccptr->user.usernum == usbuf.usernum) {
- user_is_logged_in = 1;
- }
- }
- end_critical_section(S_SESSION_TABLE);
- if (user_is_logged_in == 1) {
+ if (CtdlIsUserLoggedInByNum(usbuf.usernum)) {
CtdlLogPrintf(CTDL_WARNING, "User <%s> is logged in; not deleting.\n", pname);
- usbuf.axlevel = 0;
+ usbuf.axlevel = AxDeleted;
CtdlPutUser(&usbuf);
return (1);
}
CtdlLogPrintf(CTDL_NOTICE, "Deleting user <%s>\n", pname);
+/*
+ * FIXME:
+ * This should all be wrapped in a S_USERS mutex.
+ * Without the mutex the user could log in before we get to the next function
+ * That would truly mess things up :-(
+ * I would like to see the S_USERS start before the CtdlIsUserLoggedInByNum() above
+ * and end after the user has been deleted from the database, below.
+ * Question is should we enter the EVT_PURGEUSER whilst S_USERS is active?
+ */
+
/* Perform any purge functions registered by server extensions */
PerformUserHooks(&usbuf, EVT_PURGEUSER);
}
-int internal_create_user (char *username, struct ctdluser *usbuf, uid_t uid)
+int internal_create_user (const char *username, long len, struct ctdluser *usbuf, uid_t uid)
{
- if (!CtdlGetUser(usbuf, username)) {
+ if (!CtdlGetUserLen(usbuf, username, len)) {
return (ERROR + ALREADY_EXISTS);
}
* Set 'become_user' to nonzero if this is self-service account creation and we want
* to actually log in as the user we just created, otherwise set it to 0.
*/
-int create_user(char *newusername, int become_user)
+int create_user(const char *newusername, long len, int become_user)
{
struct ctdluser usbuf;
struct ctdlroom qrbuf;
struct passwd pd;
struct passwd *tempPwdPtr;
- char pwdbuffer[256];
+ char pwdbuffer[SIZ];
#ifdef HAVE_GETPWNAM_R
#ifdef SOLARIS_GETPWUID
if (IsEmptyStr (username))
{
safestrncpy(username, pd.pw_name, sizeof username);
+ len = cutuserkey(username);
}
}
else {
}
#endif /* HAVE_LDAP */
- if ((retval = internal_create_user(username, &usbuf, uid)) != 0)
+ if ((retval = internal_create_user(username, len, &usbuf, uid)) != 0)
return retval;
/*
void cmd_newu(char *cmdbuf)
{
int a;
+ long len;
char username[26];
if (config.c_auth_mode != AUTHMODE_NATIVE) {
config.c_nodename, config.c_maxsessions);
}
extract_token(username, cmdbuf, 0, '|', sizeof username);
- username[25] = 0;
strproc(username);
+ len = cutuserkey(username);
if (IsEmptyStr(username)) {
cprintf("%d You must supply a user name.\n", ERROR + USERNAME_REQUIRED);
return;
}
- a = create_user(username, 1);
+ a = create_user(username, len, 1);
if (a == 0) {
logged_in_response();
void cmd_creu(char *cmdbuf)
{
int a;
- char username[26];
- char password[32];
+ long len;
+ char username[SIZ];
+ char password[SIZ];
struct ctdluser tmp;
if (CtdlAccessCheck(ac_aide)) {
extract_token(username, cmdbuf, 0, '|', sizeof username);
extract_token(password, cmdbuf, 1, '|', sizeof password);
- username[25] = 0;
- password[31] = 0;
+ ////username[25] = 0;
+ //password[31] = 0;
strproc(username);
strproc(password);
+ len = cutuserkey(username);
if (IsEmptyStr(username)) {
cprintf("%d You must supply a user name.\n", ERROR + USERNAME_REQUIRED);
return;
}
- a = create_user(username, 0);
+ a = create_user(username, len, 0);
if (a == 0) {
if (!IsEmptyStr(password)) {
sizeof(struct ctdluser) : cdbus->len));
cdb_free(cdbus);
if ((usbuf.flags & US_NEEDVALID)
- && (usbuf.axlevel > 0)) {
+ && (usbuf.axlevel > AxDeleted)) {
cprintf("%d %s\n", MORE_DATA, usbuf.fullname);
cdb_close_cursor(CDB_USERS);
return;
extract_token(user, v_args, 0, '|', sizeof user);
newax = extract_int(v_args, 1);
- if (CtdlAccessCheck(ac_aide)) {
+ if (CtdlAccessCheck(ac_aide) ||
+ (newax > AxAideU) ||
+ (newax < AxDeleted)) {
return;
}
return;
}
- if (usbuf->axlevel > 0) {
- if ((CC->user.axlevel >= 6)
+ if (usbuf->axlevel > AxDeleted) {
+ if ((CC->user.axlevel >= AxAideU)
|| ((usbuf->flags & US_UNLISTED) == 0)
|| ((CC->internal_pgm))) {
cprintf("%s|%d|%ld|%ld|%ld|%ld||\n",
if ((REGISCALL != 0) && ((CC->user.flags & US_REGIS) == 0))
regis = 1;
- if (CC->user.axlevel >= 6) {
+ if (CC->user.axlevel >= AxAideU) {
get_control();
if (CitControl.MMflags & MM_VALID)
vali = 1;
usbuf.posted = extract_int(cmdbuf, 4);
if (np > 5) {
newax = extract_int(cmdbuf, 5);
- if ((newax >= 0) && (newax <= 6)) {
- usbuf.axlevel = extract_int(cmdbuf, 5);
+ if ((newax >= AxDeleted) && (newax <= AxAideU)) {
+ usbuf.axlevel = newax;
}
}
if (np > 7) {
usbuf.USuserpurge = extract_int(cmdbuf, 8);
}
CtdlPutUserLock(&usbuf);
- if (usbuf.axlevel == 0) {
+ if (usbuf.axlevel == AxDeleted) {
if (purge_user(requested_user) == 0) {
deleted = 1;
}
-/*
- * Check to see if the user who we just sent mail to is logged in. If yes,
- * bump the 'new mail' counter for their session. That enables them to
- * receive a new mail notification without having to hit the database.
- */
-void BumpNewMailCounter(long which_user) {
- struct CitContext *ptr;
-
- begin_critical_section(S_SESSION_TABLE);
-
- for (ptr = ContextList; ptr != NULL; ptr = ptr->next) {
- if (ptr->user.usernum == which_user) {
- ptr->newmail += 1;
- }
- }
-
- end_critical_section(S_SESSION_TABLE);
-}
-
-
/*
* Count the number of new mail messages the user has
*/