Develop and Download Open Source Software

XooNIps

Browse CVS Repository

/[OSDN]/xoonips/AL/commonal.cc

Contents of /xoonips/AL/commonal.cc

Parent Directory Parent Directory | Revision Log Revision Log | View Revision Graph Revision Graph

Revision 1.120 - (show annotations) (download) (as text)
Tue Apr 11 10:31:27 2006 UTC (17 years, 10 months ago) by tani
Branch: MAIN
CVS Tags: AL_PORTING, tag20070307current, tag20061130, merge_to_20060605, tag20070307, HEAD
Branch point for: XOONIPS_STABLE_32, XOONIPS_STABLE_3
Changes since 1.119: +57 -29 lines
File MIME type: text/x-c++src 
merge to main trunk (from REL20060213 to merge_to_20060411)
REL20060213からmerge_to_20060411までのSTABLE_2の差分をCURRENTにマージ.
1 /*
2 * --------------------------------------------------------------------------
3 * XooNiPs Xoops modules for Neuroinformatics Platforms
4 * Copyright (C) 2005 RIKEN, Japan. All rights reserved.
5 * http://sourceforge.jp/projects/xoonips/
6 * --------------------------------------------------------------------------
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version 2
10 * of the License, or (at your option) any later version.
11 *
12 * This program 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
20 * --------------------------------------------------------------------------
21 *
22 *
23 * $Revision: 1.119 $
24 * $Log: commonal.cc,v $
25 * Revision 1.118.2.2 2006/02/28 04:49:17 aga4096
26 * 鐃緒申NIJC code, guest鐃緒申on/off鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申 item_status 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
27 *
28 * Revision 1.118.2.1 2006/02/14 05:13:17 aga4096
29 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申 private/index_a 鐃緒申 public/index_b 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申 private/index_a鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
30 *
31 * Revision 1.119 2006/04/07 08:19:51 tani
32 * doi鐃緒申DB鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申BLOB鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
33 *
34 * Revision 1.118 2006/01/10 10:56:30 tani
35 * selectiveHarvesting:stat.item_id鐃緒申order by(asc)
36 *
37 * Revision 1.117 2006/01/06 05:50:32 aga4096
38 * 鐃緒申 ctype.h 鐃緒申include.
39 *
40 * Revision 1.116 2005/11/22 11:29:54 tani
41 * deleteItem: 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申Related to鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
42 * getRelatedTo: isActivatedBySession鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申).
43 *
44 * Revision 1.115 2005/11/17 10:59:36 tani
45 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申: insertRelatedTo, deleteRelatedTo, getRelatedTo鐃緒申鐃緒申鐃緒申.
46 *
47 * Revision 1.114 2005/11/16 03:59:06 tani
48 * XOONIPS_STABLE鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申MergePnt_20051116鐃緒申鐃緒申XooNIps_STABLE鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申CURRENT鐃緒申鐃緒申鐃緒申鐃緒申.
49 *
50 * Revision 1.113.2.3 2005/11/01 10:36:14 tani
51 * _insertItem: dierct鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
52 *
53 * Revision 1.113.2.2 2005/10/28 07:02:52 aga4096
54 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
55 *
56 * Revision 1.113.2.1 2005/10/18 09:19:53 aga4096
57 * 鐃緒申PubMed鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
58 *
59 * Revision 1.113 2005/10/11 16:20:22 orrisroot
60 * SQLRowCount 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
61 *
62 * Revision 1.112 2005/10/07 06:22:46 aga4096
63 * 鐃緒申updateAccount()鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
64 *
65 * Revision 1.111 2005/09/26 02:24:34 aga4096
66 * 鐃緒申isAdmin()鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
67 *
68 * Revision 1.110 2005/09/09 06:26:35 aga4096
69 * 鐃緒申xnp_use_syslog()鐃緒申鐃緒申鐃緒申.
70 *
71 * Revision 1.109 2005/09/09 01:29:27 aga4096
72 * 鐃緒申refresh_item_status, update_item_status鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
73 *
74 * Revision 1.108 2005/09/08 05:40:21 tani
75 * freeStringArray鐃緒申鐃緒申鐃緒申.
76 * selectiveHarvesting鐃緒申OAIPMH鐃緒申identifier鐃緒申鐃緒申鐃緒申.
77 * XNP_CONFIG_REPOSITORY_NIJC_CODE鐃緒申鐃緒申鐃緒申.
78 *
79 * Revision 1.107 2005/08/30 09:39:31 aga4096
80 * 鐃緒申xnp_get_item_status 鐃緒申鐃緒申鐃緒申.
81 *
82 * Revision 1.106 2005/08/29 07:11:05 aga4096
83 * 鐃緒申xnp_update_item_status, xnp_selective_harvesting鐃緒申鐃緒申鐃緒申.
84 *
85 * Revision 1.105 2005/08/29 05:27:37 aga4096
86 * 鐃緒申update_item_status鐃緒申鐃緒申鐃緒申.
87 *
88 * Revision 1.104 2005/08/29 02:05:34 aga4096
89 * 鐃緒申xnp_update_item_status(), xnp_refresh_item_status(), xnp_selective_harvesting() 鐃緒申鐃緒申鐃緒申.
90 *
91 * Revision 1.103 2005/08/23 07:34:24 tani
92 * Language鐃緒申鐃緒申: getItems, _insetItem, updateItem
93 *
94 * Revision 1.102 2005/08/23 02:19:10 tani
95 * getEventsForRSS鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
96 *
97 * Revision 1.101 2005/08/08 01:57:00 aga4096
98 * 鐃緒申2鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申initializeDB鐃緒申鐃緒申鐃緒申.
99 * 鐃緒申valgrind鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
100 *
101 * Revision 1.100 2005/07/21 01:47:57 tani
102 * getEventsForRSS鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
103 *
104 * Revision 1.99 2005/07/15 04:42:33 aga4096
105 * 鐃緒申getItemTypes鐃緒申鐃緒申DB鐃緒申NULL鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
106 *
107 * Revision 1.98 2005/07/12 06:40:44 aga4096
108 * 鐃緒申setConfigValue鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
109 *
110 * Revision 1.97 2005/06/30 07:21:42 aga4096
111 * 鐃緒申get_all_index鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申index鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
112 *
113 * Revision 1.96 2005/06/29 00:10:18 aga4096
114 * 鐃緒申login name -> additional info 鐃緒申鐃緒申鐃緒申.
115 *
116 * Revision 1.95 2005/06/24 02:07:34 tani
117 * insertItemDirect鐃緒申鐃緒申鐃緒申(Import鐃緒申)
118 * getPrivateItemID鐃緒申鐃緒申BINDER鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申)
119 *
120 * Revision 1.94 2005/06/23 07:58:12 aga4096
121 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
122 *
123 * Revision 1.93 2005/06/14 01:02:20 aga4096
124 * 鐃緒申鐃緒申鐃緒申Binder鐃緒申鐃緒申鐃緒申鐃緒申. xnp_extract_public_item_id, xnp_extract_nonbinder_item_id 鐃緒申鐃緒申鐃緒申.
125 *
126 * Revision 1.92 2005/06/08 04:27:08 tani
127 * default鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
128 *
129 * Revision 1.91 2005/06/07 01:10:33 tani
130 * SQLGetData鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
131 * SQLExecDirect鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申SQLExecute鐃緒申鐃緒申鐃緒申.
132 *
133 * Revision 1.90 2005/05/23 08:00:30 tani
134 * insertGroup, updateGroup: 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
135 *
136 * Revision 1.89 2005/05/18 10:00:17 aga4096
137 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
138 *
139 * Revision 1.88 2005/03/17 16:02:40 orrisroot
140 * UNIX 鐃緒申鐃緒申鐃緒申鐃緒申 SQLLEN 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申configure
141 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申 config.h 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
142 * 鐃緒申 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申 MacOS X 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
143 *
144 * Revision 1.87 2005/03/15 12:09:39 tani
145 * deleteItem 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
146 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
147 *
148 * Revision 1.86 2005/03/15 04:49:40 tani
149 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
150 *
151 * Revision 1.85 2005/03/14 09:30:50 aga4096
152 * 鐃緒申getItemCountByIndex鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
153 *
154 * Revision 1.84 2005/03/14 06:12:11 tani
155 * __BORLANDC__鐃緒申鐃緒申.
156 *
157 * Revision 1.83 2005/03/11 20:00:28 orrisroot
158 * - Autotoolized XooNiPs Abstract Layer projects.
159 * - changelog.cc commonal.cc index.cc item.cc :
160 * included <time.h> header file for undefined data type 'time_t' error.
161 *
162 * Revision 1.82 2005/03/11 07:11:30 tani
163 * itemid_t鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(*iidsLen)鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
164 *
165 * Revision 1.81 2005/03/11 00:34:57 tani
166 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申certify_state鐃緒申鐃緒申.
167 *
168 * Revision 1.80 2005/03/09 07:27:37 aga4096
169 * 鐃緒申activate=0鐃緒申鐃緒申loginUser鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
170 *
171 * Revision 1.79 2005/03/07 01:20:09 aga4096
172 * 鐃緒申getItemCountGroupByIndex鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
173 *
174 * Revision 1.78 2005/03/05 02:28:05 aga4096
175 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申 Private 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
176 *
177 * Revision 1.77 2005/03/05 01:48:35 aga4096
178 * 鐃緒申getItemCountGroupByIndex鐃緒申鐃緒申鐃緒申.
179 *
180 * Revision 1.76 2005/03/04 06:13:28 aga4096
181 * 鐃緒申updateIndex鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
182 *
183 * Revision 1.75 2005/03/03 10:13:00 aga4096
184 * 鐃緒申isValidSession鐃緒申timestamp鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
185 * 鐃緒申session鐃緒申isValidSession鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申1鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
186 * 鐃緒申loginUser, createSession鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申session鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
187 *
188 * Revision 1.74 2005/02/26 05:11:31 tani
189 * getGroupItemID鐃緒申鐃緒申.
190 *
191 * Revision 1.73 2005/02/25 07:41:35 tani
192 * getGroupItemID鐃緒申鐃緒申.
193 * item, index鐃緒申limit鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
194 *
195 * Revision 1.72 2005/02/25 01:03:42 tani
196 * dbtype==DBTYPE_SQLITE鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
197 *
198 * Revision 1.71 2005/02/24 11:32:55 aga4096
199 * 鐃緒申updateGroup鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
200 *
201 * Revision 1.70 2005/02/23 06:39:28 tani
202 * isGuestEnabled: 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
203 *
204 * Revision 1.69 2005/02/22 02:39:30 tani
205 * public_item_target_user_all鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
206 * SQL鐃緒申鐃緒申public_item_target_user_all鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申public_item_target_user_all鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
207 * session鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申LEFT JOIN鐃緒申鐃緒申鐃緒申鐃緒申sid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
208 * DB鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
209 *
210 * Revision 1.68 2005/02/21 05:46:18 tani
211 * getItemCount鐃緒申鐃緒申鐃緒申.
212 * dumpItemID, getItems鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
213 *
214 * Revision 1.67 2005/02/19 02:06:11 tani
215 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
216 *
217 * Revision 1.66 2005/02/16 10:03:13 youi
218 * publication_year/month/mday鐃緒申鐃緒申鐃緒申.
219 *
220 * Revision 1.65 2005/02/16 07:37:17 youi
221 * insertItem, updateItem, getItems: publication_date鐃緒申鐃緒申鐃緒申.
222 *
223 * Revision 1.64 2005/02/15 02:35:47 youi
224 * SQLINTEGER鐃緒申鐃緒申SQLLEN鐃緒申鐃緒申鐃緒申鐃緒申.
225 *
226 * Revision 1.63 2005/02/10 02:33:16 aga
227 * 鐃緒申zipCreate鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
228 *
229 * Revision 1.62 2005/02/09 11:11:52 youi
230 * deleteItem鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
231 *
232 * Revision 1.61 2005/02/09 07:23:50 aga
233 * 鐃緒申URL to My Personal Archive 鐃緒申DB鐃緒申AL鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
234 *
235 * Revision 1.60 2005/02/09 02:14:15 aga
236 * 鐃緒申initializeDB()鐃緒申dbtype鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(SQLite鐃緒申).
237 *
238 * Revision 1.59 2005/02/08 07:15:02 youi
239 * pubmed鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申:
240 *
241 * Revision 1.58 2005/02/08 06:40:51 youi
242 * pubmedComplete:鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申pubmed_t鐃緒申鐃緒申鐃緒申鐃緒申.
243 *
244 * Revision 1.57 2005/02/03 12:04:58 youi
245 * getOwnPublicItemID鐃緒申鐃緒申鐃緒申.
246 * binder_item_link鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
247 *
248 * Revision 1.56 2005/01/29 09:49:22 youi
249 * syslog_printf: 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
250 * getCertifyPermission: 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申sql鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
251 * SQLINTEGER->SQLLEN鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
252 * getItemPermission: 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
253 *
254 * Revision 1.55 2005/01/28 07:01:38 youi
255 * getItemIDByIndexID: 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
256 * SQLAllocHandle鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
257 *
258 * Revision 1.54 2005/01/28 00:36:58 aga
259 * 鐃緒申freeString鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
260 *
261 * Revision 1.53 2005/01/27 08:30:35 youi
262 * getIndexIDByItemID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
263 *
264 * Revision 1.52 2005/01/25 06:46:50 aga
265 * 鐃緒申Binders鐃緒申鐃緒申鐃緒申index鐃緒申deleteIndex鐃緒申鐃緒申.
266 * 鐃緒申getItems鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
267 *
268 * Revision 1.51 2005/01/24 10:50:29 youi
269 * freeItemType,getItemTypes鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
270 *
271 * Revision 1.50 2005/01/24 01:54:38 youi
272 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
273 * dumpItemID, getItemIDByBinderID, getItemIDByIndexID
274 * 鐃緒申鐃緒申鐃緒申鐃緒申
275 * getPrivateItemID, getUncertifiedLink
276 *
277 * Revision 1.49 2005/01/22 09:30:58 youi
278 * setLastErrorString鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
279 *
280 * Revision 1.48 2005/01/22 04:18:22 aga
281 * 鐃緒申loginUser, insertAccount鐃緒申鐃緒申鐃緒申md5()鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
282 *
283 * Revision 1.47 2005/01/22 02:41:14 aga
284 * 鐃緒申amazon鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
285 *
286 * Revision 1.46 2005/01/21 01:36:11 youi
287 * pubmed鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
288 *
289 * Revision 1.45 2005/01/19 10:07:53 aga
290 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
291 *
292 * Revision 1.44 2005/01/19 06:01:59 youi
293 * 鐃緒申鐃緒申鐃緒申鐃緒申
294 * getConfigValue
295 * setConfigValue
296 * getChangeLogs
297 * insertChangeLog
298 * getItemIDByBinderID
299 * registerBinderItem
300 * unregisterBinderItem
301 * getIndexPermission
302 * freeString
303 * freeChangeLog
304 * 鐃緒申鐃緒申鐃緒申criteria_t鐃緒申鐃緒申鐃緒申
305 * getItemIDByIndexID
306 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
307 * getCertifyState
308 * setCertifyState
309 * getCertifyPermission
310 * sessionID2UID,querySimple,queryGetUnsignedInt鐃緒申鐃緒申鐃緒申
311 * insertItem鐃緒申鐃緒申鐃緒申鐃緒申PrivateIndex鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
312 * getItems: getItemPermission鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
313 *
314 * Revision 1.43 2005/01/19 01:42:15 aga
315 * 鐃緒申x_xoonips_index鐃緒申gid,uid鐃緒申0鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
316 *
317 * Revision 1.42 2005/01/19 00:51:29 aga
318 * 鐃緒申insertIndex鐃緒申x_xoonips_index.index_id鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
319 *
320 * Revision 1.41 2005/01/19 00:06:51 aga
321 * 鐃緒申updateIndex鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
322 * 鐃緒申createSession鐃緒申鐃緒申uid鐃緒申Platform鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申activate鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
323 *
324 * Revision 1.40 2005/01/17 00:15:05 aga
325 * 鐃緒申deleteIndex, updateIndex鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
326 *
327 * Revision 1.39 2005/01/15 05:38:10 youi
328 * insertAccount: 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
329 * updateAccount: 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
330 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
331 * insertItem, getItem, getItems, dumpItemID, updateItem, deleteItem鐃緒申鐃緒申.
332 * freeGID, freeUID: 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
333 *
334 * Revision 1.38 2005/01/15 00:39:16 aga
335 * 鐃緒申x_xoonips_item_basic鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
336 *
337 * Revision 1.37 2005/01/14 10:36:59 aga
338 * 鐃緒申index鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
339 * 鐃緒申insertAccount鐃緒申private index鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
340 * 鐃緒申insertGroup鐃緒申group index 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
341 *
342 * Revision 1.36 2005/01/13 04:19:22 aga
343 * 鐃緒申VP鐃緒申XNP鐃緒申鐃緒申鐃緒申.
344 *
345 * Revision 1.35 2005/01/06 07:20:17 youi
346 * WIN32鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
347 * MySQL API鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
348 * deleteAccount: 鐃緒申鐃緒申鐃緒申鐃緒申Platform鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
349 * insertAccount: 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申Platform鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
350 * deleteMember: 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申Platform鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
351 * deleteMemberNoLimit鐃緒申鐃緒申鐃緒申.
352 *
353 * Revision 1.34 2004/12/28 04:38:14 aga
354 * 鐃緒申logoutUser()鐃緒申鐃緒申鐃緒申.
355 *
356 * Revision 1.33 2004/12/27 05:56:23 youi
357 * odbcDiagString: STMT鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
358 * syslog鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
359 *
360 * Revision 1.32 2004/12/25 09:46:47 youi
361 * MySQL+MyODBC鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
362 *
363 * Revision 1.31 2004/12/21 11:42:59 youi
364 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
365 *
366 * Revision 1.30 2004/12/18 10:24:54 youi
367 * IMPORT_MYSQLDLL鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申MYSQL鐃緒申DLL鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
368 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
369 *
370 * Revision 1.29 2004/12/18 01:12:29 youi
371 * freeResult鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申free<鐃緒申鐃緒申鐃緒申鐃緒申>鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
372 *
373 * Revision 1.28 2004/12/14 12:02:08 youi
374 * __WIN__鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申windows鐃緒申dll鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
375 * USE_SYSLOG鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申syslogd鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
376 * getAccounts: uidsLen鐃緒申0鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
377 *
378 * Revision 1.27 2004/12/06 11:34:47 aga
379 * 鐃緒申uninitializeDB()鐃緒申鐃緒申鐃緒申.
380 *
381 * Revision 1.26 2004/12/06 10:17:36 youi
382 * mysql_use_result鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
383 * while( row = mysql_fetch_row(result) );鐃緒申鐃緒申鐃緒申鐃緒申
384 *
385 * Revision 1.25 2004/12/06 07:24:33 youi
386 * insertAccount, insertGroup:
387 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
388 *
389 * Revision 1.24 2004/12/06 01:45:50 aga
390 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
391 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
392 *
393 * Revision 1.23 2004/12/04 09:21:10 aga
394 * 鐃緒申xnp_config 鐃緒申 xoonips_config.
395 *
396 * Revision 1.22 2004/12/03 07:17:21 youi
397 * isModerator鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
398 *
399 * Revision 1.21 2004/12/01 10:28:58 youi
400 * DB鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
401 * institute -> division
402 * organizaion -> company_name
403 *
404 * Revis1.20 2004/12/01 04:37:04 youi
405 * freeResult: unsigned int* 鐃緒申 int* 鐃緒申鐃緒申鐃緒申.
406 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
407 *
408 * Revision 1.19 2004/11/30 06:40:11 youi
409 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(gidExists, uidExists)
410 * getGroupCount鐃緒申鐃緒申鐃緒申.
411 * getGroupsByUid鐃緒申鐃緒申鐃緒申.
412 * isGroupAdmin鐃緒申鐃緒申鐃緒申.
413 * dumpGroupAdmins鐃緒申鐃緒申鐃緒申.
414 * deleteMember鐃緒申鐃緒申鐃緒申.
415 * insertMember鐃緒申鐃緒申鐃緒申.
416 * getMembers鐃緒申鐃緒申鐃緒申.
417 * isModerator鐃緒申鐃緒申鐃緒申.
418 *
419 * Revision 1.18 2004/11/30 05:46:32 aga
420 * 鐃緒申session鐃緒申鐃緒申remoteHost鐃緒申鐃緒申鐃緒申.
421 *
422 * Revision 1.17 2004/11/27 09:35:49 youi
423 * isActivated鐃緒申鐃緒申鐃緒申.
424 * activate鐃緒申鐃緒申鐃緒申.
425 * dumpUid鐃緒申鐃緒申鐃緒申.
426 *
427 * Revision 1.16 2004/11/27 06:29:29 youi
428 * getAccountCount鐃緒申鐃緒申鐃緒申.
429 * dumpGids鐃緒申鐃緒申鐃緒申.
430 * insertGroup, deleteGroup, updateGroup鐃緒申鐃緒申鐃緒申.
431 * getGroup, getGroups鐃緒申鐃緒申鐃緒申.
432 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申RES_DB_NOT_INITIALIZED鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
433 * (鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申)
434 *
435 * Revision 1.15 2004/11/27 02:22:22 aga
436 * 鐃緒申initializeDB鐃緒申鐃緒申addSlashes()鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
437 *
438 * Revision 1.14 2004/11/27 01:07:31 youi
439 * criteria2str: LIMIT鐃緒申ORDER BY鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
440 *
441 * Revision 1.13 2004/11/27 00:35:39 youi
442 * getAccounts鐃緒申鐃緒申鐃緒申.
443 * getAccount鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申getAccounts鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
444 * criteria2str鐃緒申鐃緒申鐃緒申.
445 *
446 * Revision 1.12 2004/11/26 09:45:28 youi
447 * getAccount鐃緒申鐃緒申鐃緒申.
448 *
449 * Revision 1.11 2004/11/26 08:16:26 aga
450 * 鐃緒申getSession, loginUser, createSession, freeResult(const session_t*) 鐃緒申鐃緒申.
451 *
452 * Revision 1.10 2004/11/26 07:57:42 youi
453 * updateAccount, deleteAccount鐃緒申鐃緒申鐃緒申.
454 * mysql_query鐃緒申鐃緒申鐃緒申鐃緒申stderr鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
455 *
456 * Revision 1.9 2004/11/26 07:38:02 aga
457 * 鐃緒申FAILUE -> FAILURE.
458 *
459 * Revision 1.8 2004/11/26 06:36:55 aga
460 * 鐃緒申createSession, getSession 鐃緒申鐃緒申鐃緒申.
461 *
462 * Revision 1.7 2004/11/26 04:51:47 youi
463 * dbprefix鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
464 * insertAccount鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
465 * isValidSessionID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
466 *
467 * Revision 1.6 2004/11/26 04:35:55 aga
468 * 鐃緒申loginUser(), logoutUser()鐃緒申鐃緒申鐃緒申.
469 *
470 * Revision 1.5 2004/11/26 01:08:25 aga
471 * 鐃緒申addSlashes()鐃緒申鐃緒申.
472 *
473 * Revision 1.4 2004/11/25 12:14:29 youi
474 * getUid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
475 *
476 * Revision 1.3 2004/11/25 11:13:59 youi
477 * getLastErrorString/setLastErrorString鐃緒申鐃緒申鐃緒申.
478 *
479 * Revision 1.2 2004/11/25 08:55:19 youi
480 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
481 * freeResult鐃緒申鐃緒申鐃緒申.
482 *
483 * Revision 1.1 2004/11/25 05:14:58 youi
484 * initial version
485 *
486 *
487 */
488 #ifdef HAVE_CONFIG_H
489 # include <config.h>
490 #endif
491
492 #ifdef WIN32
493 #include <windows.h>
494 #endif
495
496 #ifdef USE_SYSLOG
497 #include <syslog.h>
498 #endif
499
500 #include <stdio.h>
501 #include <stdlib.h>
502 #include <string.h>
503 #include <string>
504 #include <assert.h>
505 #include <time.h>
506 #include <sql.h>
507 #include <sqlext.h>
508 #include <libxml/xmlreader.h>
509 #include <ctype.h>
510
511 using namespace std;
512
513 #include "common.h"
514 #include "account.h"
515 #include "group.h"
516 #include "session.h"
517 #include "item.h"
518 #include "itemtype.h"
519 #include "criteria.h"
520 #include "commonal.h"
521 #include "item.h"
522 #include "index.h"
523 #include "changelog.h"
524 #include "pubmed.h"
525 #include "amazonbook.h"
526
527 static string dbprefix; //!< XOOPS鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申PREFIX
528 static dbtype_t dbtype; //!< MySQL/SQLite
529 static bool useSyslogFlag = false;
530
531 static SQLHANDLE henv = NULL;
532 static SQLHANDLE hdbc = NULL;
533
534
535 static void processEsummary(xmlTextReaderPtr reader, string &title, string &title_abbr);
536 static bool processEsearch(xmlTextReaderPtr reader, pubmed_t* p, int* DocID );
537 static void processEfetch(xmlTextReaderPtr reader, pubmed_t* p);
538 static int streamPubmedFile(const char *filename, pubmed_t* p);
539 static result_t insertIndexInternal( sessionid_t sid, index_t *index, indexid_t *xid );
540 static string odbcDiagString( SQLSMALLINT HandleType, SQLHANDLE hstmt, SQLRETURN sqlcode );
541 static result_t deleteMemberNoLimit( sessionid_t sid, groupid_t gid, userid_t uid );
542 static result_t getXoopsModuleConfigValue( const char *module, const char *key, char **value );
543 static void setLastErrorString( const char* str );
544 static result_t checkTitleConflict( sessionid_t sid, indexid_t parentIndexID, const char *title, bool *conflict );
545 static result_t _insertItem( sessionid_t sid, const item_t* item, itemid_t* itemid, bool direct );
546 static result_t getEvents(sessionid_t sid, event_t** events, int* eventsLen, string condition );
547 static result_t insertMetadataEvent( metadataevent_t me, itemid_t iid );
548 static result_t insertMetadataEventAuto( itemid_t iid, bool isCreate = false );
549
550 static void syslog_printf( char* format, ... )
551 {
552 #ifdef USE_SYSLOG
553 if ( useSyslogFlag ){
554 va_list ap;
555 va_start(ap, format);
556 openlog( "commonal", LOG_ODELAY, LOG_USER );
557 vsyslog( LOG_DEBUG, format, ap );
558 }
559 #endif
560 }
561
562 void useSyslog( bool f )
563 {
564 useSyslogFlag = f;
565 }
566
567 /** ',' . implode( ',', pi ) 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申comma鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
568 * @param pi int鐃緒申鐃緒申
569 * @param len 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
570 */
571 static string getCsvStr( const itemid_t *pi, int len ){
572 char *buf = new char[(sizeof(int)*3+1)*len+1];
573 buf[0] = '\0';
574 char *p = buf;
575 for ( int i = 0; i < len; i++ ){
576 int len = sprintf( p, ",%u", pi[i] );
577 p += len;
578 }
579 string iids_str(buf);
580 delete[] buf;
581 return iids_str;
582 }
583
584 string urlencode( string str ){
585 int len = str.length();
586 char *buf = new char[len*3+1];
587 char *p = buf;
588 for ( int i = 0; i < len; i++ ){
589 char c = str[i];
590 if ( isalnum(c) || c =='$' || c == '*' || c == '_' || c =='.' )
591 *p++ = c;
592 else {
593 sprintf( p, "%%%02X", c & 0x00ff );
594 p += 3;
595 }
596 }
597 *p = '\0';
598 string encoded(buf);
599 delete[] buf;
600 return encoded;
601 }
602
603 /**
604 *
605 * public_item_target_user鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申'all'鐃緒申鐃緒申true鐃緒申鐃緒申鐃緒申鐃緒申
606 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申'all'鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申false鐃緒申鐃緒申鐃緒申鐃緒申
607 *
608 */
609 static bool public_item_target_user_all( )
610 {
611 char* value = 0;
612 bool public_item_target_user_all = false;
613 if( getConfigValue( XNP_CONFIG_PUBLIC_ITEM_TARGET_USER_KEY, &value ) == RES_OK ){
614 public_item_target_user_all = ( strcmp( value, XNP_CONFIG_PUBLIC_ITEM_TARGET_USER_ALL ) == 0 );
615 freeString( value );
616 }
617 return public_item_target_user_all;
618 }
619
620 static result_t countResultRows( const char* sql, SQLLEN* count )
621 {
622 result_t ret = RES_ERROR;
623 SQLRETURN sqlcode;
624 SQLHANDLE hstmt = NULL;
625 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
626 if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql, strlen( sql ) ) ) == SQL_SUCCESS ){
627 *count = 0;
628 while( ( sqlcode = SQLFetch( hstmt ) ) == SQL_SUCCESS ) ( *count )++;
629 ret = RES_OK;
630 }else{
631 string s( "SQLExecDirect in countResultRows " );
632 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
633 s += "sql=";
634 s += string( sql );
635 setLastErrorString( s.c_str( ) );
636 ret = RES_DB_QUERY_ERROR;
637 }
638 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
639 }
640 return ret;
641 }
642
643
644 /**
645 *
646 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
647 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
648 *
649 */
650 static certify_t getInitialCertifyStateFromConfig( )
651 {
652 char* certify_item_val;
653 certify_t ret = index::NOT_CERTIFIED;
654
655 if( getConfigValue( XNP_CONFIG_CERTIFY_ITEM_KEY, &certify_item_val ) == RES_OK ){
656 if( strcmp( certify_item_val, XNP_CONFIG_CERTIFY_ITEM_AUTO ) == 0 ){
657 //certify automatic
658 ret = index::CERTIFIED;
659 }else if( strcmp( certify_item_val, XNP_CONFIG_CERTIFY_ITEM_ON ) == 0 ){
660 //certify by moderator or group admin
661 ret = index::CERTIFY_REQUIRED;
662 }
663 syslog_printf( "\ngetInitialCertifyStateFromConfig certify_item_val=%s", certify_item_val );
664 freeString( certify_item_val );
665 }
666 return ret;
667 }
668
669 /**
670 *
671 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申Platform鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申Activate鐃緒申
672 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
673 *
674 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
675 * @return true Activate鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
676 * @return false Activate鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
677 *
678 */
679 static bool isActivatedBySession( sessionid_t sid )
680 {
681 const session_t* session;
682 if( getSession( sid, &session ) == RES_OK ){
683 userid_t sess_uid = session -> getUID( );
684 freeSession( session );
685 return isActivated( sid, sess_uid );
686 }
687 return false;
688 }
689
690 /**
691 *
692 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
693 *
694 *
695 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
696 * @return true 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
697 * @return false 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
698 *
699 */
700 static bool isModeratorBySession( sessionid_t sid )
701 {
702 const session_t* session;
703 if( getSession( sid, &session ) == RES_OK ){
704 userid_t sess_uid = session -> getUID( );
705 freeSession( session );
706 return isModerator( sid, sess_uid );
707 }
708 return false;
709 }
710
711
712 // SQLAllocHandle鐃緒申SQLExecDirect鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申hstmt鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
713 class sqlexec_t {
714 private:
715 SQLRETURN sqlcode;
716 SQLHANDLE hstmt;
717 public:
718 SQLRETURN getSqlcode(){ return sqlcode; }
719 SQLHANDLE getHstmt(){ return hstmt; }
720 //SQLRETURN SQLFetch(){ return sqlcode = SQLFetch(hstmt); } // 鐃緒申鐃緒申鐃緒申wrapper鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
721
722 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申: SQLAllocHandle, SQLExecDirect鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申getSqlcode()==SQL_SUCCESS
723 * @param functionName 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
724 * @param sql 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申SQL
725 * @param ret 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
726 */
727 sqlexec_t( const char *functionName, string &sql, result_t *ret ){
728 sqlcode = 0;
729 hstmt = 0;
730
731 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
732 if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
733 return;
734 }else {
735 string s( "SQLExecDirect in " );
736 s += functionName;
737 s += " ";
738 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
739 s += " sql=";
740 s += string( sql );
741 setLastErrorString( s.c_str( ) );
742 *ret = RES_DB_QUERY_ERROR;
743 return;
744 }
745 }else {
746 string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in " );
747 s += functionName;
748 s += " ";
749 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
750 setLastErrorString( s.c_str( ) );
751 *ret = RES_ERROR;
752 return;
753 }
754 }
755 ~sqlexec_t(){
756 if ( hstmt )
757 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
758 }
759 };
760
761
762 /** SQL鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
763 * @param sql sql
764 * @return result_t
765 */
766 static result_t querySimple( const char *functionName, string &sql ){
767 result_t ret = RES_ERROR;
768 SQLRETURN sqlcode;
769 SQLHANDLE hstmt = NULL;
770 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
771 if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), strlen( sql.c_str() ) ) ) == SQL_SUCCESS ){
772 ret = RES_OK;
773 }else{
774 string s( "SQLExecDirect in querySimple " );
775 s += functionName;
776 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
777 s += "sql=";
778 s += sql;
779 setLastErrorString( s.c_str( ) );
780 ret = RES_DB_QUERY_ERROR;
781 }
782 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
783 }
784 else {
785 string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in querySimple " );
786 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
787 setLastErrorString( s.c_str( ) );
788 ret = RES_ERROR;
789 }
790 return ret;
791 }
792
793 /** SQL鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申1鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(NULL鐃緒申鐃緒申0鐃緒申鐃緒申鐃緒申鐃緒申)鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
794 * @param sql sql
795 * @param u 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
796 * @return result_t
797 */
798 static result_t queryGetUnsignedInt( const char *functionName, string &sql, unsigned int *u ){
799 result_t ret = RES_ERROR;
800 SQLRETURN sqlcode;
801 SQLHANDLE hstmt = NULL;
802
803 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
804 if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), strlen( sql.c_str() ) ) ) == SQL_SUCCESS ){
805 SQLUINTEGER sInt = 0;
806 SQLLEN len = 0;
807 SQLBindCol( hstmt, 1, SQL_C_ULONG, &sInt, 0, &len );
808 if( ( sqlcode = SQLFetch( hstmt ) ) == SQL_SUCCESS ){
809 if ( len == SQL_NULL_DATA )
810 sInt = 0;
811 *u = sInt;
812 ret = RES_OK;
813 }else{
814 string s( "SQLFetch in queryGetUnsignedInt " );
815 s += functionName;
816 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
817 setLastErrorString( s.c_str( ) );
818 ret = RES_ERROR;
819 }
820 }else{
821 string s( "SQLExecDirect in queryGetUnsignedInt " );
822 s += functionName;
823 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
824 s += "sql=";
825 s += sql;
826 setLastErrorString( s.c_str( ) );
827 ret = RES_DB_QUERY_ERROR;
828 }
829 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
830 }
831 else {
832 string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in queryGetUnsignedInt " );
833 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
834 setLastErrorString( s.c_str( ) );
835 ret = RES_ERROR;
836 }
837 return ret;
838 }
839
840 /**
841 *
842 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
843 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申NULL鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
844 * ( dst鐃緒申鐃緒申鐃緒申鐃緒申 >= len + 1 )鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
845 *
846 */
847 static char* strncpy2( char* dst, const char* src, int len )
848 {
849 strncpy( dst, src, len );
850 dst[ len ] = '\0';
851 syslog_printf( "\nstrncpy2 '%s'\n", dst );
852 return dst;
853 }
854
855 /**
856 *
857 * SQL鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
858 *
859 * @param hstmt SQL鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
860 * @param sqlcode SQLExecDirect,SQLExecute鐃緒申鐃緒申鐃緒申鐃緒申
861 * @return 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
862 */
863 static string odbcDiagString( SQLSMALLINT HandleType, SQLHANDLE hstmt, SQLRETURN sqlcode )
864 {
865 string s;
866 if( sqlcode == SQL_ERROR || sqlcode == SQL_SUCCESS_WITH_INFO ){
867 SQLCHAR SQLState[6];
868 SQLINTEGER NativeError;
869 SQLCHAR MessageText[ 1024 ];
870 SQLSMALLINT TextLength;
871 SQLGetDiagRec( HandleType, hstmt, 1, SQLState, &NativeError, MessageText, 1024, &TextLength );
872
873 s += string( (char*)MessageText );
874 s += " SQLSTATE=";
875 s += string( (char*)SQLState );
876
877 }
878 s += " sqlcode=";
879 s += intToString( sqlcode );
880 return s;
881 }
882
883 /**
884 *
885 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
886 *
887 */
888 string getResultCol( SQLHANDLE hstmt, int col, SQLSMALLINT targetType = SQL_C_CHAR )
889 {
890 string s;
891 SQLRETURN sqlcode;
892 SQLCHAR BinaryPtr[5000];
893 SQLLEN BinaryLenOrInd;
894 SQLINTEGER NumBytes;
895
896 syslog_printf( "getResultCol" );
897 while ( ( sqlcode = SQLGetData(hstmt, col, targetType, BinaryPtr, sizeof(BinaryPtr),
898 &BinaryLenOrInd)) != SQL_NO_DATA) {
899 syslog_printf( "SQLGetData BinaryLenOrInd=%d", BinaryLenOrInd );
900 NumBytes = (BinaryLenOrInd > 5000) || (BinaryLenOrInd == SQL_NO_TOTAL) ? 5000 : BinaryLenOrInd;
901 if( NumBytes <= 0 ) break;
902 else if( NumBytes > 0 ){
903 s += string( (char*)BinaryPtr, NumBytes );
904 }
905 }
906 syslog_printf( "getResultCol returns %s", s.c_str() );
907 return s;
908 }
909
910
911 /**
912 *
913 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申\鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
914 *
915 * @param str addslashes鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申NULL鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
916 * @return 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
917 */
918 string addSlashes( const char *str )
919 {
920 if ( hdbc == NULL ){
921 string s;
922 return s;
923 }else{
924 string s( str );
925 return s;
926 }
927
928 int len = strlen(str) * 3;
929 char* dst = new char[ len ];
930 const char* from = str;
931 char* to = dst;
932 while( *from != '\0' ){
933 switch( *from ){
934 case '\'':
935 case '\"':
936 case ';':
937 *to = '\\'; to++;
938 break;
939 }
940 *to = *from; to++;
941 from++;
942 }
943 *to = '\0';
944 string s( dst );
945 delete[] dst;
946 return s;
947 }
948
949 /** Xoops Module 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
950 * @param module 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申dirname
951 * @param key 鐃緒申鐃緒申鐃緒申key
952 * @param value 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
953 * @return
954 */
955 static result_t getXoopsModuleConfigValue( const char *module, const char *key, char **value ){
956 SQLRETURN sqlcode;
957 SQLHANDLE hstmt = NULL;
958 result_t result = RES_ERROR;
959
960 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
961 string sql = "SELECT conf_value "
962 " from " + dbprefix + "_config as tc, " + dbprefix + "_modules as tm "
963 " where tm.mid=tc.conf_modid and tm.dirname = ? and tc.conf_name = ? ";
964 sqlcode = SQLPrepare(hstmt, (SQLCHAR*)sql.c_str(), SQL_NTS);
965 SQLLEN cbModule = SQL_NTS, cbKey = SQL_NTS;
966 SQLBindParameter(hstmt, 1, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_VARCHAR, strlen(module), 0, (SQLCHAR *)module, 0, &cbModule );
967 SQLBindParameter(hstmt, 2, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_VARCHAR, strlen(key), 0, (SQLCHAR *)key, 0, &cbKey );
968 sqlcode = SQLExecute( hstmt );
969 if( sqlcode == SQL_SUCCESS || sqlcode == SQL_SUCCESS_WITH_INFO ){
970 if ( ( sqlcode = SQLFetch( hstmt ) ) == SQL_SUCCESS ){
971 string s = getResultCol( hstmt, 1 );
972 *value = new char[s.length()+1];
973 strcpy( *value, s.c_str() );
974 result = RES_OK;
975 }
976 else if ( sqlcode == SQL_NO_DATA ){
977 *value = 0;
978 result = RES_OK;
979 }
980 else {
981 string s( "SQLFetch in getXoopsModuleConfig " );
982 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
983 s += "sql=";
984 s += sql;
985 setLastErrorString( s.c_str( ) );
986 result = RES_ERROR;
987 }
988 }else{
989 string s( "SQLExecDirect in getXoopsModuleConfig " );
990 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
991 s += "sql=";
992 s += sql;
993 setLastErrorString( s.c_str( ) );
994 result = RES_DB_QUERY_ERROR;
995 }
996 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
997 }
998 else {
999 string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in getXoopsModuleConfig " );
1000 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
1001 setLastErrorString( s.c_str( ) );
1002 result = RES_ERROR;
1003 }
1004 return result;
1005 }
1006
1007 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申XooNiPs鐃緒申Public鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1008 */
1009 static bool isGuestEnabled(){
1010 char *value = 0;
1011 result_t result = getConfigValue( XNP_CONFIG_PUBLIC_ITEM_TARGET_USER_KEY, &value );
1012 if ( result != RES_OK )
1013 return false;
1014 if ( value == 0 )
1015 return false;
1016 bool enabled = ( strcmp( value, XNP_CONFIG_PUBLIC_ITEM_TARGET_USER_ALL ) == 0 );
1017 freeString( value );
1018 return enabled;
1019 }
1020
1021 /** sid鐃緒申鐃緒申uid鐃緒申鐃緒申鐃緒申鐃緒申
1022 * @param sid session id
1023 * @param uid uid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1024 * @return RES_OK
1025 * sid鐃緒申鐃緒申鐃緒申鐃緒申sessionid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申*uid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申uid鐃緒申鐃緒申鐃緒申鐃緒申
1026 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申XooNiPs鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申 鐃緒申鐃緒申sid鐃緒申session::SID_GUEST(=0)鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申*uid鐃緒申鐃緒申account::UID_GUEST(=0)鐃緒申鐃緒申鐃緒申鐃緒申
1027 * @return 鐃緒申鐃緒申鐃緒申 鐃緒申鐃緒申鐃緒申
1028 */
1029 static result_t sessionID2UID( sessionid_t sid, userid_t *uid ){
1030 if( hdbc == NULL ) return RES_DB_NOT_INITIALIZED;
1031
1032 if ( sid == session::SID_GUEST ){
1033 if ( isGuestEnabled() ){
1034 *uid = account::UID_GUEST;
1035 return RES_OK;
1036 }
1037 return RES_NO_SUCH_SESSION;
1038 }
1039 else {
1040 string sql = "SELECT uid FROM " + dbprefix + "_xoonips_session WHERE sid=" + unsignedIntToString(sid);
1041 syslog_printf( "sql=%s", sql.c_str() );
1042 return queryGetUnsignedInt( "sessionID2UID", sql, uid );
1043 }
1044 }
1045
1046
1047
1048 /**
1049 *
1050 * gid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
1051 * DB鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申false鐃緒申鐃緒申鐃緒申鐃緒申
1052 *
1053 * @param gid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申GID
1054 * @return true 鐃緒申鐃緒申鐃緒申鐃緒申
1055 * @return false 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1056 *
1057 */
1058 static bool gidExists( groupid_t gid )
1059 {
1060 string sql;
1061 SQLRETURN sqlcode;
1062 SQLHANDLE hstmt = NULL;
1063
1064 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) != SQL_SUCCESS ) {
1065 string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in gidExists" );
1066 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
1067 setLastErrorString( s.c_str( ) );
1068 return false;
1069 }
1070
1071 sql = "SELECT * FROM " + dbprefix + "_xoonips_groups ";
1072 sql += "WHERE gid=" + string( unsignedIntToString( gid ) );
1073 if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) != SQL_SUCCESS ){
1074 setLastErrorString( "SQLExecDirect in gidExists" );
1075 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
1076 return false;
1077 }
1078
1079 if( ( sqlcode = SQLFetch( hstmt ) ) != SQL_SUCCESS ){
1080 setLastErrorString( "SQLFetch in gidExists" );
1081 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
1082 return false;
1083 }
1084
1085 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
1086 return true;
1087 }
1088
1089
1090 /**
1091 *
1092 * Platform鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申uid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
1093 * DB鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申false鐃緒申鐃緒申鐃緒申鐃緒申
1094 *
1095 * @param uid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申UID
1096 * @return true 鐃緒申鐃緒申鐃緒申鐃緒申
1097 * @return false 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1098 *
1099 */
1100 static bool uidExists( userid_t uid )
1101 {
1102 bool ret = false;
1103 string sql;
1104 SQLHANDLE hstmt = NULL;
1105 SQLRETURN sqlcode;
1106
1107 sql = "SELECT * FROM " + dbprefix + "_xoonips_users ";
1108 sql += "WHERE uid=" + string( unsignedIntToString( uid ) );
1109 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
1110 if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
1111 if( ( sqlcode = SQLFetch( hstmt ) ) == SQL_SUCCESS ){
1112 ret = true;
1113 }else{
1114 string s( "SQLFetch in uidExists ");
1115 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
1116 s += string( ", sql=" ) + string( sql );
1117 setLastErrorString( s.c_str( ) );
1118 ret = false;
1119 }
1120 }else{
1121 string s( "SQLExecDirect in uidExists ");
1122 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
1123 s += string( ", sql=" ) + string( sql );
1124 setLastErrorString( s.c_str( ) );
1125 ret = false;
1126 }
1127 }else{
1128 string s( "SQLAllocHandle in uidExists ");
1129 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
1130 setLastErrorString( s.c_str( ) );
1131 ret = false;
1132 }
1133 return ret;
1134 }
1135
1136
1137 /**
1138 *
1139 * criteria 鐃緒申 SQL鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1140 *
1141 *
1142 *
1143 */
1144 string criteria2str( criteria* cri )
1145 {
1146 string sql;
1147
1148 const orderby* odrby = cri -> headOrderBy( );
1149 if( odrby != 0 ){
1150 sql += " ORDER BY " + string( odrby -> getColumn( ) );
1151 sql += ( odrby -> getOrder( ) == orderby::DESC ) ? " DESC" : " ";
1152 while( ( odrby = cri -> nextOrderBy( ) ) != 0 ){
1153 sql += ", " + string( odrby -> getColumn( ) );
1154 sql += ( odrby -> getOrder( ) == orderby::DESC ) ? " DESC" : " ";
1155 }
1156 }
1157
1158 if( cri -> getLimitStart( ) != 0 || cri -> getLimitRows( ) != 0 ){
1159 sql += " LIMIT " + string( intToString( cri -> getLimitStart( ) ) )
1160 + ", " + string( intToString( cri -> getLimitRows( ) ) );
1161 }
1162 return sql;
1163 }
1164
1165
1166 /**
1167 *
1168 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1169 *
1170 * @param dsn ODBC鐃緒申DSN
1171 * @param user 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1172 * @param password 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1173 * @param reserve 鐃緒申鐃緒申鐃緒申(NULL)
1174 * @param prefix XOOPS鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申PREFIX
1175 * @param type DBTYPE_MYSQL or DBTYPE_SQLITE
1176 * @return RES_OK
1177 * @return RES_DB_INITIALIZE_ERROR
1178 * @return RES_DB_CONNECT_ERROR
1179 * @see result_t
1180 */
1181 result_t initializeDB( const char* dsn, const char* user, const char* password, const char* reserve, const char* prefix, dbtype_t type )
1182 {
1183 SQLRETURN sqlcode;
1184
1185 // 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1186 if ( hdbc != NULL ){
1187 SQLDisconnect( hdbc );
1188 hdbc = NULL;
1189 }
1190
1191 dbprefix = prefix;
1192 dbtype = type;
1193
1194 // 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1195 // if( SQLAllocEnv( &henv ) != SQL_SUCCESS ) {
1196 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_ENV, SQL_NULL_HANDLE, &henv ) ) != SQL_SUCCESS ) {
1197 string s( "SQLAllocHandle(SQL_HANDLE_ENV,...) in initializeDB" );
1198 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
1199 setLastErrorString( s.c_str( ) );
1200 syslog_printf( "initializeDB %s", getLastErrorString( ) );
1201 return RES_DB_INITIALIZE_ERROR;
1202 }
1203 //ODBC Ver.3 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1204 SQLSetEnvAttr(henv, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0);
1205
1206 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_DBC, henv, &hdbc ) ) != SQL_SUCCESS ) {
1207 string s( "SQLAllocHandle(SQL_HANDLE_DBC,...) in initializeDB" );
1208 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
1209 setLastErrorString( s.c_str( ) );
1210 syslog_printf( "initializeDB %s", getLastErrorString( ) );
1211 return RES_DB_INITIALIZE_ERROR;
1212 }
1213 //鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申5鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1214 //SQLSetConnectAttr(hdbc, SQL_LOGIN_TIMEOUT, (SQLPOINTER *)5, 0);
1215
1216 if ( ( sqlcode = SQLConnect( hdbc, (SQLCHAR*)dsn, strlen( dsn ), (SQLCHAR*)user, strlen( user ), (SQLCHAR*)password, strlen( password ) ) ) != SQL_SUCCESS ){
1217 string s( "SQLConnect in initializeDB " );
1218 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
1219 setLastErrorString( s.c_str( ) );
1220 syslog_printf( "initializeDB %s", getLastErrorString( ) );
1221 return RES_DB_CONNECT_ERROR;
1222 }
1223 syslog_printf( "initializeDB succeed" );
1224 return RES_OK;
1225 }
1226
1227 /**
1228 *
1229 * 鐃緒申鐃緒申DB鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1230 *
1231 * @param 鐃緒申鐃緒申
1232 * @return RES_OK
1233 */
1234 result_t uninitializeDB()
1235 {
1236 if ( hdbc != NULL ){
1237 SQLDisconnect( hdbc );
1238 hdbc = NULL;
1239 }
1240 return RES_OK;
1241 }
1242
1243 /**
1244 *
1245 * Platform鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1246 *
1247 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1248 * @param uid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申UID
1249 * @return true 鐃緒申鐃緒申鐃緒申鐃緒申
1250 * @return false 鐃緒申鐃緒申鐃緒申
1251 *
1252 */
1253 bool isActivated( sessionid_t sid, userid_t uid )
1254 {
1255 if( hdbc == NULL ) return false;
1256 if( !isValidSessionID( sid ) ) return false;
1257
1258 bool ret = false;
1259 string sql;
1260 SQLRETURN sqlcode;
1261 SQLHANDLE hstmt = NULL;
1262
1263 sql = "SELECT * FROM " + dbprefix + "_xoonips_users ";
1264 sql += "WHERE activate=1 and uid=" + string( unsignedIntToString( uid ) );
1265 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
1266 if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
1267 if( ( sqlcode = SQLFetch( hstmt ) ) == SQL_SUCCESS ){
1268 ret = true;
1269 }else{
1270 string s( "SQLFetch in isActivated " );
1271 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
1272 s += ", sql=" + sql;
1273 setLastErrorString( s.c_str() );
1274 ret = false;
1275 }
1276 }else{
1277 string s( "SQLExecDirect in isActivated " );
1278 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
1279 s += ", sql=" + sql;
1280 setLastErrorString( s.c_str() );
1281 ret = false;
1282 }
1283 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
1284 }else{
1285 string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in isActivated" );
1286 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
1287 setLastErrorString( s.c_str( ) );
1288 ret = false;
1289 }
1290 return ret;
1291 }
1292
1293 /**
1294 *
1295 * Platform鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1296 *
1297 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1298 * @param uid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申UID
1299 * @param activate 鐃緒申鐃緒申(true) / 鐃緒申鐃緒申鐃緒申(false)鐃緒申鐃緒申鐃緒申
1300 * @return RES_OK
1301 * @return RES_ERROR
1302 * @return RES_DB_QUERY_ERROR
1303 * @return RES_NO_SUCH_USER
1304 * @return RES_NO_SUCH_SESSION
1305 * @return RES_DB_NOT_INITIALIZED;
1306 */
1307 result_t activate( sessionid_t sid, userid_t uid, bool activate )
1308 {
1309 if( hdbc == NULL ) return RES_DB_NOT_INITIALIZED;
1310 if( !isValidSessionID( sid ) ) return RES_NO_SUCH_SESSION;
1311
1312 string sql;
1313 SQLHANDLE hstmt = NULL;
1314 SQLRETURN sqlcode;
1315 result_t ret = RES_ERROR;
1316
1317 sql = "UPDATE " + dbprefix + "_xoonips_users ";
1318 sql += "SET activate=" + string( activate ? "1" : "0" );
1319 sql += " WHERE uid=" + string( unsignedIntToString( uid ) );
1320 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
1321 if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
1322 SQLLEN count = 0;
1323 if( ( sqlcode = SQLRowCount( hstmt, &count ) ) == SQL_SUCCESS && count > 0 ){
1324 ret = RES_OK;
1325 }else{
1326 string s( "SQLRowCount in activate ");
1327 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
1328 s += string( ", sql=" ) + string( sql );
1329 setLastErrorString( s.c_str( ) );
1330 ret = RES_NO_SUCH_USER;
1331 }
1332 }else{
1333 string s( "SQLExecDirect in activate " );
1334 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
1335 s += ", sql=";
1336 s += string( sql );
1337 setLastErrorString( s.c_str( ) );
1338 ret = RES_DB_QUERY_ERROR;
1339 }
1340 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
1341 }else{
1342 string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in activate" );
1343 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
1344 setLastErrorString( s.c_str( ) );
1345 ret = RES_ERROR;
1346 }
1347 return ret;
1348 }
1349
1350 /**
1351 *
1352 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1353 *
1354 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1355 * @return 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申鐃緒申鐃緒申0)
1356 *
1357 */
1358 int getAccountCount( sessionid_t sid )
1359 {
1360 if( hdbc == NULL ) return 0;
1361 if( !isValidSessionID( sid ) ) return 0;
1362
1363 int ret = 0;
1364 string sql;
1365 SQLRETURN sqlcode;
1366 SQLHANDLE hstmt = NULL;
1367
1368 //鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1369 sql = "SELECT COUNT(*) FROM " + dbprefix + "_xoonips_users ";
1370 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
1371 if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
1372 SQLUINTEGER count = 0;
1373 SQLLEN len = 0;
1374 SQLBindCol( hstmt, 1, SQL_C_ULONG, &count, 0, &len );
1375 if( ( sqlcode = SQLFetch( hstmt ) ) == SQL_SUCCESS ){
1376 ret = count;
1377 }else {
1378 string s( "SQLFetch in getAccountCount sql=" );
1379 s += string( sql );
1380 setLastErrorString( s.c_str( ) );
1381 ret = 0;
1382 }
1383 }else{
1384 setLastErrorString( "SQLExecDirect in getAccountCount" );
1385 ret = 0;
1386 }
1387 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
1388 }else{
1389 string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in getAccountCount" );
1390 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
1391 setLastErrorString( s.c_str( ) );
1392 ret = 0;
1393 }
1394 return ret;
1395 }
1396
1397 /**
1398 *
1399 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1400 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1401 *
1402 * @param
1403 * @return RES_OK
1404 * @return RES_ERROR
1405 * @return RES_DB_NOT_INITIALIZED
1406 * @return RES_NO_SUCH_SESSION
1407 * @return RES_DB_QUERY_ERROR
1408 *
1409 */
1410 result_t deleteAccount( sessionid_t sid, userid_t uid )
1411 {
1412 if( hdbc == NULL ) return RES_DB_NOT_INITIALIZED;
1413 if( !isValidSessionID( sid ) ) return RES_NO_SUCH_SESSION;
1414
1415 result_t ret1 = RES_ERROR, ret2 = RES_ERROR;
1416 criteria_t c;
1417 string sql;
1418 groupid_t* gids;
1419 int gidsLen;
1420 SQLRETURN sqlcode;
1421 SQLHANDLE hstmt = NULL;
1422
1423 /*
1424 1. delete user from default platform group
1425 2. delete user profile from xoops_users
1426 3. delete platform user from xoonips_users
1427 */
1428
1429 //1. delete user from platform groups
1430 c.clearAll();
1431 if( getGroupsByUid( sid, uid, &c, &gids, &gidsLen ) == RES_OK ){
1432 for( int i = 0; i < gidsLen; i++ )
1433 deleteMemberNoLimit( sid, gids[ i ], uid );
1434 freeGID( gids );
1435 }
1436
1437 //2. delete user profile from xoops_users
1438 sql = "DELETE FROM " + dbprefix + "_users ";
1439 sql += "WHERE uid = " + string( unsignedIntToString( uid ) );
1440 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
1441 if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
1442 SQLLEN count = 0;
1443 if( ( sqlcode = SQLRowCount( hstmt, &count ) ) == SQL_SUCCESS && count > 0 ){
1444 ret1 = RES_OK;
1445 }else{
1446 string s( "SQLRowCount in deleteAccount" );
1447 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
1448 s += string( ", sql=" ) + string( sql );
1449 setLastErrorString( s.c_str( ) );
1450 ret1 = RES_NO_SUCH_USER;
1451 }
1452 }else{
1453 string s( "SQLExecDirect in deleteAccount" );
1454 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
1455 s += ", sql=";
1456 s += string( sql );
1457 setLastErrorString( s.c_str( ) );
1458 ret1 = RES_DB_QUERY_ERROR;
1459 }
1460 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
1461 }else{
1462 string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in deleteAccount" );
1463 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
1464 setLastErrorString( s.c_str( ) );
1465 ret1 = RES_ERROR;
1466 }
1467
1468 //3. delete platform user from xoonips_users
1469 sql = "DELETE FROM " + dbprefix + "_xoonips_users ";
1470 sql += "WHERE uid = " + string( unsignedIntToString( uid ) );
1471 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
1472 if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
1473 SQLLEN count = 0;
1474 if( ( sqlcode = SQLRowCount( hstmt, &count ) ) == SQL_SUCCESS && count > 0 ){
1475 ret2 = RES_OK;
1476 }else{
1477 string s( "SQLRowCount in deleteAccount" );
1478 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
1479 s += string( ", sql=" ) + string( sql );
1480 setLastErrorString( s.c_str( ) );
1481 ret2 = RES_NO_SUCH_USER;
1482 }
1483 }else{
1484 string s( "SQLExecDirect in deleteAccount" );
1485 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
1486 s += ", sql=";
1487 s += string( sql );
1488 setLastErrorString( s.c_str( ) );
1489 ret2 = RES_DB_QUERY_ERROR;
1490 }
1491 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
1492 }else{
1493 string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in deleteAccount" );
1494 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
1495 setLastErrorString( s.c_str( ) );
1496 ret2 = RES_ERROR;
1497 }
1498
1499 //鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1500 return ret1 != RES_OK ? ret1 : ret2;
1501 }
1502
1503 /**
1504 *
1505 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1506 *
1507 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1508 * @param uid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申UID
1509 * @param acc 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(account_t)鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1510 * @return RES_OK
1511 * @return RES_DB_NOT_INITIALIZED
1512 * @return RES_NO_SUCH_USER
1513 * @return RES_NO_SUCH_SESSION
1514 * @return RES_DB_QUERY_ERROR
1515 * @see freeAccount
1516 *
1517 */
1518 result_t getAccount( sessionid_t sid, userid_t uid, const account_t** acc )
1519 {
1520 int len = 0;
1521 static criteria c;
1522 result_t res = getAccounts( sid, &uid, 1, &c, acc, &len );
1523 if( res == RES_OK && len == 0 ) return RES_NO_SUCH_USER;
1524 return res;
1525 }
1526
1527 /**
1528 *
1529 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1530 *
1531 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1532 * @param uids 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申UID鐃緒申鐃緒申鐃緒申
1533 * @param uidsLen uids鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1534 * @param cri 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1535 * @param accounts 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1536 * @param accountsLen 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申*accounts鐃緒申鐃緒申鐃緒申鐃緒申)
1537 * @return RES_OK
1538 * @return RES_DB_NOT_INITIALIZED
1539 * @return RES_NO_SUCH_SESSION
1540 * @return RES_DB_QUERY_ERROR
1541 * @see freeAccount
1542 *
1543 */
1544 result_t getAccounts( sessionid_t sid, const userid_t* uids, int uidsLen, criteria_t* cri, const account_t** accounts, int* accountsLen )
1545 {
1546 if( hdbc == NULL ) return RES_DB_NOT_INITIALIZED;
1547 if( !isValidSessionID( sid ) ) return RES_NO_SUCH_SESSION;
1548 if( uidsLen <= 0 ){
1549 *accounts = new account_t[ 0 ];
1550 *accountsLen = 0;
1551 syslog_printf( "getAccounts succeed len=0" );
1552 return RES_OK;
1553 }
1554
1555 syslog_printf( "begin of getAccounts" );
1556 result_t ret = RES_ERROR;
1557 SQLRETURN sqlcode;
1558 SQLHANDLE hstmt = NULL;
1559 string sql;
1560 account_t* dst = new account_t[ uidsLen ];
1561
1562 sql += "SELECT u1.uid, u1.name, u1.uname, u1.email, u1.url, u1.user_avatar, u1.user_regdate, u1.user_icq, u1.user_from, u1.user_sig, u1.user_viewemail, u1.actkey, u1.user_aim, u1.user_yim, u1.user_msnm, u1.pass, u1.posts, u1.attachsig, u1.rank, u1.level, u1.theme, u1.timezone_offset, u1.last_login, u1.umode, u1.uorder, u1.notify_method, u1.notify_mode, u1.user_occ, u1.bio, u1.user_intrest, u1.user_mailok, u2.activate, u2.address, u2.division, u2.tel, u2.company_name, u2.country, u2.zipcode, u2.fax, u2.notice_mail, u2.notice_mail_since, u2.private_index_id, u2.private_item_number_limit, u2.private_index_number_limit, u2.private_item_storage_limit ";
1563 sql += "FROM " + dbprefix + "_users AS u1, " + dbprefix + "_xoonips_users AS u2 ";
1564 sql += "WHERE u1.uid = u2.uid ";
1565 if( uidsLen > 0 ){
1566 syslog_printf( "set uid[%d] value=%d to ...", 0, uids[0] );
1567 sql += "AND ( u1.uid=" + string( unsignedIntToString( uids[ 0 ] ) );
1568 for( int i = 1; i < uidsLen; i++ ){
1569 syslog_printf( "set uid[%d] value=%d to ...", i, uids[i] );
1570 sql += " OR u1.uid=" + string( unsignedIntToString( uids[ i ] ) );
1571 }
1572 sql += " ) ";
1573 }
1574 sql += criteria2str( cri );
1575 syslog_printf( "sql=%s", sql.c_str() );
1576
1577 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
1578 syslog_printf( "SQLAllocHandle" );
1579 if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
1580 syslog_printf( "SQLExecDirect" );
1581 SQLLEN cbUid = 0, cbStorageLimit = 0;
1582 userid_t uid = 0;
1583 SQLDOUBLE storage_limit = 0;
1584 SQLBindCol( hstmt, 1, SQL_C_ULONG, &uid, 0, &cbUid );
1585 SQLBindCol( hstmt, 45, SQL_C_DOUBLE, &storage_limit, 0, &cbStorageLimit );
1586 syslog_printf( "SQLBindCol" );
1587 *accountsLen=0;
1588 for( int i = 0; ( sqlcode = SQLFetch( hstmt ) ) == SQL_SUCCESS && i < uidsLen ; i++ ){
1589 syslog_printf( "SQLFetch" );
1590 dst[ i ].setUID( uid );
1591 dst[ i ].setName( getResultCol( hstmt, 2 ).c_str() );
1592 dst[ i ].setUname( getResultCol( hstmt, 3 ).c_str() );
1593 dst[ i ].setEmail( getResultCol( hstmt, 4 ).c_str() );
1594 dst[ i ].setURL( getResultCol( hstmt, 5 ).c_str() );
1595 dst[ i ].setUserAvatar( getResultCol( hstmt, 6 ).c_str() );
1596 dst[ i ].setUserRegdate( atoi( getResultCol( hstmt, 7 ).c_str() ) );
1597 dst[ i ].setUserIcq( getResultCol( hstmt, 8 ).c_str() );
1598 dst[ i ].setUserFrom( getResultCol( hstmt, 9 ).c_str() );
1599 dst[ i ].setUserSig( getResultCol( hstmt, 10 ).c_str() );
1600 dst[ i ].setUserViewemail( atoi( getResultCol( hstmt, 11 ).c_str() ));
1601 dst[ i ].setActkey( getResultCol( hstmt, 12 ).c_str() );
1602 dst[ i ].setUserAim( getResultCol( hstmt, 13 ).c_str() );
1603 dst[ i ].setUserYim( getResultCol( hstmt, 14 ).c_str() );
1604 dst[ i ].setUserMsnm( getResultCol( hstmt, 15 ).c_str() );
1605 dst[ i ].setPass( getResultCol( hstmt, 16 ).c_str() );
1606 dst[ i ].setPosts( atoi( getResultCol( hstmt, 17 ).c_str() ));
1607 dst[ i ].setAttachsig( atoi( getResultCol( hstmt, 18 ).c_str() ));
1608 dst[ i ].setRank( atoi( getResultCol( hstmt, 19 ).c_str() ));
1609 dst[ i ].setLevel( atoi( getResultCol( hstmt, 20 ).c_str() ));
1610 dst[ i ].setTheme( getResultCol( hstmt, 21 ).c_str() );
1611 dst[ i ].setTimezoneOffset( atof( getResultCol( hstmt, 22 ).c_str() ) );
1612 dst[ i ].setLastLogin( atoi( getResultCol( hstmt, 23 ).c_str() ));
1613 dst[ i ].setUmode( getResultCol( hstmt, 24 ).c_str() );
1614 dst[ i ].setUorder( atoi( getResultCol( hstmt, 25 ).c_str() ));
1615 dst[ i ].setNotifyMethod( atoi( getResultCol( hstmt, 26 ).c_str() ));
1616 dst[ i ].setNotifyMode( atoi( getResultCol( hstmt, 27 ).c_str() ));
1617 dst[ i ].setUserOcc( getResultCol( hstmt, 28 ).c_str() );
1618 dst[ i ].setBio( getResultCol( hstmt, 29 ).c_str() );
1619 dst[ i ].setUserIntrest( getResultCol( hstmt, 30 ).c_str() );
1620 dst[ i ].setUserMailok( atoi( getResultCol( hstmt, 31 ).c_str() ));
1621 dst[ i ].setActivate( atoi( getResultCol( hstmt, 32 ).c_str() ));
1622 dst[ i ].setAddress( getResultCol( hstmt, 33 ).c_str() );
1623 dst[ i ].setDivision( getResultCol( hstmt, 34 ).c_str() );
1624 dst[ i ].setTel( getResultCol( hstmt, 35 ).c_str() );
1625 dst[ i ].setCompanyName( getResultCol( hstmt, 36 ).c_str() );
1626 dst[ i ].setCountry( getResultCol( hstmt, 37 ).c_str() );
1627 dst[ i ].setZipcode( getResultCol( hstmt, 38 ).c_str() );
1628 dst[ i ].setFax( getResultCol( hstmt, 39 ).c_str() );
1629 dst[ i ].setNoticeMail( atoi( getResultCol( hstmt, 40 ).c_str() ));
1630 dst[ i ].setNoticeMailSince( atoi( getResultCol( hstmt, 41 ).c_str() ));
1631 dst[ i ].setPrivateIndexID( atoi( getResultCol( hstmt, 42 ).c_str() ));
1632 dst[ i ].setItemNumberLimit( atoi( getResultCol( hstmt, 43 ).c_str() ));
1633 dst[ i ].setIndexNumberLimit( atoi( getResultCol( hstmt, 44 ).c_str() ));
1634 dst[ i ].setItemStorageLimit( storage_limit );
1635 ( *accountsLen )++;
1636 }
1637 *accounts = dst;
1638 syslog_printf( "getAccounts succeed" );
1639 ret = RES_OK;
1640 }else{
1641 string s( "SQLExecDirect in getAccounts" );
1642 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
1643 s += string( ", sql=" ) + string( sql );
1644 setLastErrorString( s.c_str( ) );
1645 syslog_printf( "getAccounts %s", getLastErrorString( ) );
1646 ret = RES_DB_QUERY_ERROR;
1647 }
1648 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
1649 }else{
1650 string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in getAccounts" );
1651 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
1652 setLastErrorString( s.c_str( ) );
1653 syslog_printf( "getAccounts %s", getLastErrorString( ) );
1654 ret = RES_DB_QUERY_ERROR;
1655 }
1656 return ret;
1657 }
1658
1659 /**
1660 *
1661 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1662 *
1663 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1664 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申uid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1665 *
1666 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1667 * @param account 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1668 * @param uid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1669 * @return RES_OK
1670 * @return RES_NO_SUCH_SESSION
1671 * @return RES_DB_QUERY_ERROR
1672 * @return RES_DB_NOT_INITIALIZED
1673 *
1674 */
1675 result_t insertAccount( sessionid_t sid, const account_t* account, userid_t* uid )
1676 {
1677 if( hdbc == NULL ) return RES_DB_NOT_INITIALIZED;
1678 if( !isValidSessionID( sid ) ) return RES_NO_SUCH_SESSION;
1679
1680 string sql;
1681 string tmp;
1682 SQLHANDLE hstmt = NULL;
1683 SQLRETURN sqlcode;
1684 result_t ret = RES_ERROR;
1685
1686 /*
1687 1. insert user profile into xoops_users
1688 2. insert platform user profile into xoonips_users
1689 3. add user to default platform group
1690 4. create private index
1691 5. update account set private_index_id=...
1692 */
1693
1694 //1.xoops鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1695 SQLCHAR uname[ACCOUNT_UNAME_LEN+1], name[ACCOUNT_NAME_LEN+1], email[ACCOUNT_EMAIL_LEN+1], url[ACCOUNT_URL_LEN+1], user_avatar[ACCOUNT_USER_AVATAR_LEN+1], user_icq[ACCOUNT_USER_ICQ_LEN+1], user_from[ACCOUNT_USER_FROM_LEN+1], user_sig[ACCOUNT_USER_SIG_LEN+1], actkey[ACCOUNT_ACTKEY_LEN+1], user_aim[ACCOUNT_USER_AIM_LEN+1], user_yim[ACCOUNT_USER_YIM_LEN+1], user_msnm[ACCOUNT_USER_MSNM_LEN+1], pass[ACCOUNT_PASS_LEN+1], theme[ACCOUNT_THEME_LEN+1], umode[ACCOUNT_UMODE_LEN+1], user_occ[ACCOUNT_USER_OCC_LEN+1], bio[ACCOUNT_BIO_LEN+1], user_intrest[ACCOUNT_USER_INTREST_LEN+1];
1696 SQLINTEGER user_regdate, user_viewemail, posts, attachsig, rank, level, last_login, uorder, notify_method, notify_mode, user_mailok;
1697 SQLDOUBLE timezone_offset;
1698
1699 SQLLEN cbUname = SQL_NTS, cbName = SQL_NTS, cbEmail = SQL_NTS, cbUrl = SQL_NTS, cbUser_avatar = SQL_NTS, cbUser_icq = SQL_NTS, cbUser_from = SQL_NTS, cbUser_sig = SQL_NTS, cbActkey = SQL_NTS, cbUser_aim = SQL_NTS, cbUser_yim = SQL_NTS, cbUser_msnm = SQL_NTS, cbPass = SQL_NTS, cbTheme = SQL_NTS, cbUmode = SQL_NTS, cbUser_occ = SQL_NTS, cbBio = SQL_NTS, cbUser_intrest = SQL_NTS;
1700 SQLLEN cbUser_regdate = 0, cbUser_viewemail = 0, cbPosts = 0, cbAttachsig = 0, cbRank = 0, cbLevel = 0, cbLast_login = 0, cbUorder = 0, cbNotify_method = 0, cbNotify_mode = 0, cbUser_mailok = 0, cbTimezone_offset = 0;
1701
1702 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
1703 string sql;
1704 sql = "INSERT INTO " + dbprefix + "_users (uname, name, email, url, user_avatar, user_regdate, user_icq, user_from, user_sig, user_viewemail, actkey, user_aim, user_yim, user_msnm, pass, posts, attachsig, rank, level, theme, timezone_offset, last_login, umode, uorder, notify_method, notify_mode, user_occ, bio, user_intrest, user_mailok) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
1705 sqlcode = SQLPrepare(hstmt, (SQLCHAR*)sql.c_str(), SQL_NTS);
1706 if( sqlcode == SQL_SUCCESS || sqlcode == SQL_SUCCESS_WITH_INFO ){
1707 SQLBindParameter(hstmt, 1, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_UNAME_LEN, 0, uname, 0, &cbUname );
1708 SQLBindParameter(hstmt, 2, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_NAME_LEN, 0, name, 0, &cbName );
1709 SQLBindParameter(hstmt, 3, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_EMAIL_LEN, 0, email, 0, &cbEmail );
1710 SQLBindParameter(hstmt, 4, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_URL_LEN, 0, url, 0, &cbUrl );
1711 SQLBindParameter(hstmt, 5, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_AVATAR_LEN, 0, user_avatar, 0, &cbUser_avatar );
1712 SQLBindParameter(hstmt, 6, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &user_regdate, 0, &cbUser_regdate );
1713 SQLBindParameter(hstmt, 7, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_ICQ_LEN, 0, user_icq, 0, &cbUser_icq );
1714 SQLBindParameter(hstmt, 8, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_FROM_LEN, 0, user_from, 0, &cbUser_from );
1715 SQLBindParameter(hstmt, 9, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_SIG_LEN, 0, user_sig, 0, &cbUser_sig );
1716 SQLBindParameter(hstmt, 10, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &user_viewemail, 0, &cbUser_viewemail );
1717 SQLBindParameter(hstmt, 11, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_ACTKEY_LEN, 0, actkey, 0, &cbActkey );
1718 SQLBindParameter(hstmt, 12, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_AIM_LEN, 0, user_aim, 0, &cbUser_aim );
1719 SQLBindParameter(hstmt, 13, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_YIM_LEN, 0, user_yim, 0, &cbUser_yim );
1720 SQLBindParameter(hstmt, 14, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_MSNM_LEN, 0, user_msnm, 0, &cbUser_msnm );
1721 SQLBindParameter(hstmt, 15, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_PASS_LEN, 0, pass, 0, &cbPass );
1722 SQLBindParameter(hstmt, 16, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &posts, 0, &cbPosts );
1723 SQLBindParameter(hstmt, 17, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &attachsig, 0, &cbAttachsig );
1724 SQLBindParameter(hstmt, 18, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &rank, 0, &cbRank );
1725 SQLBindParameter(hstmt, 19, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &level, 0, &cbLevel );
1726 SQLBindParameter(hstmt, 20, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_THEME_LEN, 0, theme, 0, &cbTheme );
1727 SQLBindParameter(hstmt, 21, SQL_PARAM_INPUT, SQL_C_DOUBLE, SQL_DOUBLE, 0, 0, &timezone_offset, 0, &cbTimezone_offset );
1728 SQLBindParameter(hstmt, 22, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &last_login, 0, &cbLast_login );
1729 SQLBindParameter(hstmt, 23, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_UMODE_LEN, 0, umode, 0, &cbUmode );
1730 SQLBindParameter(hstmt, 24, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &uorder, 0, &cbUorder );
1731 SQLBindParameter(hstmt, 25, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &notify_method, 0, &cbNotify_method );
1732 SQLBindParameter(hstmt, 26, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &notify_mode, 0, &cbNotify_mode );
1733 SQLBindParameter(hstmt, 27, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_OCC_LEN, 0, user_occ, 0, &cbUser_occ );
1734 SQLBindParameter(hstmt, 28, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_BIO_LEN, 0, bio, 0, &cbBio );
1735 SQLBindParameter(hstmt, 29, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_INTREST_LEN, 0, user_intrest, 0, &cbUser_intrest );
1736 SQLBindParameter(hstmt, 30, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &user_mailok, 0, &cbUser_mailok );
1737
1738 strncpy2( (char*)uname, account -> getUname( ), ACCOUNT_UNAME_LEN );
1739 strncpy2( (char*)name, account -> getName( ), ACCOUNT_NAME_LEN );
1740 strncpy2( (char*)email, account -> getEmail( ), ACCOUNT_EMAIL_LEN );
1741 strncpy2( (char*)url, account -> getURL( ), ACCOUNT_URL_LEN );
1742 strncpy2( (char*)user_avatar, account -> getUserAvatar( ), ACCOUNT_USER_AVATAR_LEN );
1743 user_regdate = time( NULL );
1744 strncpy2( (char*)user_icq, account -> getUserIcq( ), ACCOUNT_USER_ICQ_LEN );
1745 strncpy2( (char*)user_from, account -> getUserFrom( ), ACCOUNT_USER_FROM_LEN );
1746 strncpy2( (char*)user_sig, account -> getUserSig( ), ACCOUNT_USER_SIG_LEN );
1747 user_viewemail = account -> getUserViewemail( );
1748 strncpy2( (char*)actkey, account -> getActkey( ), ACCOUNT_ACTKEY_LEN );
1749 strncpy2( (char*)user_aim, account -> getUserAim( ), ACCOUNT_USER_AIM_LEN );
1750 strncpy2( (char*)user_yim, account -> getUserYim( ), ACCOUNT_USER_YIM_LEN );
1751 strncpy2( (char*)user_msnm, account -> getUserMsnm( ), ACCOUNT_USER_MSNM_LEN );
1752 strncpy2( (char*)pass, account -> getPass( ), ACCOUNT_PASS_LEN );
1753 posts = account -> getPosts( );
1754 attachsig = account -> getAttachsig( );
1755 rank = account -> getRank( );
1756 level = account -> getLevel( );
1757 strncpy2( (char*)theme, account -> getTheme( ), ACCOUNT_THEME_LEN );
1758 timezone_offset = account -> getTimezoneOffset( );
1759 last_login = 0;
1760 strncpy2( (char*)umode, account -> getUmode( ), ACCOUNT_UMODE_LEN );
1761 uorder = account -> getUorder( );
1762 notify_method = account -> getNotifyMethod( );
1763 notify_mode = account -> getNotifyMode( );
1764 strncpy2( (char*)user_occ, account -> getUserOcc( ), ACCOUNT_USER_OCC_LEN );
1765 strncpy2( (char*)bio, account -> getBio( ), ACCOUNT_BIO_LEN );
1766 strncpy2( (char*)user_intrest, account -> getUserIntrest( ), ACCOUNT_USER_INTREST_LEN );
1767 user_mailok = account -> getUserMailok( );
1768
1769 if( ( sqlcode = SQLExecute( hstmt ) ) == SQL_SUCCESS ){
1770 SQLLEN count = 0;
1771 if( ( sqlcode = SQLRowCount( hstmt, &count ) ) == SQL_SUCCESS && count > 0 ){
1772 //鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1773 if( dbtype == DBTYPE_MYSQL ){
1774 sql = "SELECT LAST_INSERT_ID()";
1775 }else if( dbtype == DBTYPE_SQLITE ){
1776 sql = "SELECT LAST_INSERT_ROWID()";
1777 }
1778 ret = queryGetUnsignedInt( "insertAccount", sql, (unsigned int*)uid );
1779 }else{
1780 string s( "SQLRowCount in insertAccount sql=" );
1781 s += string( sql );
1782 setLastErrorString( s.c_str( ) );
1783 ret = RES_DB_QUERY_ERROR;
1784 }
1785 }else{
1786 string s( "SQLExecute in insertAccount " );
1787 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
1788 setLastErrorString( s.c_str( ) );
1789 ret = RES_DB_QUERY_ERROR;
1790 }
1791 }else{
1792 string s( "SQLPrepare in insertAccount " );
1793 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
1794 setLastErrorString( s.c_str( ) );
1795 ret = RES_ERROR;
1796 }
1797 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
1798 }else{
1799 string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in insertAccount" );
1800 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
1801 setLastErrorString( s.c_str( ) );
1802 ret = RES_ERROR;
1803 }
1804
1805 if( ret == RES_OK ){
1806 //2.xoonips鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1807 SQLUINTEGER activate;
1808 SQLCHAR address[XNP_ACCOUNT_ADDRESS_LEN+1];
1809 SQLCHAR division[XNP_ACCOUNT_DIVISION_LEN+1];
1810 SQLCHAR tel[XNP_ACCOUNT_TEL_LEN+1];
1811 SQLCHAR company_name[XNP_ACCOUNT_COMPANY_NAME_LEN+1];
1812 SQLCHAR country[XNP_ACCOUNT_COUNTRY_LEN+1];
1813 SQLCHAR zipcode[XNP_ACCOUNT_ZIPCODE_LEN+1];
1814 SQLCHAR fax[XNP_ACCOUNT_FAX_LEN+1];
1815 SQLLEN cbAddress = SQL_NTS, cbDivision = SQL_NTS, cbTel = SQL_NTS, cbCompany_name = SQL_NTS, cbCountry = SQL_NTS, cbZipcode = SQL_NTS, cbFax = SQL_NTS;
1816 SQLLEN cbUid = 0, cbActivate = 0, cbNotice_mail = 0, cbNotice_mail_since = 0, cbItem_number_limit = 0, cbIndex_number_limit = 0, cbItem_storage_limit = 0;
1817 SQLUINTEGER notice_mail;
1818 SQLUINTEGER notice_mail_since;
1819 SQLINTEGER item_number_limit;
1820 SQLINTEGER index_number_limit;
1821 SQLDOUBLE item_storage_limit;
1822
1823 if( ret == RES_OK && ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
1824 string sql;
1825 sql = "INSERT INTO " + dbprefix + "_xoonips_users (uid, activate, address, division, tel, company_name, country, zipcode, fax, notice_mail, notice_mail_since, private_item_number_limit, private_index_number_limit, private_item_storage_limit) VALUES ( ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ? )";
1826 sqlcode = SQLPrepare(hstmt, (SQLCHAR*)sql.c_str(), SQL_NTS);
1827 if( sqlcode == SQL_SUCCESS || sqlcode == SQL_SUCCESS_WITH_INFO ){
1828 SQLBindParameter(hstmt, 1, SQL_PARAM_INPUT, SQL_C_SSHORT, SQL_INTEGER, 0, 0, uid, 0, &cbUid);
1829 SQLBindParameter(hstmt, 2, SQL_PARAM_INPUT, SQL_C_SSHORT, SQL_INTEGER, 0, 0, &activate, 0, &cbActivate);
1830 SQLBindParameter(hstmt, 3, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, XNP_ACCOUNT_ADDRESS_LEN, 0, address, 0, &cbAddress);
1831 SQLBindParameter(hstmt, 4, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, XNP_ACCOUNT_DIVISION_LEN, 0, division, 0, &cbDivision);
1832 SQLBindParameter(hstmt, 5, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, XNP_ACCOUNT_TEL_LEN, 0, tel, 0, &cbTel);
1833 SQLBindParameter(hstmt, 6, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, XNP_ACCOUNT_COMPANY_NAME_LEN, 0, company_name, 0, &cbCompany_name);
1834 SQLBindParameter(hstmt, 7, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, XNP_ACCOUNT_COUNTRY_LEN, 0, country, 0, &cbCountry);
1835 SQLBindParameter(hstmt, 8, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, XNP_ACCOUNT_ZIPCODE_LEN, 0, zipcode, 0, &cbZipcode);
1836 SQLBindParameter(hstmt, 9, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, XNP_ACCOUNT_FAX_LEN, 0, fax, 0, &cbFax);
1837 SQLBindParameter(hstmt, 10, SQL_PARAM_INPUT, SQL_C_SSHORT, SQL_INTEGER, 0, 0, &notice_mail, 0, &cbNotice_mail);
1838 SQLBindParameter(hstmt, 11, SQL_PARAM_INPUT, SQL_C_SSHORT, SQL_INTEGER, 0, 0, &notice_mail_since, 0, &cbNotice_mail_since);
1839 SQLBindParameter(hstmt, 12, SQL_PARAM_INPUT, SQL_C_SSHORT, SQL_INTEGER, 0, 0, &item_number_limit, 0, &cbItem_number_limit);
1840 SQLBindParameter(hstmt, 13, SQL_PARAM_INPUT, SQL_C_SSHORT, SQL_INTEGER, 0, 0, &index_number_limit, 0, &cbIndex_number_limit);
1841 SQLBindParameter(hstmt, 14, SQL_PARAM_INPUT, SQL_C_DOUBLE, SQL_DOUBLE, 0, 0, &item_storage_limit, 0, &cbItem_storage_limit);
1842
1843 activate = account -> getActivate() ? 1 : 0;
1844 strncpy2( (char*)address, account -> getAddress(), XNP_ACCOUNT_ADDRESS_LEN );
1845 strncpy2( (char*)division, account -> getDivision(), XNP_ACCOUNT_DIVISION_LEN );
1846 strncpy2( (char*)tel, account -> getTel(), XNP_ACCOUNT_TEL_LEN );
1847 strncpy2( (char*)company_name, account -> getCompanyName(), XNP_ACCOUNT_COMPANY_NAME_LEN );
1848 strncpy2( (char*)country, account -> getCountry(), XNP_ACCOUNT_COUNTRY_LEN );
1849 strncpy2( (char*)zipcode, account -> getZipcode(), XNP_ACCOUNT_ZIPCODE_LEN );
1850 strncpy2( (char*)fax, account -> getFax(), XNP_ACCOUNT_FAX_LEN );
1851 notice_mail = account -> getNoticeMail( );
1852 notice_mail_since = time( NULL );
1853 item_number_limit = account -> getItemNumberLimit( );
1854 index_number_limit = account -> getIndexNumberLimit( );
1855 item_storage_limit = account -> getItemStorageLimit( );
1856
1857 if( ( sqlcode = SQLExecute( hstmt ) ) == SQL_SUCCESS ){
1858 SQLLEN count = 0;
1859 if( ( sqlcode = SQLRowCount( hstmt, &count ) ) == SQL_SUCCESS && count > 0 ){
1860 ret = RES_OK;
1861 if( ret == RES_OK ){
1862 //3.add new user to default group(not a group admin)
1863 ret = insertMember( sid, group_t::GID_DEFAULT, *uid, false );
1864 }else{
1865 //xoops_users鐃緒申insert鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1866 sql = "DELETE FROM " + dbprefix + "_users where uid=";
1867 sql += unsignedIntToString( *uid );
1868 SQLHANDLE hstmt2 = NULL;
1869 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt2 ) ) == SQL_SUCCESS ) {
1870 SQLExecDirect( hstmt2, (SQLCHAR*)sql.c_str(), sql.length() );
1871 SQLFreeHandle( SQL_HANDLE_STMT, hstmt2 );
1872 }
1873 setLastErrorString( "insertMember in insertAccount" );
1874 ret = RES_DB_QUERY_ERROR;
1875 }
1876 }else{
1877 string s( "SQLRowCount in insertAccount sql=" );
1878 s += string( sql );
1879 setLastErrorString( s.c_str( ) );
1880 ret = RES_DB_QUERY_ERROR;
1881 }
1882 }else{
1883 string s( "SQLExecute in insertAccount " );
1884 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
1885 setLastErrorString( s.c_str( ) );
1886 ret = RES_DB_QUERY_ERROR;
1887 }
1888 }else{
1889 //xoops_users鐃緒申insert鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1890 sql = "DELETE FROM " + dbprefix + "_users where uid=";
1891 sql += unsignedIntToString( *uid );
1892 SQLHANDLE hstmt2 = NULL;
1893 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt2 ) ) == SQL_SUCCESS ) {
1894 SQLExecDirect( hstmt2, (SQLCHAR*)sql.c_str(), sql.length() );
1895 SQLFreeHandle( SQL_HANDLE_STMT, hstmt2 );
1896 }
1897 string s( "SQLExecDirect in insertAccount sql=" );
1898 s += string( sql );
1899 setLastErrorString( s.c_str( ) );
1900 ret = RES_DB_QUERY_ERROR;
1901 }
1902 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
1903 }else{
1904 string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in insertAccount" );
1905 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
1906 setLastErrorString( s.c_str( ) );
1907 ret = RES_ERROR;
1908 }
1909 }
1910
1911 if ( ret == RES_OK ){
1912 //4.private index鐃緒申鐃緒申鐃緒申
1913
1914 // private index鐃緒申鐃緒申sort_number鐃緒申鐃緒申
1915 string sql = "select min(sort_number) from " +
1916 dbprefix + "_xoonips_index where parent_index_id=" + unsignedIntToString(item::IID_ROOT) +
1917 " and open_level=" + unsignedIntToString(index::OL_PRIVATE);
1918 unsigned int sortNumber;
1919 ret = queryGetUnsignedInt( "insertAccount", sql, &sortNumber );
1920 sortNumber--;
1921 if ( ret == RES_OK ){
1922 // private index鐃緒申鐃緒申
1923 index_t index;
1924 index.setItemTypeID(item::ITID_INDEX);
1925 index.setContributorUID(*uid);
1926 index.setParentIndexID(item::IID_ROOT);
1927 index.setOwnerUID(*uid);
1928 index.setOpenLevel(index::OL_PRIVATE);
1929 index.setSortNumber(sortNumber);
1930 index.setTitle(account->getUname());
1931 indexid_t privateXID;
1932 ret = insertIndexInternal( sid, &index, &privateXID );
1933 if ( ret == RES_OK ){
1934 // xnpaccuont_users鐃緒申private_index_id鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1935 sql = "UPDATE " + dbprefix + "_xoonips_users SET private_index_id="
1936 + unsignedIntToString(privateXID) + " WHERE uid=" + unsignedIntToString(*uid);
1937 ret = querySimple( "insertAccount", sql );
1938 }
1939 }
1940 }
1941
1942 return ret;
1943 }
1944
1945 /**
1946 *
1947 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
1948 * account鐃緒申uid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1949 *
1950 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1951 * @param account 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1952 * @return RES_OK
1953 * @return RES_DB_NOT_INITIALIZED
1954 * @return RES_NO_SUCH_SESSION
1955 * @return RES_DB_QUERY_ERROR
1956 * @return RES_NO_SUCH_USER
1957 * @return RES_ERROR
1958 *
1959 */
1960 result_t updateAccount( sessionid_t sid, const account_t* account )
1961 {
1962 if( hdbc == NULL ) return RES_DB_NOT_INITIALIZED;
1963 if( account == NULL ) return RES_ERROR;
1964 if( !isValidSessionID( sid ) ) return RES_NO_SUCH_SESSION;
1965 if( !uidExists( account -> getUID( ) ) ) return RES_NO_SUCH_USER;
1966
1967 SQLRETURN sqlcode;
1968 result_t ret = RES_ERROR;
1969 SQLHANDLE hstmt = NULL;
1970
1971 //xoops鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1972 SQLCHAR uname[ACCOUNT_UNAME_LEN+1], name[ACCOUNT_NAME_LEN+1], email[ACCOUNT_EMAIL_LEN+1], url[ACCOUNT_URL_LEN+1], user_avatar[ACCOUNT_USER_AVATAR_LEN+1], user_icq[ACCOUNT_USER_ICQ_LEN+1], user_from[ACCOUNT_USER_FROM_LEN+1], user_sig[ACCOUNT_USER_SIG_LEN+1], actkey[ACCOUNT_ACTKEY_LEN+1], user_aim[ACCOUNT_USER_AIM_LEN+1], user_yim[ACCOUNT_USER_YIM_LEN+1], user_msnm[ACCOUNT_USER_MSNM_LEN+1], pass[ACCOUNT_PASS_LEN+1], theme[ACCOUNT_THEME_LEN+1], umode[ACCOUNT_UMODE_LEN+1], user_occ[ACCOUNT_USER_OCC_LEN+1], bio[ACCOUNT_BIO_LEN+1], user_intrest[ACCOUNT_USER_INTREST_LEN+1];
1973 SQLINTEGER uid, user_regdate, user_viewemail, posts, attachsig, rank, level, last_login, uorder, notify_method, notify_mode, user_mailok;
1974 SQLDOUBLE timezone_offset;
1975
1976 SQLLEN cbUname = SQL_NTS, cbName = SQL_NTS, cbEmail = SQL_NTS, cbUrl = SQL_NTS, cbUser_avatar = SQL_NTS, cbUser_icq = SQL_NTS, cbUser_from = SQL_NTS, cbUser_sig = SQL_NTS, cbActkey = SQL_NTS, cbUser_aim = SQL_NTS, cbUser_yim = SQL_NTS, cbUser_msnm = SQL_NTS, cbPass = SQL_NTS, cbTheme = SQL_NTS, cbUmode = SQL_NTS, cbUser_occ = SQL_NTS, cbBio = SQL_NTS, cbUser_intrest = SQL_NTS;
1977 SQLLEN cbUid = 0, cbUser_regdate = 0, cbUser_viewemail = 0, cbPosts = 0, cbAttachsig = 0, cbRank = 0, cbLevel = 0, cbLast_login = 0, cbUorder = 0, cbNotify_method = 0, cbNotify_mode = 0, cbUser_mailok = 0, cbTimezone_offset = 0;
1978
1979 SQLUINTEGER activate;
1980 SQLCHAR address[XNP_ACCOUNT_ADDRESS_LEN+1];
1981 SQLCHAR division[XNP_ACCOUNT_DIVISION_LEN+1];
1982 SQLCHAR tel[XNP_ACCOUNT_TEL_LEN+1];
1983 SQLCHAR company_name[XNP_ACCOUNT_COMPANY_NAME_LEN+1];
1984 SQLCHAR country[XNP_ACCOUNT_COUNTRY_LEN+1];
1985 SQLCHAR zipcode[XNP_ACCOUNT_ZIPCODE_LEN+1];
1986 SQLCHAR fax[XNP_ACCOUNT_FAX_LEN+1];
1987 SQLLEN cbActivate = 0, cbAddress = SQL_NTS, cbDivision = SQL_NTS, cbTel = SQL_NTS, cbCompany_name = SQL_NTS, cbCountry = SQL_NTS, cbZipcode = SQL_NTS, cbFax = SQL_NTS;
1988 SQLUINTEGER notice_mail, notice_mail_since;
1989 SQLLEN cbNotice_mail = 0, cbNotice_mail_since = 0;
1990
1991 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
1992 string sql;
1993
1994 sql = "UPDATE " + dbprefix + "_users SET ";
1995 sql += "uname=?";
1996 sql += ", name=?";
1997 sql += ", email=?";
1998 sql += ", url=?";
1999 sql += ", user_avatar=?";
2000 sql += ", user_regdate=?";
2001 sql += ", user_icq=?";
2002 sql += ", user_from=?";
2003 sql += ", user_sig=?";
2004 sql += ", user_viewemail=?";
2005 sql += ", actkey=?";
2006 sql += ", user_aim=?";
2007 sql += ", user_yim=?";
2008 sql += ", user_msnm=?";
2009 sql += ", pass=?";
2010 sql += ", posts=?";
2011 sql += ", attachsig=?";
2012 sql += ", rank=?";
2013 sql += ", level=?";
2014 sql += ", theme=?";
2015 sql += ", timezone_offset=?";
2016 sql += ", last_login=?";
2017 sql += ", umode=?";
2018 sql += ", uorder=?";
2019 sql += ", notify_method=?";
2020 sql += ", notify_mode=?";
2021 sql += ", user_occ=?";
2022 sql += ", bio=?";
2023 sql += ", user_intrest=?";
2024 sql += ", user_mailok=? ";
2025 sql += " WHERE uid = ?";
2026
2027 sqlcode = SQLPrepare(hstmt, (SQLCHAR*)sql.c_str(), SQL_NTS);
2028 if( sqlcode == SQL_SUCCESS || sqlcode == SQL_SUCCESS_WITH_INFO ){
2029 SQLBindParameter(hstmt, 1, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_UNAME_LEN, 0, uname, 0, &cbUname );
2030 SQLBindParameter(hstmt, 2, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_NAME_LEN, 0, name, 0, &cbName );
2031 SQLBindParameter(hstmt, 3, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_EMAIL_LEN, 0, email, 0, &cbEmail );
2032 SQLBindParameter(hstmt, 4, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_URL_LEN, 0, url, 0, &cbUrl );
2033 SQLBindParameter(hstmt, 5, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_AVATAR_LEN, 0, user_avatar, 0, &cbUser_avatar );
2034 SQLBindParameter(hstmt, 6, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &user_regdate, 0, &cbUser_regdate );
2035 SQLBindParameter(hstmt, 7, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_ICQ_LEN, 0, user_icq, 0, &cbUser_icq );
2036 SQLBindParameter(hstmt, 8, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_FROM_LEN, 0, user_from, 0, &cbUser_from );
2037 SQLBindParameter(hstmt, 9, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_SIG_LEN, 0, user_sig, 0, &cbUser_sig );
2038 SQLBindParameter(hstmt, 10, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &user_viewemail, 0, &cbUser_viewemail );
2039 SQLBindParameter(hstmt, 11, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_ACTKEY_LEN, 0, actkey, 0, &cbActkey );
2040 SQLBindParameter(hstmt, 12, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_AIM_LEN, 0, user_aim, 0, &cbUser_aim );
2041 SQLBindParameter(hstmt, 13, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_YIM_LEN, 0, user_yim, 0, &cbUser_yim );
2042 SQLBindParameter(hstmt, 14, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_MSNM_LEN, 0, user_msnm, 0, &cbUser_msnm );
2043 SQLBindParameter(hstmt, 15, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_PASS_LEN, 0, pass, 0, &cbPass );
2044 SQLBindParameter(hstmt, 16, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &posts, 0, &cbPosts );
2045 SQLBindParameter(hstmt, 17, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &attachsig, 0, &cbAttachsig );
2046 SQLBindParameter(hstmt, 18, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &rank, 0, &cbRank );
2047 SQLBindParameter(hstmt, 19, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &level, 0, &cbLevel );
2048 SQLBindParameter(hstmt, 20, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_THEME_LEN, 0, theme, 0, &cbTheme );
2049 SQLBindParameter(hstmt, 21, SQL_PARAM_INPUT, SQL_C_DOUBLE, SQL_DOUBLE, 0, 0, &timezone_offset, 0, &cbTimezone_offset );
2050 SQLBindParameter(hstmt, 22, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &last_login, 0, &cbLast_login );
2051 SQLBindParameter(hstmt, 23, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_UMODE_LEN, 0, umode, 0, &cbUmode );
2052 SQLBindParameter(hstmt, 24, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &uorder, 0, &cbUorder );
2053 SQLBindParameter(hstmt, 25, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &notify_method, 0, &cbNotify_method );
2054 SQLBindParameter(hstmt, 26, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &notify_mode, 0, &cbNotify_mode );
2055 SQLBindParameter(hstmt, 27, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_OCC_LEN, 0, user_occ, 0, &cbUser_occ );
2056 SQLBindParameter(hstmt, 28, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_BIO_LEN, 0, bio, 0, &cbBio );
2057 SQLBindParameter(hstmt, 29, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_INTREST_LEN, 0, user_intrest, 0, &cbUser_intrest );
2058 SQLBindParameter(hstmt, 30, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &user_mailok, 0, &cbUser_mailok );
2059 SQLBindParameter(hstmt, 31, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &uid, 0, &cbUid );
2060
2061 strncpy2( (char*)uname, account -> getUname( ), ACCOUNT_UNAME_LEN );
2062 strncpy2( (char*)name, account -> getName( ), ACCOUNT_NAME_LEN );
2063 strncpy2( (char*)email, account -> getEmail( ), ACCOUNT_EMAIL_LEN );
2064 strncpy2( (char*)url, account -> getURL( ), ACCOUNT_URL_LEN );
2065 strncpy2( (char*)user_avatar, account -> getUserAvatar( ), ACCOUNT_USER_AVATAR_LEN );
2066 user_regdate = time( NULL );
2067 strncpy2( (char*)user_icq, account -> getUserIcq( ), ACCOUNT_USER_ICQ_LEN );
2068 strncpy2( (char*)user_from, account -> getUserFrom( ), ACCOUNT_USER_FROM_LEN );
2069 strncpy2( (char*)user_sig, account -> getUserSig( ), ACCOUNT_USER_SIG_LEN );
2070 user_viewemail = account -> getUserViewemail( );
2071 strncpy2( (char*)actkey, account -> getActkey( ), ACCOUNT_ACTKEY_LEN );
2072 strncpy2( (char*)user_aim, account -> getUserAim( ), ACCOUNT_USER_AIM_LEN );
2073 strncpy2( (char*)user_yim, account -> getUserYim( ), ACCOUNT_USER_YIM_LEN );
2074 strncpy2( (char*)user_msnm, account -> getUserMsnm( ), ACCOUNT_USER_MSNM_LEN );
2075 strncpy2( (char*)pass, account -> getPass( ), ACCOUNT_PASS_LEN );
2076 posts = account -> getPosts( );
2077 attachsig = account -> getAttachsig( );
2078 rank = account -> getRank( );
2079 level = account -> getLevel( );
2080 strncpy2( (char*)theme, account -> getTheme( ), ACCOUNT_THEME_LEN );
2081 timezone_offset = account -> getTimezoneOffset( );
2082 last_login = 0;
2083 strncpy2( (char*)umode, account -> getUmode( ), ACCOUNT_UMODE_LEN );
2084 uorder = account -> getUorder( );
2085 notify_method = account -> getNotifyMethod( );
2086 notify_mode = account -> getNotifyMode( );
2087 strncpy2( (char*)user_occ, account -> getUserOcc( ), ACCOUNT_USER_OCC_LEN );
2088 strncpy2( (char*)bio, account -> getBio( ), ACCOUNT_BIO_LEN );
2089 strncpy2( (char*)user_intrest, account -> getUserIntrest( ), ACCOUNT_USER_INTREST_LEN );
2090 user_mailok = account -> getUserMailok( );
2091 uid = account -> getUID( );
2092
2093 if( ( sqlcode = SQLExecute( hstmt ) ) == SQL_SUCCESS ){
2094 SQLLEN count = 0;
2095 if( ( sqlcode = SQLRowCount( hstmt, &count ) ) == SQL_SUCCESS && count > 0 ){
2096 ret = RES_OK;
2097 }else{
2098 string s( "SQLRowCount in updateAccount sql=" );
2099 s += string( sql );
2100 setLastErrorString( s.c_str( ) );
2101 ret = RES_DB_QUERY_ERROR;
2102 }
2103 }else{
2104 string s( "SQLExecute in updateAccount 1 " );
2105 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
2106 setLastErrorString( s.c_str( ) );
2107 ret = RES_DB_QUERY_ERROR;
2108 }
2109 }else{
2110 setLastErrorString( "SQLPrepare in updateAccount sql=" );
2111 ret = RES_ERROR;
2112 }
2113 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
2114 hstmt = NULL;
2115 }else{
2116 string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in updateAccount" );
2117 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
2118 setLastErrorString( s.c_str( ) );
2119 ret = RES_ERROR;
2120 }
2121
2122 if( ret != RES_OK ){
2123 return ret;
2124 }
2125
2126 //xoonips鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2127 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
2128 string sql;
2129
2130 sql = "UPDATE " + dbprefix + "_xoonips_users SET ";
2131 sql += "activate=?, ";
2132 sql += "address=?, ";
2133 sql += "division=?, ";
2134 sql += "tel=?, ";
2135 sql += "company_name=?, ";
2136 sql += "country=?, ";
2137 sql += "zipcode=?, ";
2138 sql += "fax=?, ";
2139 sql += "notice_mail=?, ";
2140 sql += "notice_mail_since=? ,";
2141 sql += "private_item_number_limit=" + unsignedIntToString( account -> getItemNumberLimit( ) ) + " ,";
2142 sql += "private_index_number_limit=" + unsignedIntToString( account -> getIndexNumberLimit( ) ) + " ,";
2143 sql += "private_item_storage_limit=" + doubleToString( account -> getItemStorageLimit( ) ) + " ";
2144 sql += "WHERE uid=?";
2145
2146 sqlcode = SQLPrepare(hstmt, (SQLCHAR*)sql.c_str(), SQL_NTS);
2147 if( sqlcode == SQL_SUCCESS || sqlcode == SQL_SUCCESS_WITH_INFO ){
2148 SQLBindParameter(hstmt, 1, SQL_PARAM_INPUT, SQL_C_SSHORT, SQL_INTEGER, 0, 0, &activate, 0, &cbActivate);
2149 SQLBindParameter(hstmt, 2, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, XNP_ACCOUNT_ADDRESS_LEN, 0, address, 0, &cbAddress);
2150 SQLBindParameter(hstmt, 3, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, XNP_ACCOUNT_DIVISION_LEN, 0, division, 0, &cbDivision);
2151 SQLBindParameter(hstmt, 4, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, XNP_ACCOUNT_TEL_LEN, 0, tel, 0, &cbTel);
2152 SQLBindParameter(hstmt, 5, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, XNP_ACCOUNT_COMPANY_NAME_LEN, 0, company_name, 0, &cbCompany_name);
2153 SQLBindParameter(hstmt, 6, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, XNP_ACCOUNT_COUNTRY_LEN, 0, country, 0, &cbCountry);
2154 SQLBindParameter(hstmt, 7, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, XNP_ACCOUNT_ZIPCODE_LEN, 0, zipcode, 0, &cbZipcode);
2155 SQLBindParameter(hstmt, 8, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, XNP_ACCOUNT_FAX_LEN, 0, fax, 0, &cbFax);
2156 SQLBindParameter(hstmt, 9, SQL_PARAM_INPUT, SQL_C_SSHORT, SQL_INTEGER, 0, 0, &notice_mail, 0, &cbNotice_mail);
2157 SQLBindParameter(hstmt, 10, SQL_PARAM_INPUT, SQL_C_SSHORT, SQL_INTEGER, 0, 0, &notice_mail_since, 0, &cbNotice_mail_since);
2158 SQLBindParameter(hstmt, 11, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &uid, 0, &cbUid );
2159
2160 activate = account -> getActivate() ? 1 : 0;
2161 strncpy2( (char*)address, account -> getAddress( ) , XNP_ACCOUNT_ADDRESS_LEN );
2162 strncpy2( (char*)division, account -> getDivision(), XNP_ACCOUNT_DIVISION_LEN );
2163 strncpy2( (char*)tel, account -> getTel(), XNP_ACCOUNT_TEL_LEN );
2164 strncpy2( (char*)company_name, account -> getCompanyName(), XNP_ACCOUNT_COMPANY_NAME_LEN );
2165 strncpy2( (char*)country, account -> getCountry(), XNP_ACCOUNT_COUNTRY_LEN );
2166 strncpy2( (char*)zipcode, account -> getZipcode(), XNP_ACCOUNT_ZIPCODE_LEN );
2167 strncpy2( (char*)fax, account -> getFax(), XNP_ACCOUNT_FAX_LEN );
2168 notice_mail = account -> getNoticeMail( );
2169 notice_mail_since = account -> getNoticeMailSince( );
2170 uid = account -> getUID( );
2171
2172 if( ( sqlcode = SQLExecute( hstmt ) ) == SQL_SUCCESS ){
2173 SQLLEN count = 0;
2174 if( ( sqlcode = SQLRowCount( hstmt, &count ) ) == SQL_SUCCESS && count > 0 ){
2175 ret = RES_OK;
2176 }else{
2177 string s( "SQLRowCount in updateAccount sql=" );
2178 s += string( sql );
2179 setLastErrorString( s.c_str( ) );
2180 ret = RES_DB_QUERY_ERROR;
2181 }
2182 }else{
2183 string s( "SQLExecute in updateAccount 2 " );
2184 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
2185 setLastErrorString( s.c_str( ) );
2186 ret = RES_DB_QUERY_ERROR;
2187 }
2188 }else{
2189 setLastErrorString( "SQLPrepare in updateAccount sql=" );
2190 ret = RES_ERROR;
2191 }
2192 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
2193 }else{
2194 string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in updateAccount" );
2195 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
2196 setLastErrorString( s.c_str( ) );
2197 ret = RES_ERROR;
2198 }
2199 return ret;
2200 }
2201
2202 /**
2203 *
2204 * criteria_t鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申.
2205 * 鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申*uids鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
2206 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申*uidsLen鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2207 *
2208 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2209 * @param cri 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2210 * @param uids 鐃緒申鐃緒申鐃緒申鐃緒申UID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2211 * @param uidsLen uids鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2212 * @return RES_OK
2213 * @return RES_DB_NOT_INITIALIZED
2214 * @return RES_NO_SUCH_SESSION
2215 * @return RES_DB_QUERY_ERROR
2216 * @see freeUID
2217 */
2218 result_t dumpUids( sessionid_t sid, criteria_t* cri, userid_t** uids, int* uidsLen )
2219 {
2220 if( hdbc == NULL ) return RES_DB_NOT_INITIALIZED;
2221 if( !isValidSessionID( sid ) ) return RES_NO_SUCH_SESSION;
2222
2223 result_t ret = RES_ERROR;
2224 userid_t* dst = 0;
2225 string sql;
2226 SQLHANDLE hstmt = NULL;
2227 SQLRETURN sqlcode;
2228 SQLLEN count = 0;
2229
2230
2231 sql = "SELECT uid FROM " + dbprefix + "_xoonips_users ";
2232 sql += criteria2str( cri );
2233 if( countResultRows( sql.c_str(), &count ) == RES_OK ){
2234 *uidsLen = count;
2235 dst = new userid_t[ *uidsLen ];
2236 *uids = dst;
2237 }else{
2238 return RES_ERROR;
2239 }
2240 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
2241 if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
2242 userid_t uid = 0;
2243 SQLLEN len = 0;
2244 SQLBindCol( hstmt, 1, SQL_C_ULONG, &uid, 0, &len );
2245
2246 for( int i = 0; ( sqlcode = SQLFetch( hstmt ) ) == SQL_SUCCESS && i < *uidsLen ; i++ ){
2247 dst[ i ] = uid;
2248 }
2249
2250 syslog_printf( "dumpUids succeed" );
2251 ret = RES_OK;
2252 }else{
2253 string s( "SQLExecDirect in dumpUids " );
2254 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
2255 s += "sql=";
2256 s += string( sql );
2257 setLastErrorString( s.c_str( ) );
2258 syslog_printf( "dumpUids %s", getLastErrorString( ) );
2259 ret = RES_DB_QUERY_ERROR;
2260 }
2261 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
2262 }else{
2263 string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in dumpUids" );
2264 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
2265 setLastErrorString( s.c_str( ) );
2266 syslog_printf( "dumpUids %s", getLastErrorString( ) );
2267 ret = RES_ERROR;
2268 }
2269 return ret;
2270 }
2271
2272 /**
2273 *
2274 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(default鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申).
2275 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申0鐃緒申鐃緒申鐃緒申.
2276 *
2277 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2278 * @return 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2279 *
2280 */
2281 int getGroupCount( sessionid_t sid )
2282 {
2283 if( hdbc == NULL ) return 0;
2284 if( !isValidSessionID( sid ) ) return 0;
2285
2286 SQLRETURN sqlcode;
2287 SQLHANDLE hstmt = NULL;
2288 string sql;
2289 int ret = 0;
2290
2291 //鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2292 sql = "SELECT COUNT(*) FROM " + dbprefix + "_xoonips_groups";
2293 sql += " WHERE gid != " + unsignedIntToString( group::GID_DEFAULT );
2294 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
2295 if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
2296 SQLUINTEGER count = 0;
2297 SQLLEN len = 0;
2298 SQLBindCol( hstmt, 1, SQL_C_ULONG, &count, 0, &len );
2299 if( ( sqlcode = SQLFetch( hstmt ) ) == SQL_SUCCESS ){
2300 ret = count;
2301 }else {
2302 string s( "SQLFetch in getGroupCount sql=" );
2303 s += string( sql );
2304 setLastErrorString( s.c_str( ) );
2305 ret = 0;
2306 }
2307 }else{
2308 setLastErrorString( "SQLExecDirect in getGroupCount" );
2309 ret = 0;
2310 }
2311 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
2312 }else{
2313 string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in getGroupCount" );
2314 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
2315 setLastErrorString( s.c_str( ) );
2316 ret = 0;
2317 }
2318 return ret;
2319 }
2320
2321 /**
2322 *
2323 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
2324 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(default鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申).
2325 *
2326 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2327 * @param uid 鐃緒申鐃緒申鐃緒申鐃緒申UID
2328 * @param cri 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2329 * @param gids 鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2330 * @param gidsLen gids鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2331 * @return RES_DB_NOT_INITIALIZED
2332 * @return RES_NO_SUCH_SESSION
2333 * @return RES_NO_SUCH_USER
2334 * @return RES_DB_QUERY_ERROR
2335 * @return RES_OK
2336 * @see freeGID
2337 */
2338 result_t getGroupsByUid( sessionid_t sid, userid_t uid, criteria_t* cri, groupid_t** gids, int* gidsLen )
2339 {
2340 if( hdbc == NULL ) return RES_DB_NOT_INITIALIZED;
2341 if( !isValidSessionID( sid ) ) return RES_NO_SUCH_SESSION;
2342 if( !uidExists( uid ) ) return RES_NO_SUCH_USER; //uid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2343
2344 result_t ret = RES_ERROR;
2345 string sql;
2346 SQLRETURN sqlcode;
2347 SQLHANDLE hstmt = NULL;
2348 SQLLEN count = 0;
2349 groupid_t* dst = 0;
2350
2351 sql = "SELECT gid FROM " + dbprefix + "_xoonips_groups_users_link";
2352 sql += " WHERE uid=" + string( unsignedIntToString( uid ) );
2353 sql += " AND gid != " + unsignedIntToString( group::GID_DEFAULT );
2354 sql += criteria2str( cri );
2355 if( countResultRows( sql.c_str(), &count ) == RES_OK ){
2356 *gidsLen = count;
2357 dst = new groupid_t[ *gidsLen ];
2358 *gids = dst;
2359 }else{
2360 return RES_ERROR;
2361 }
2362
2363 //鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2364 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
2365 if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
2366 if( count > 0 ){
2367 SQLHANDLE hstmt2 = NULL;
2368 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt2 ) ) == SQL_SUCCESS ) {
2369 sql = "SELECT gid, uid, is_admin FROM " + dbprefix + "_xoonips_groups_users_link";
2370 sql += " WHERE uid=" + string( unsignedIntToString( uid ) );
2371 sql += " AND gid != " + unsignedIntToString( group::GID_DEFAULT );
2372 sql += criteria2str( cri );
2373 if( ( sqlcode = SQLExecDirect( hstmt2, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
2374 SQLLEN len = 0;
2375 groupid_t gid = 0;
2376 SQLBindCol( hstmt, 1, SQL_C_ULONG, &gid, 0, &len );
2377 for( int i = 0; ( sqlcode = SQLFetch( hstmt ) ) == SQL_SUCCESS && i < *gidsLen ; i++ ){
2378 dst[ i ] = gid;
2379 }
2380 ret = RES_OK;
2381 }else{
2382 string s( "SQLExecDirect in getGroupsByUid " );
2383 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
2384 s += string( ", sql=" ) + string( sql );
2385 setLastErrorString( s.c_str( ) );
2386 ret = RES_DB_QUERY_ERROR;
2387 }
2388 }else{
2389 string s( "SQLAllocHandle in getGroupsByUid " );
2390 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
2391 setLastErrorString( s.c_str( ) );
2392 ret = RES_ERROR;
2393 }
2394 }else{
2395 ret = RES_OK;
2396 }
2397 }else{
2398 string s( "SQLExecDirect in getGroupsByUid " );
2399 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
2400 s += string( ", sql=" ) + string( sql );
2401 setLastErrorString( s.c_str( ) );
2402 ret = RES_DB_QUERY_ERROR;
2403 }
2404 }else{
2405 string s( "SQLAllocHandle in getGroupsByUid " );
2406 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
2407 setLastErrorString( s.c_str( ) );
2408 ret = RES_ERROR;
2409 }
2410 return ret;
2411 }
2412
2413 /**
2414 *
2415 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
2416 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申)鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
2417 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申false鐃緒申鐃緒申鐃緒申.
2418 *
2419 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2420 * @param gid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申UID
2421 * @param uid 鐃緒申鐃緒申鐃緒申鐃緒申UID
2422 * @return true 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2423 * @return false 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2424 * @see
2425 */
2426 bool isGroupAdmin( sessionid_t sid, groupid_t gid, userid_t uid )
2427 {
2428 if( hdbc == NULL ) return false;
2429 if( !isValidSessionID( sid ) ) return false;
2430 if( !uidExists( uid ) ) return false;
2431 if( !gidExists( gid ) ) return false;
2432
2433 bool ret = false;
2434 string sql;
2435 SQLLEN count = 0;
2436
2437 sql = "SELECT * FROM " + dbprefix + "_xoonips_groups_users_link ";
2438 sql += "WHERE gid=" + string( unsignedIntToString( gid ) );
2439 sql += " AND uid=" + string( unsignedIntToString( uid ) );
2440 sql += " AND is_admin=1";
2441 if( countResultRows( sql.c_str(), &count ) == RES_OK ){
2442 if( count > 0 ){
2443 ret = true;
2444 }else{
2445 ret = false;
2446 }
2447 }else{
2448 ret = false;
2449 }
2450 return ret;
2451 }
2452
2453 /**
2454 *
2455 * 鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申.
2456 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
2457 *
2458 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2459 * @param cri 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2460 * @param gids 鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2461 * @param gidsLen gids鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2462 * @return RES_DB_NOT_INITIALIZED
2463 * @return RES_NO_SUCH_SESSION
2464 * @return RES_DB_QUERY_ERROR
2465 * @return RES_OK
2466 *
2467 */
2468 result_t dumpGids( sessionid_t sid, criteria_t* cri, groupid_t** gids, int* gidsLen )
2469 {
2470 if( hdbc == NULL ) return RES_DB_NOT_INITIALIZED;
2471 if( !isValidSessionID( sid ) ) return RES_NO_SUCH_SESSION;
2472
2473 result_t ret = RES_ERROR;
2474 groupid_t* dst = 0;
2475 string sql;
2476 SQLHANDLE hstmt = NULL;
2477 SQLRETURN sqlcode;
2478 SQLLEN count = 0;
2479
2480 sql = "SELECT gid FROM " + dbprefix + "_xoonips_groups ";
2481 sql += " WHERE gid != " + unsignedIntToString( group::GID_DEFAULT );
2482 sql += criteria2str( cri );
2483 if( countResultRows( sql.c_str(), &count ) == RES_OK ){
2484 *gidsLen = count;
2485 dst = new groupid_t[ *gidsLen ];
2486 *gids = dst;
2487 }else{
2488 return RES_ERROR;
2489 }
2490
2491 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
2492 if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
2493 groupid_t gid = 0;
2494 SQLLEN len = 0;
2495 SQLBindCol( hstmt, 1, SQL_C_ULONG, &gid, 0, &len );
2496 for( int i = 0; ( sqlcode = SQLFetch( hstmt ) ) == SQL_SUCCESS && i < *gidsLen ; i++ ){
2497 dst[ i ] = gid;
2498 }
2499
2500 ret = RES_OK;
2501 }else{
2502 string s( "SQLExecDirect in dumpGids " );
2503 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
2504 s += "sql=";
2505 s += string( sql );
2506 setLastErrorString( s.c_str( ) );
2507 ret = RES_DB_QUERY_ERROR;
2508 }
2509 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
2510 }
2511 return ret;
2512 }
2513
2514 /**
2515 *
2516 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
2517 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
2518 *
2519 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2520 * @param gid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2521 * @param cri 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2522 * @param uids 鐃緒申鐃緒申鐃緒申鐃緒申UID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2523 * @param uidsLen uids鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2524 * @return RES_OK
2525 * @return RES_DB_NOT_INITIALIZED
2526 * @return RES_NO_SUCH_SESSION
2527 * @return RES_DB_QUERY_ERROR
2528 * @return RES_ERROR
2529 *
2530 */
2531 result_t dumpGroupAdmins( sessionid_t sid, groupid_t gid, criteria_t* cri, userid_t** uids, int* uidsLen )
2532 {
2533 if( hdbc == NULL ) return RES_DB_NOT_INITIALIZED;
2534 if( !isValidSessionID( sid ) ) return RES_NO_SUCH_SESSION;
2535
2536 result_t ret = RES_ERROR;
2537 string sql;
2538 SQLHANDLE hstmt = NULL;
2539 SQLRETURN sqlcode;
2540 SQLLEN count = 0;
2541
2542 sql = "SELECT uid FROM " + dbprefix + "_xoonips_groups_users_link ";
2543 sql += " WHERE is_admin=1 and gid=" + unsignedIntToString( gid );
2544 if( countResultRows( sql.c_str(), &count ) == RES_OK ){
2545 *uidsLen = count;
2546 *uids = new groupid_t[ *uidsLen ];
2547 }else{
2548 return RES_ERROR;
2549 }
2550 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
2551 if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
2552 userid_t uid;
2553 SQLLEN len = 0;
2554 SQLBindCol( hstmt, 1, SQL_C_ULONG, &uid, 0, &len );
2555 for( int i = 0; ( sqlcode = SQLFetch( hstmt ) ) == SQL_SUCCESS && i < *uidsLen ; i++ ){
2556 (*uids)[ i ] = uid;
2557 }
2558 ret = RES_OK;
2559 }else{
2560 string s( "SQLExecDirect in dumpGroupAdmins " );
2561 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
2562 s += "sql=";
2563 s += string( sql );
2564 setLastErrorString( s.c_str( ) );
2565 ret = RES_DB_QUERY_ERROR;
2566 }
2567 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
2568 }
2569 return ret;
2570 }
2571
2572 /**
2573 *
2574 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
2575 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
2576 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2577 *
2578 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2579 * @param gid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2580 * @param uid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2581 * @return RES_DB_NOT_INITIALIZED
2582 * @return RES_NO_SUCH_SESSION
2583 * @return RES_NO_SUCH_USER
2584 * @return RES_NO_SUCH_GROUP
2585 * @return RES_DB_QUERY_ERROR
2586 * @return RES_OK
2587 * @return RES_ERROR
2588 *
2589 */
2590 result_t deleteMember( sessionid_t sid, groupid_t gid, userid_t uid )
2591 {
2592 if( gid == group_t::GID_DEFAULT ) return RES_ERROR;
2593 return deleteMemberNoLimit( sid, gid, uid );
2594 }
2595
2596 /**
2597 *
2598 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
2599 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
2600 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申deleteMember鐃緒申鐃緒申鐃緒申鐃緒申
2601 *
2602 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2603 * @param gid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2604 * @param uid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2605 * @return RES_DB_NOT_INITIALIZED
2606 * @return RES_NO_SUCH_SESSION
2607 * @return RES_NO_SUCH_USER
2608 * @return RES_NO_SUCH_GROUP
2609 * @return RES_DB_QUERY_ERROR
2610 * @return RES_OK
2611 * @return RES_ERROR
2612 *
2613 */
2614 static result_t deleteMemberNoLimit( sessionid_t sid, groupid_t gid, userid_t uid )
2615 {
2616 if( hdbc == NULL ) return RES_DB_NOT_INITIALIZED;
2617 if( !isValidSessionID( sid ) ) return RES_NO_SUCH_SESSION;
2618 if( !uidExists( uid ) ) return RES_NO_SUCH_USER; //uid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2619 if( !gidExists( gid ) ) return RES_NO_SUCH_GROUP; //gid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2620
2621 result_t ret = RES_ERROR;
2622 string sql;
2623 SQLRETURN sqlcode;
2624 SQLHANDLE hstmt = NULL;
2625
2626 sql = "DELETE FROM " + dbprefix + "_xoonips_groups_users_link ";
2627 sql += "WHERE gid=" + string( unsignedIntToString( gid ) );
2628 sql += " AND uid=" + string( unsignedIntToString( uid ) );
2629 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
2630 if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
2631 SQLLEN count = 0;
2632 if( ( sqlcode = SQLRowCount( hstmt, &count ) ) == SQL_SUCCESS && count > 0 ){
2633 ret = RES_OK;
2634 }else{
2635 string s( "SQLRowCount in deleteMember" );
2636 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
2637 s += string( ", sql=" ) + string( sql );
2638 setLastErrorString( s.c_str( ) );
2639 ret = RES_NO_SUCH_USER;
2640 }
2641 }else{
2642 string s( "SQLExecDirect in deleteMember" );
2643 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
2644 s += ", sql=";
2645 s += string( sql );
2646 setLastErrorString( s.c_str( ) );
2647 ret = RES_DB_QUERY_ERROR;
2648 }
2649 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
2650 }else{
2651 string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in deleteMember" );
2652 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
2653 setLastErrorString( s.c_str( ) );
2654 ret = RES_ERROR;
2655 }
2656 return ret;
2657 }
2658
2659 /**
2660 *
2661 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
2662 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
2663 *
2664 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2665 * @param gid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2666 * @param uid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2667 * @param admin 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申true
2668 * @return RES_OK
2669 * @return RES_DB_NOT_INITIALIZED
2670 * @return RES_NO_SUCH_SESSION
2671 * @return RES_NO_SUCH_USER
2672 * @return RES_NO_SUCH_GROUP
2673 * @return RES_DB_QUERY_ERROR
2674 *
2675 */
2676 result_t insertMember( sessionid_t sid, groupid_t gid, userid_t uid, bool admin )
2677 {
2678 if( hdbc == NULL ) return RES_DB_NOT_INITIALIZED;
2679 if( !isValidSessionID( sid ) ) return RES_NO_SUCH_SESSION;
2680 if( !uidExists( uid ) ) return RES_NO_SUCH_USER; //uid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2681 if( !gidExists( gid ) ) return RES_NO_SUCH_GROUP; //gid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2682
2683 result_t ret = RES_ERROR;
2684 string sql;
2685 SQLHANDLE hstmt = NULL;
2686 SQLRETURN sqlcode;
2687
2688 //鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2689 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
2690 sql = "INSERT INTO " + dbprefix + "_xoonips_groups_users_link ( gid, uid, is_admin ) VALUES (";
2691 sql += string( unsignedIntToString( gid ) ) + ", ";
2692 sql += string( unsignedIntToString( uid ) ) + ", ";
2693 sql += string( admin ? "1" : "0" ) + ") ";
2694 if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
2695 SQLLEN count = 0;
2696 if( ( sqlcode = SQLRowCount( hstmt, &count ) ) == SQL_SUCCESS && count > 0 ){
2697 ret = RES_OK;
2698 }else{
2699 string s( "SQLRowCount in insertMember " );
2700 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
2701 s += string( ", sql=" ) + string( sql );
2702 setLastErrorString( s.c_str( ) );
2703 ret = RES_DB_QUERY_ERROR;
2704 }
2705 }else{
2706 string s( "SQLExecDirect in insertMember " );
2707 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
2708 s += string( ", sql=" ) + string( sql );
2709 setLastErrorString( s.c_str( ) );
2710 ret = RES_DB_QUERY_ERROR;
2711 }
2712 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
2713 }else{
2714 string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in insertMember" );
2715 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
2716 setLastErrorString( s.c_str( ) );
2717 ret = RES_ERROR;
2718 }
2719 return ret;
2720 }
2721
2722 /**
2723 *
2724 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
2725 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2726 *
2727 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2728 * @param gid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申
2729 * @param cri 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2730 * @param uids 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申UID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2731 * @param uidsLen uids鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2732 * @return RES_OK
2733 * @return RES_DB_NOT_INITIALIZED
2734 * @return RES_NO_SUCH_SESSION
2735 * @return RES_NO_SUCH_GROUP
2736 * @return RES_DB_QUERY_ERROR
2737 * @return RES_ERROR
2738 *
2739 */
2740 result_t getMembers( sessionid_t sid, groupid_t gid, criteria_t* cri, userid_t** uids, int* uidsLen )
2741 {
2742 if( hdbc == NULL ) return RES_DB_NOT_INITIALIZED;
2743 if( !isValidSessionID( sid ) ) return RES_NO_SUCH_SESSION;
2744 if( !gidExists( gid ) ) return RES_NO_SUCH_GROUP; //gid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2745
2746 result_t ret = RES_ERROR;
2747 string sql;
2748 SQLRETURN sqlcode;
2749 SQLHANDLE hstmt = NULL;
2750 userid_t* dst = 0;
2751
2752 //how many members ?
2753 sql = "SELECT COUNT(*) FROM " + dbprefix + "_xoonips_groups_users_link ";
2754 sql += " WHERE gid=" + string( unsignedIntToString( gid ) );
2755 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
2756 if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
2757 SQLUINTEGER count = 0;
2758 SQLLEN len = 0;
2759 SQLBindCol( hstmt, 1, SQL_C_ULONG, &count, 0, &len );
2760 if( ( sqlcode = SQLFetch( hstmt ) ) == SQL_SUCCESS ){
2761 dst = new userid_t[ count ];
2762 *uids = dst;
2763 *uidsLen = count;
2764 if( count > 0 ){
2765 //retrieve member's IDs
2766 SQLHANDLE hstmt2 = NULL;
2767 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt2 ) ) == SQL_SUCCESS ) {
2768 sql = "SELECT uid, gid, is_admin FROM " + dbprefix + "_xoonips_groups_users_link ";
2769 sql += " WHERE gid=" + string( unsignedIntToString( gid ) );
2770 sql += " " + string( criteria2str( cri ) );
2771 if( ( sqlcode = SQLExecDirect( hstmt2, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
2772 SQLUINTEGER uid = 0;
2773 SQLLEN len = 0;
2774 SQLBindCol( hstmt2, 1, SQL_C_ULONG, &uid, 0, &len );
2775 for( SQLUINTEGER i = 0; ( sqlcode = SQLFetch( hstmt2 ) ) == SQL_SUCCESS && i < count ; i++ ){
2776 dst[ i ] = uid;
2777 }
2778 ret = RES_OK;
2779 }else{
2780 setLastErrorString( "SQLExecDirect in getMembers" );
2781 ret = RES_DB_QUERY_ERROR;
2782 }
2783 SQLFreeHandle( SQL_HANDLE_STMT, hstmt2 );
2784 }else{
2785 string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in getMembers" );
2786 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
2787 setLastErrorString( s.c_str( ) );
2788 ret = RES_ERROR;
2789 }
2790 }else{
2791 ret = RES_OK;
2792 }
2793 }else{
2794 string s( "SQLFetch in getMembers sql=" );
2795 s += string( sql );
2796 setLastErrorString( s.c_str( ) );
2797 ret = RES_DB_QUERY_ERROR;
2798 }
2799 }else{
2800 setLastErrorString( "SQLExecDirect in getMembers" );
2801 ret = RES_DB_QUERY_ERROR;
2802 }
2803 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
2804 }else{
2805 string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in getMembers" );
2806 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
2807 setLastErrorString( s.c_str( ) );
2808 ret = RES_ERROR;
2809 }
2810 return ret;
2811 }
2812
2813 /**
2814 *
2815 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
2816 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
2817 *
2818 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2819 * @param gid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申
2820 * @return RES_OK
2821 * @return RES_DB_QUERY_ERROR
2822 * @return RES_NO_SUCH_SESSION
2823 * @return RES_DB_NOT_INITIALIZED
2824 *
2825 */
2826 result_t deleteGroup( sessionid_t sid, groupid_t gid )
2827 {
2828 if( hdbc == NULL ) return RES_DB_NOT_INITIALIZED;
2829 if( !isValidSessionID( sid ) ) return RES_NO_SUCH_SESSION;
2830
2831 result_t ret = RES_ERROR;
2832 string sql;
2833 SQLRETURN sqlcode;
2834 SQLHANDLE hstmt = NULL;
2835
2836 sql = "DELETE FROM " + dbprefix + "_xoonips_groups ";
2837 sql += "WHERE gid = " + string( unsignedIntToString( gid ) );
2838 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
2839 if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
2840 SQLLEN count = 0;
2841 if( ( sqlcode = SQLRowCount( hstmt, &count ) ) == SQL_SUCCESS && count > 0 ){
2842 ret = RES_OK;
2843 }else{
2844 string s( "SQLRowCount in deleteGroup" );
2845 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
2846 s += string( ", sql=" ) + string( sql );
2847 setLastErrorString( s.c_str( ) );
2848 ret = RES_NO_SUCH_USER;
2849 }
2850 }else{
2851 string s( "SQLExecDirect in deleteGroup" );
2852 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
2853 s += ", sql=";
2854 s += string( sql );
2855 setLastErrorString( s.c_str( ) );
2856 ret = RES_DB_QUERY_ERROR;
2857 }
2858 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
2859 }else{
2860 string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in deleteGroup" );
2861 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
2862 setLastErrorString( s.c_str( ) );
2863 ret = RES_ERROR;
2864 }
2865 return ret;
2866 }
2867
2868
2869 /**
2870 *
2871 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
2872 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2873 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申gid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2874 *
2875 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2876 * @param group 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2877 * @param gid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2878 * @return RES_OK
2879 * @return RES_DB_NOT_INITIALIZED
2880 * @return RES_NO_SUCH_SESSION
2881 * @return RES_DB_QUERY_ERROR
2882 * @return RES_GROUPNAME_ALREADY_EXISTS
2883 */
2884 result_t insertGroup( sessionid_t sid, const group_t* group, groupid_t* gid )
2885 {
2886 if( hdbc == NULL ) return RES_DB_NOT_INITIALIZED;
2887 if( !isValidSessionID( sid ) ) return RES_NO_SUCH_SESSION;
2888
2889 result_t ret = RES_ERROR;
2890 string sql;
2891