RIP BOOL. Convert BOOL -> bool. I found a few interesting
[nivanova/samba-autobuild/.git] / source3 / libsmb / clifsinfo.c
1 /* 
2    Unix SMB/CIFS implementation.
3    FS info functions
4    Copyright (C) Stefan (metze) Metzmacher      2003
5    
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 3 of the License, or
9    (at your option) any later version.
10    
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15    
16    You should have received a copy of the GNU General Public License
17    along with this program.  If not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include "includes.h"
21
22 /****************************************************************************
23  Get UNIX extensions version info.
24 ****************************************************************************/
25                                                                                                                    
26 bool cli_unix_extensions_version(struct cli_state *cli, uint16 *pmajor, uint16 *pminor,
27                                         uint32 *pcaplow, uint32 *pcaphigh)
28 {
29         bool ret = False;
30         uint16 setup;
31         char param[2];
32         char *rparam=NULL, *rdata=NULL;
33         unsigned int rparam_count=0, rdata_count=0;
34
35         setup = TRANSACT2_QFSINFO;
36         
37         SSVAL(param,0,SMB_QUERY_CIFS_UNIX_INFO);
38
39         if (!cli_send_trans(cli, SMBtrans2, 
40                     NULL, 
41                     0, 0,
42                     &setup, 1, 0,
43                     param, 2, 0,
44                     NULL, 0, 560)) {
45                 goto cleanup;
46         }
47         
48         if (!cli_receive_trans(cli, SMBtrans2,
49                               &rparam, &rparam_count,
50                               &rdata, &rdata_count)) {
51                 goto cleanup;
52         }
53
54         if (cli_is_error(cli)) {
55                 ret = False;
56                 goto cleanup;
57         } else {
58                 ret = True;
59         }
60
61         if (rdata_count < 12) {
62                 goto cleanup;
63         }
64
65         *pmajor = SVAL(rdata,0);
66         *pminor = SVAL(rdata,2);
67         cli->posix_capabilities = *pcaplow = IVAL(rdata,4);
68         *pcaphigh = IVAL(rdata,8);
69
70         /* todo: but not yet needed 
71          *       return the other stuff
72          */
73
74 cleanup:
75         SAFE_FREE(rparam);
76         SAFE_FREE(rdata);
77
78         return ret;     
79 }
80
81 /****************************************************************************
82  Set UNIX extensions capabilities.
83 ****************************************************************************/
84                                                                                                                    
85 bool cli_set_unix_extensions_capabilities(struct cli_state *cli, uint16 major, uint16 minor,
86                                         uint32 caplow, uint32 caphigh)
87 {
88         bool ret = False;
89         uint16 setup;
90         char param[4];
91         char data[12];
92         char *rparam=NULL, *rdata=NULL;
93         unsigned int rparam_count=0, rdata_count=0;
94
95         setup = TRANSACT2_SETFSINFO;
96         
97         SSVAL(param,0,0);
98         SSVAL(param,2,SMB_SET_CIFS_UNIX_INFO);
99
100         SSVAL(data,0,major);
101         SSVAL(data,2,minor);
102         SIVAL(data,4,caplow);
103         SIVAL(data,8,caphigh);
104
105         if (!cli_send_trans(cli, SMBtrans2, 
106                     NULL, 
107                     0, 0,
108                     &setup, 1, 0,
109                     param, 4, 0,
110                     data, 12, 560)) {
111                 goto cleanup;
112         }
113         
114         if (!cli_receive_trans(cli, SMBtrans2,
115                               &rparam, &rparam_count,
116                               &rdata, &rdata_count)) {
117                 goto cleanup;
118         }
119
120         if (cli_is_error(cli)) {
121                 ret = False;
122                 goto cleanup;
123         } else {
124                 ret = True;
125         }
126
127 cleanup:
128         SAFE_FREE(rparam);
129         SAFE_FREE(rdata);
130
131         return ret;     
132 }
133
134 bool cli_get_fs_attr_info(struct cli_state *cli, uint32 *fs_attr)
135 {
136         bool ret = False;
137         uint16 setup;
138         char param[2];
139         char *rparam=NULL, *rdata=NULL;
140         unsigned int rparam_count=0, rdata_count=0;
141
142         if (!cli||!fs_attr)
143                 smb_panic("cli_get_fs_attr_info() called with NULL Pionter!");
144
145         setup = TRANSACT2_QFSINFO;
146         
147         SSVAL(param,0,SMB_QUERY_FS_ATTRIBUTE_INFO);
148
149         if (!cli_send_trans(cli, SMBtrans2, 
150                     NULL, 
151                     0, 0,
152                     &setup, 1, 0,
153                     param, 2, 0,
154                     NULL, 0, 560)) {
155                 goto cleanup;
156         }
157         
158         if (!cli_receive_trans(cli, SMBtrans2,
159                               &rparam, &rparam_count,
160                               &rdata, &rdata_count)) {
161                 goto cleanup;
162         }
163
164         if (cli_is_error(cli)) {
165                 ret = False;
166                 goto cleanup;
167         } else {
168                 ret = True;
169         }
170
171         if (rdata_count < 12) {
172                 goto cleanup;
173         }
174
175         *fs_attr = IVAL(rdata,0);
176
177         /* todo: but not yet needed 
178          *       return the other stuff
179          */
180
181 cleanup:
182         SAFE_FREE(rparam);
183         SAFE_FREE(rdata);
184
185         return ret;     
186 }
187
188 bool cli_get_fs_volume_info_old(struct cli_state *cli, fstring volume_name, uint32 *pserial_number)
189 {
190         bool ret = False;
191         uint16 setup;
192         char param[2];
193         char *rparam=NULL, *rdata=NULL;
194         unsigned int rparam_count=0, rdata_count=0;
195         unsigned char nlen;
196
197         setup = TRANSACT2_QFSINFO;
198         
199         SSVAL(param,0,SMB_INFO_VOLUME);
200
201         if (!cli_send_trans(cli, SMBtrans2, 
202                     NULL, 
203                     0, 0,
204                     &setup, 1, 0,
205                     param, 2, 0,
206                     NULL, 0, 560)) {
207                 goto cleanup;
208         }
209         
210         if (!cli_receive_trans(cli, SMBtrans2,
211                               &rparam, &rparam_count,
212                               &rdata, &rdata_count)) {
213                 goto cleanup;
214         }
215
216         if (cli_is_error(cli)) {
217                 ret = False;
218                 goto cleanup;
219         } else {
220                 ret = True;
221         }
222
223         if (rdata_count < 5) {
224                 goto cleanup;
225         }
226
227         if (pserial_number) {
228                 *pserial_number = IVAL(rdata,0);
229         }
230         nlen = CVAL(rdata,l2_vol_cch);
231         clistr_pull(cli, volume_name, rdata + l2_vol_szVolLabel, sizeof(fstring), nlen, STR_NOALIGN);
232
233         /* todo: but not yet needed 
234          *       return the other stuff
235          */
236
237 cleanup:
238         SAFE_FREE(rparam);
239         SAFE_FREE(rdata);
240
241         return ret;     
242 }
243
244 bool cli_get_fs_volume_info(struct cli_state *cli, fstring volume_name, uint32 *pserial_number, time_t *pdate)
245 {
246         bool ret = False;
247         uint16 setup;
248         char param[2];
249         char *rparam=NULL, *rdata=NULL;
250         unsigned int rparam_count=0, rdata_count=0;
251         unsigned int nlen;
252
253         setup = TRANSACT2_QFSINFO;
254         
255         SSVAL(param,0,SMB_QUERY_FS_VOLUME_INFO);
256
257         if (!cli_send_trans(cli, SMBtrans2, 
258                     NULL, 
259                     0, 0,
260                     &setup, 1, 0,
261                     param, 2, 0,
262                     NULL, 0, 560)) {
263                 goto cleanup;
264         }
265         
266         if (!cli_receive_trans(cli, SMBtrans2,
267                               &rparam, &rparam_count,
268                               &rdata, &rdata_count)) {
269                 goto cleanup;
270         }
271
272         if (cli_is_error(cli)) {
273                 ret = False;
274                 goto cleanup;
275         } else {
276                 ret = True;
277         }
278
279         if (rdata_count < 19) {
280                 goto cleanup;
281         }
282
283         if (pdate) {
284                 struct timespec ts;
285                 ts = interpret_long_date(rdata);
286                 *pdate = ts.tv_sec;
287         }
288         if (pserial_number) {
289                 *pserial_number = IVAL(rdata,8);
290         }
291         nlen = IVAL(rdata,12);
292         clistr_pull(cli, volume_name, rdata + 18, sizeof(fstring), nlen, STR_UNICODE);
293
294         /* todo: but not yet needed 
295          *       return the other stuff
296          */
297
298 cleanup:
299         SAFE_FREE(rparam);
300         SAFE_FREE(rdata);
301
302         return ret;     
303 }