pv(k): use $TV(Sn) for string timeval
[sip-router] / modules_k / group / re_group.c
1 /*
2  * $Id$ 
3  *
4  * Copyright (C) 2005-2007 Voice Sistem SRL
5  *
6  * This file is part of Kamailio, a free SIP server.
7  *
8  * Kamailio is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version
12  *
13  * Kamailio is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License 
19  * along with this program; if not, write to the Free Software 
20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
21  *
22  * History:
23  * --------
24  *  2005-10-06 - created by bogdan
25  */
26
27 /**
28  * \file
29  * \brief Group membership module
30  * \ingroup group
31  * - Module: \ref group
32  */
33
34 #include <sys/types.h>
35 #include <regex.h>
36
37 #include "../../str.h"
38 #include "../../mem/mem.h"
39 #include "../../route_struct.h"
40 #include "../../lvalue.h"
41 #include "group_mod.h"
42 #include "re_group.h"
43 #include "group.h"
44
45 /*! regular expression for groups */
46 struct re_grp {
47         regex_t       re;
48         int_str       gid;
49         struct re_grp *next;
50 };
51
52 /*! global regexp list */
53 static struct re_grp *re_list = 0;
54
55
56 /*!
57  * \brief Create a group regexp and add it to the list
58  * \param re regular expression string
59  * \param gid group ID
60  * \return 0 on success, -1 on failure
61  */
62 static int add_re(const char *re, int gid)
63 {
64         struct re_grp *rg;
65
66         LM_DBG("adding <%s> with %d\n",re, gid);
67
68         rg = (struct re_grp*)pkg_malloc(sizeof(struct re_grp));
69         if (rg==0) {
70                 LM_ERR("no more pkg mem\n");
71                 goto error;
72         }
73         memset( rg, 0, sizeof(struct re_grp));
74
75         if (regcomp(&rg->re, re, REG_EXTENDED|REG_ICASE|REG_NEWLINE) ) {
76                 LM_ERR("bad re %s\n", re);
77                 pkg_free(rg);
78                 goto error;
79         }
80
81         rg->gid.n = gid;
82
83         rg->next = re_list;
84         re_list = rg;
85
86         return 0;
87 error:
88         return -1;
89 }
90
91
92 /*!
93  * \brief Load regular expression rules from a database
94  * \param table DB table
95  * \return 0 on success, -1 on failure
96  */
97 int load_re( str *table )
98 {
99         db_key_t cols[2];
100         db1_res_t* res = NULL;
101         db_row_t* row;
102         int n;
103
104         cols[0] = &re_exp_column;
105         cols[1] = &re_gid_column;
106
107         if (group_dbf.use_table(group_dbh, table) < 0) {
108                 LM_ERR("failed to set table <%s>\n", table->s);
109                 goto error;
110         }
111
112         if (group_dbf.query(group_dbh, 0, 0, 0, cols, 0, 2, 0, &res) < 0) {
113                 LM_ERR("failed to query database\n");
114                 goto error;
115         }
116
117         for( n=0 ; n<RES_ROW_N(res) ; n++) {
118                 row = &res->rows[n];
119                 /* validate row */
120                 if (row->values[0].nul || row->values[0].type!=DB1_STRING) {
121                         LM_ERR("empty or non-string "
122                                 "value for <%s>(re) column\n",re_exp_column.s);
123                         goto error1;
124                 }
125                 if (row->values[1].nul || row->values[1].type!=DB1_INT) {
126                         LM_ERR("empty or non-integer "
127                                 "value for <%s>(gid) column\n",re_gid_column.s);
128                         goto error1;
129                 }
130
131                 if ( add_re( row->values[0].val.string_val,
132                 row->values[1].val.int_val)!=0 ) {
133                         LM_ERR("failed to add row\n");
134                         goto error1;
135                 }
136         }
137         LM_DBG("%d rules were loaded\n", n);
138
139         group_dbf.free_result(group_dbh, res);
140         return 0;
141 error1:
142         group_dbf.free_result(group_dbh, res);
143 error:
144         return -1;
145 }
146
147
148 /*!
149  * \brief Get the user group and compare to the regexp list
150  * \param req SIP message
151  * \param user user string
152  * \param avp AVP value
153  * \return number of all matches (positive), -1 on errors or when not found
154  */
155 int get_user_group(struct sip_msg *req, char *user, char *avp)
156 {
157         static char uri_buf[MAX_URI_SIZE];
158         str  username;
159         str  domain;
160         pv_spec_t *pvs;
161         pv_value_t val;
162         struct re_grp *rg;
163         regmatch_t pmatch;
164         char *c;
165         int n;
166
167         if (get_username_domain( req, (group_check_p)user, &username, &domain)!=0){
168                 LM_ERR("failed to get username@domain\n");
169                 goto error;
170         }
171
172         if (username.s==NULL || username.len==0 ) {
173                 LM_DBG("no username part\n");
174                 return -1;
175         }
176
177         if ( 4 + username.len + 1 + domain.len + 1 > MAX_URI_SIZE ) {
178                 LM_ERR("URI to large!!\n");
179                 goto error;
180         }
181
182         *(int*)uri_buf = htonl(('s'<<24) + ('i'<<16) + ('p'<<8) + ':');
183         c = uri_buf + 4;
184         memcpy( c, username.s, username.len);
185         c += username.len;
186         *(c++) = '@';
187         memcpy( c, domain.s, domain.len);
188         c += domain.len;
189         *c = 0;
190
191         LM_DBG("getting groups for <%s>\n",uri_buf);
192         pvs = (pv_spec_t*)avp;
193         memset(&val, 0, sizeof(pv_value_t));
194         val.flags = PV_VAL_INT|PV_TYPE_INT;
195
196         /* check against all re groups */
197         for( rg=re_list,n=0 ; rg ; rg=rg->next ) {
198                 if (regexec( &rg->re, uri_buf, 1, &pmatch, 0)==0) {
199                         LM_DBG("user matched to group %d!\n", rg->gid.n);
200
201                         /* match -> add the gid as AVP */
202                         val.ri = rg->gid.n;
203                         if(pvs->setf(req, &pvs->pvp, (int)EQ_T, &val)<0)
204                         {
205                                 LM_ERR("setting PV AVP failed\n");
206                                 goto error;
207                         }
208                         n++;
209                         /* continue? */
210                         if (multiple_gid==0)
211                                 break;
212                 }
213         }
214
215         return n?n:-1;
216 error:
217         return -1;
218 }
219
220