all: updated FSF address in GPL text
[sip-router] / modules / p_usrloc / ul_db_failover_func.c
1 /* sp-ul_db module
2  *
3  * Copyright (C) 2007 1&1 Internet AG
4  *
5  * This file is part of Kamailio, a free SIP server.
6  *
7  * Kamailio is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version
11  *
12  * Kamailio is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License 
18  * along with this program; if not, write to the Free Software 
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
20  */
21
22 #include "ul_db_failover_func.h"
23
24 #include "../../dprint.h"
25 #include "p_usrloc_mod.h"
26 #include "ul_db.h"
27
28 static str autocommit_off = str_init("SET AUTOCOMMIT=0");
29 static str fail_isolation_level = str_init("SET TRANSACTION ISOLATION LEVEL SERIALIZABLE");
30 static str start_transaction = str_init("START TRANSACTION");
31 static str commit = str_init("COMMIT");
32 static str rollback = str_init("ROLLBACK");
33 static str autocommit_on = str_init("SET AUTOCOMMIT=1");
34 static char query[UL_DB_QUERY_LEN];
35
36 int ul_db_failover_prepare(db_func_t * dbf, db1_con_t * dbh) {
37         if(dbf->raw_query(dbh, &autocommit_off, NULL) < 0) {
38                 LM_ERR("could not "
39                                 "set autocommit off!\n");
40                 return -2;
41         }
42         if(dbf->raw_query(dbh, &fail_isolation_level, NULL) < 0) {
43                 LM_ERR("could not "
44                                 "set transaction isolation level!\n");
45                 return -2;
46         }
47         if(dbf->raw_query(dbh, &start_transaction, NULL) < 0) {
48                 LM_ERR("could not "
49                                 "start transaction!\n");
50                 return -2;
51         }
52         return 0;
53 }
54
55 int ul_db_failover_commit(db_func_t * dbf, db1_con_t * dbh) {
56         if(dbf->raw_query(dbh, &commit, NULL) < 0) {
57                 LM_ERR("transaction commit "
58                                 "failed.\n");
59                 return -1;
60         }
61         if(dbf->raw_query(dbh, &autocommit_on, NULL) < 0) {
62                 LM_ERR("could not turn "
63                                 "transaction autocommit on.\n");
64                 return -2;
65         }
66         return 0;
67 }
68
69 int ul_db_failover_rollback(db_func_t * dbf, db1_con_t * dbh) {
70         LM_ERR("rolling back failover "
71                         "transaction.\n");
72         if(dbf->raw_query(dbh, &rollback, NULL) < 0) {
73                 LM_ERR("could not rollback "
74                                 "transaction.\n");
75                 return -1;
76         }
77         if(dbf->raw_query(dbh, &autocommit_on, NULL) < 0) {
78                 LM_ERR("could not set "
79                                 "autocommit on.\n");
80                 return -2;
81         }
82         return 0;
83 }
84
85 int get_max_no_of_db_id(db_func_t * dbf, db1_con_t * dbh, int id){
86         db1_res_t * res;
87         db_row_t * row;
88         int query_len, max;
89         str tmp;
90
91         query_len = 50 + reg_table.len + id_col.len + num_col.len;
92         if(query_len > UL_DB_QUERY_LEN){
93                 LM_ERR("weird: query too long.\n");
94                 return -1;
95         }
96         memset(query, 0, UL_DB_QUERY_LEN);
97         if (sprintf(query,
98                         "SELECT MAX(%.*s) "
99                         "FROM %.*s "
100                         "WHERE %.*s='%i'",
101                         num_col.len, num_col.s,
102                         reg_table.len, reg_table.s,
103                         id_col.len, id_col.s, id) < 0) {
104                 LM_ERR("could not print query\n");
105                 return -1;
106         }
107         tmp.s = query;
108         tmp.len = strlen(query);
109         
110         if(dbf->raw_query(dbh, &tmp, &res) < 0){
111                 LM_ERR("weird: could not query %.*s.\n",
112                    reg_table.len, reg_table.s);
113                 return -1;
114         }
115         if(RES_ROW_N(res) == 0){
116                 LM_ERR("weird: no data found for id %i\n", id);
117                 dbf->free_result(dbh, res);
118                 return -1;
119         }
120         row = RES_ROWS(res);
121         max = VAL_INT(ROW_VALUES(row));
122         dbf->free_result(dbh, res);
123         return max;
124 }
125
126 int store_handle_data(db_func_t * dbf, db1_con_t * dbh, ul_db_t * db, int id, int old_num, int new_id){
127         db_key_t cols[8];
128         db_val_t vals[8];
129         db_key_t keys[2];
130         db_val_t key_vals[8];
131         db_op_t op[2];
132         
133         cols[0] = &id_col;
134         vals[0].type = DB1_INT;
135         vals[0].nul = 0;
136         vals[0].val.int_val = new_id;
137         
138         cols[1] = &num_col;
139         vals[1].type = DB1_INT;
140         vals[1].nul = 0;
141         vals[1].val.int_val = db->no;
142         
143         cols[2] = &url_col;
144         vals[2].type = DB1_STRING;
145         vals[2].nul = 0;
146         vals[2].val.string_val = db->url.s;
147         
148         cols[3] = &error_col;
149         vals[3].type = DB1_INT;
150         vals[3].nul = 0;
151         vals[3].val.int_val = db->errors;
152         
153         cols[4] = &failover_time_col;
154         vals[4].type = DB1_DATETIME;
155         vals[4].nul = 0;
156         vals[4].val.time_val = db->failover_time;
157         
158         cols[5] = &spare_col;
159         vals[5].type = DB1_INT;
160         vals[5].nul = 0;
161         vals[5].val.int_val = db->spare;
162         
163         cols[6] = &status_col;
164         vals[6].type = DB1_INT;
165         vals[6].nul = 0;
166         vals[6].val.int_val = db->status;
167         
168         cols[7] = &risk_group_col;
169         vals[7].type = DB1_INT;
170         vals[7].nul = 0;
171         vals[7].val.int_val = db->rg;
172         
173         keys[0] = &id_col;
174         op[0] = OP_EQ;
175         key_vals[0].type = DB1_INT;
176         key_vals[0].nul = 0;
177         key_vals[0].val.int_val = id;
178         
179         keys[1] = &num_col;
180         op[1] = OP_EQ;
181         key_vals[1].type = DB1_INT;
182         key_vals[1].nul = 0;
183         key_vals[1].val.int_val = old_num;
184         
185         if(dbf->use_table(dbh, &reg_table) < 0){
186                 LM_ERR("could not use reg_table.\n");
187                 return -1;
188         }
189         if(dbf->update(dbh, keys, op, key_vals, cols, vals, 2, 7) < 0){
190                 LM_ERR("could insert handle data.\n");
191                 return -1;
192         }
193         return 0;
194 }
195
196 int check_handle_data(db_func_t * dbf, db1_con_t * dbh, ul_db_t * db, int id){
197         db_key_t cols[2];
198         db_key_t keys[4];
199         db_val_t key_vals[4];
200         db_op_t op[4];
201         db1_res_t * res;
202         
203         cols[0] = &id_col;
204         
205         keys[0] = &id_col;
206         op[0] = OP_EQ;
207         key_vals[0].type = DB1_INT;
208         key_vals[0].nul = 0;
209         key_vals[0].val.int_val = id;
210         
211         keys[1] = &num_col;
212         op[1] = OP_EQ;
213         key_vals[1].type = DB1_INT;
214         key_vals[1].nul = 0;
215         key_vals[1].val.int_val = db->no;
216         
217         keys[2] = &url_col;
218         op[2] = OP_EQ;
219         key_vals[2].type = DB1_STRING;
220         key_vals[2].nul = 0;
221         key_vals[2].val.string_val = db->url.s;
222         
223         if(dbf->use_table(dbh, &reg_table) < 0){
224                 LM_ERR("could not use "
225                                 "reg table.\n");
226                 return -1;
227         }
228         if(dbf->query(dbh, keys, op, key_vals, cols, 3, 1, NULL, &res) < 0){
229                 LM_ERR("could not use "
230                                 "query table.\n");
231                 return -1;
232         }
233         if(RES_ROW_N(res) == 0){
234                 dbf->free_result(dbh, res);
235                 return 1;
236         }
237         dbf->free_result(dbh, res);
238         return 0;
239 }