jabberd2  2.3.6
user.c
Go to the documentation of this file.
1 /*
2  * jabberd - Jabber Open Source Server
3  * Copyright (c) 2002 Jeremie Miller, Thomas Muldowney,
4  * Ryan Eatmon, Robert Norris
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA02111-1307USA
19  */
20 
21 #include "sm.h"
22 
31 static user_t _user_alloc(sm_t sm, jid_t jid) {
32  pool_t p;
33  user_t user;
34 
35  p = pool_new();
36 
37  user = (user_t) pmalloco(p, sizeof(struct user_st));
38 
39  user->p = p;
40  user->sm = sm;
41 
42  user->jid = jid_dup(jid);
43  pool_cleanup(p, (void (*)(void *)) jid_free, user->jid);
44 
45  /* a place for modules to store stuff */
46  user->module_data = (void **) pmalloco(p, sizeof(void *) * sm->mm->nindex);
47 
48  return user;
49 }
50 
53  user_t user;
54 
55  /* already loaded */
56  user = xhash_get(sm->users, jid_user(jid));
57  if(user != NULL) {
58  log_debug(ZONE, "returning previously-created user data for %s", jid_user(jid));
59  return user;
60  }
61 
62  /* make a new one */
63  user = _user_alloc(sm, jid);
64 
65  /* get modules to setup */
66  if(mm_user_load(sm->mm, user) != 0) {
67  log_debug(ZONE, "modules failed user load for %s", jid_user(jid));
68  pool_free(user->p);
69  return NULL;
70  }
71 
72  /* save them for later */
73  xhash_put(sm->users, jid_user(user->jid), (void *) user);
74 
75  log_debug(ZONE, "loaded user data for %s", jid_user(jid));
76 
77  return user;
78 }
79 
80 void user_free(user_t user) {
81  log_debug(ZONE, "freeing user %s", jid_user(user->jid));
82 
83  xhash_zap(user->sm->users, jid_user(user->jid));
84  pool_free(user->p);
85 }
86 
88 int user_create(sm_t sm, jid_t jid) {
89  user_t user;
90 
91  log_debug(ZONE, "create user request for %s", jid_user(jid));
92 
93  /* check whether it is to serviced domain */
94  if(xhash_get(sm->hosts, jid->domain) == NULL) {
95  log_write(sm->log, LOG_ERR, "request to create user for non-serviced domain: jid=%s", jid_user(jid));
96  log_debug(ZONE, "no such domain, not creating");
97  return 1;
98  }
99 
100  user = user_load(sm, jid);
101  if(user != NULL) {
102  log_write(sm->log, LOG_ERR, "request to create already-active user: jid=%s", jid_user(jid));
103  log_debug(ZONE, "user already active, not creating");
104  return 1;
105  }
106 
107  /* modules create */
108  if(mm_user_create(sm->mm, jid) != 0) {
109  log_write(sm->log, LOG_ERR, "user creation failed: jid=%s", jid_user(jid));
110  log_debug(ZONE, "user create failed, forcing deletion for cleanup");
111  mm_user_delete(sm->mm, jid);
112  return 1;
113  }
114 
115  log_write(sm->log, LOG_NOTICE, "created user: jid=%s", jid_user(jid));
116 
117  return 0;
118 }
119 
121 void user_delete(sm_t sm, jid_t jid) {
122  user_t user;
123  sess_t scan, next;
124 
125  log_debug(ZONE, "delete user request for %s", jid_user(jid));
126 
127  user = user_load(sm, jid);
128  if(user == NULL) {
129  log_debug(ZONE, "user doesn't exist, can't delete");
130  return;
131  }
132 
133  /* close their sessions first (this will free user, after the last session ends) */
134  scan = user->sessions;
135  while(scan != NULL) {
136  next = scan->next;
137  sm_c2s_action(scan, "ended", NULL);
138  sess_end(scan);
139  scan = next;
140  }
141 
142  mm_user_delete(sm->mm, jid);
143 
144  log_write(sm->log, LOG_NOTICE, "deleted user: jid=%s", jid_user(jid));
145 }
static sm_t sm
Definition: main.c:33
void pool_free(pool_t p)
Definition: pool.c:226
data structures and prototypes for the session manager
int nindex
counter for module instance sequence (!!! should be local to mm_new)
Definition: sm.h:370
int mm_user_load(mm_t mm, user_t user)
load user data
Definition: mm.c:659
const char * jid_user(jid_t jid)
expand and return the user
Definition: jid.c:339
log_t log
log context
Definition: sm.h:200
void log_write(log_t log, int level, const char *msgfmt,...)
Definition: log.c:104
mm_t mm
module subsystem
Definition: sm.h:213
xht hosts
vHosts map
Definition: sm.h:224
void sm_c2s_action(sess_t dest, const char *action, const char *target)
send a new action route
Definition: sm.c:280
sm_t sm
sm context
Definition: sm.h:237
void user_free(user_t user)
Definition: user.c:80
#define pool_new()
Definition: pool.h:97
xht users
pointers to currently loaded users (key is user@domain)
Definition: sm.h:189
void mm_user_delete(mm_t mm, jid_t jid)
delete user
Definition: mm.c:752
sess_t next
next session (in a list of sessions)
Definition: sm.h:276
void pool_cleanup(pool_t p, pool_cleanup_t f, void *arg)
public cleanup utils, insert in a way that they are run FIFO, before mem frees
Definition: pool.c:251
void sess_end(sess_t sess)
Definition: sess.c:85
pool_t p
memory pool this user is allocated off
Definition: sm.h:235
sess_t sessions
list of action sessions
Definition: sm.h:243
void * pmalloco(pool_t p, int size)
easy safety utility (for creating blank mem for structs, etc)
Definition: pool.c:183
static user_t _user_alloc(sm_t sm, jid_t jid)
make a new one
Definition: user.c:31
session manager global context
Definition: sm.h:167
void jid_free(jid_t jid)
free a jid
Definition: jid.c:286
void xhash_put(xht h, const char *key, void *val)
Definition: xhash.c:163
char * domain
Definition: jid.h:45
Definition: jid.h:42
void xhash_zap(xht h, const char *key)
Definition: xhash.c:235
#define log_debug(...)
Definition: log.h:65
struct user_st * user_t
Definition: sm.h:60
int mm_user_create(mm_t mm, jid_t jid)
create user
Definition: mm.c:721
user_t user_load(sm_t sm, jid_t jid)
fetch user data
Definition: user.c:52
There is one instance of this struct per user who is logged in to this c2s instance.
Definition: c2s.h:74
jid_t jid_dup(jid_t jid)
duplicate a jid
Definition: jid.c:373
jid_t jid
user jid (user@host)
Definition: sm.h:239
void * xhash_get(xht h, const char *key)
Definition: xhash.c:184
#define ZONE
Definition: mio_impl.h:76
void user_delete(sm_t sm, jid_t jid)
trash a user
Definition: user.c:121
void ** module_data
per-user module data
Definition: sm.h:249
pool - base node for a pool.
Definition: pool.h:80
int user_create(sm_t sm, jid_t jid)
initialise a user
Definition: user.c:88
data for a single user
Definition: sm.h:234