← Back to branch summary

~zulcss/samba/server-dailies-3.4

« back to all changes in this revision

Viewing changes to source3/libsmb/cliquota.c

  • Committer: Chuck Short
  • Date: 2010-09-28 20:38:39 UTC
  • Revision ID: zulcss@ubuntu.com-20100928203839-pgjulytsi9ue63x1
Initial version

Show diffs side-by-side

added added

removed removed

Lines of Context:
source3/libsmb/cliquota.c
 
1
/* 
 
2
   Unix SMB/CIFS implementation.
 
3
   client quota 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
bool cli_get_quota_handle(struct cli_state *cli, int *quota_fnum)
 
23
{
 
24
        *quota_fnum = cli_nt_create_full(cli, FAKE_FILE_NAME_QUOTA_WIN32,
 
25
                 0x00000016, DESIRED_ACCESS_PIPE,
 
26
                 0x00000000, FILE_SHARE_READ|FILE_SHARE_WRITE,
 
27
                 FILE_OPEN, 0x00000000, 0x03);
 
28
 
 
29
        if (*quota_fnum == (-1)) {
 
30
                return False;
 
31
        }
 
32
 
 
33
        return True;
 
34
}
 
35
 
 
36
void free_ntquota_list(SMB_NTQUOTA_LIST **qt_list)
 
37
{
 
38
        if (!qt_list)
 
39
                return;
 
40
 
 
41
        if ((*qt_list)->mem_ctx)
 
42
                talloc_destroy((*qt_list)->mem_ctx);
 
43
 
 
44
        (*qt_list) = NULL;
 
45
 
 
46
        return; 
 
47
}
 
48
 
 
49
static bool parse_user_quota_record(const char *rdata, unsigned int rdata_count, unsigned int *offset, SMB_NTQUOTA_STRUCT *pqt)
 
50
{
 
51
        int sid_len;
 
52
        SMB_NTQUOTA_STRUCT qt;
 
53
 
 
54
        ZERO_STRUCT(qt);
 
55
 
 
56
        if (!rdata||!offset||!pqt) {
 
57
                smb_panic("parse_quota_record: called with NULL POINTER!");
 
58
        }
 
59
 
 
60
        if (rdata_count < 40) {
 
61
                return False;
 
62
        }
 
63
 
 
64
        /* offset to next quota record.
 
65
         * 4 bytes IVAL(rdata,0)
 
66
         * unused here...
 
67
         */
 
68
        *offset = IVAL(rdata,0);
 
69
 
 
70
        /* sid len */
 
71
        sid_len = IVAL(rdata,4);
 
72
 
 
73
        if (rdata_count < 40+sid_len) {
 
74
                return False;           
 
75
        }
 
76
 
 
77
        /* unknown 8 bytes in pdata 
 
78
         * maybe its the change time in NTTIME
 
79
         */
 
80
 
 
81
        /* the used space 8 bytes (uint64_t)*/
 
82
        qt.usedspace = (uint64_t)IVAL(rdata,16);
 
83
#ifdef LARGE_SMB_OFF_T
 
84
        qt.usedspace |= (((uint64_t)IVAL(rdata,20)) << 32);
 
85
#else /* LARGE_SMB_OFF_T */
 
86
        if ((IVAL(rdata,20) != 0)&&
 
87
                ((qt.usedspace != 0xFFFFFFFF)||
 
88
                 (IVAL(rdata,20)!=0xFFFFFFFF))) {
 
89
                /* more than 32 bits? */
 
90
                return False;
 
91
        }
 
92
#endif /* LARGE_SMB_OFF_T */
 
93
 
 
94
        /* the soft quotas 8 bytes (uint64_t)*/
 
95
        qt.softlim = (uint64_t)IVAL(rdata,24);
 
96
#ifdef LARGE_SMB_OFF_T
 
97
        qt.softlim |= (((uint64_t)IVAL(rdata,28)) << 32);
 
98
#else /* LARGE_SMB_OFF_T */
 
99
        if ((IVAL(rdata,28) != 0)&&
 
100
                ((qt.softlim != 0xFFFFFFFF)||
 
101
                 (IVAL(rdata,28)!=0xFFFFFFFF))) {
 
102
                /* more than 32 bits? */
 
103
                return False;
 
104
        }
 
105
#endif /* LARGE_SMB_OFF_T */
 
106
 
 
107
        /* the hard quotas 8 bytes (uint64_t)*/
 
108
        qt.hardlim = (uint64_t)IVAL(rdata,32);
 
109
#ifdef LARGE_SMB_OFF_T
 
110
        qt.hardlim |= (((uint64_t)IVAL(rdata,36)) << 32);
 
111
#else /* LARGE_SMB_OFF_T */
 
112
        if ((IVAL(rdata,36) != 0)&&
 
113
                ((qt.hardlim != 0xFFFFFFFF)||
 
114
                 (IVAL(rdata,36)!=0xFFFFFFFF))) {
 
115
                /* more than 32 bits? */
 
116
                return False;
 
117
        }
 
118
#endif /* LARGE_SMB_OFF_T */
 
119
 
 
120
        if (!sid_parse(rdata+40,sid_len,&qt.sid)) {
 
121
                return false;
 
122
        }
 
123
 
 
124
        qt.qtype = SMB_USER_QUOTA_TYPE;
 
125
 
 
126
        *pqt = qt;
 
127
 
 
128
        return True;
 
129
}
 
130
 
 
131
bool cli_get_user_quota(struct cli_state *cli, int quota_fnum, SMB_NTQUOTA_STRUCT *pqt)
 
132
{
 
133
        bool ret = False;
 
134
        uint16 setup;
 
135
        char params[16];
 
136
        unsigned int data_len;
 
137
        char data[SID_MAX_SIZE+8];
 
138
        char *rparam=NULL, *rdata=NULL;
 
139
        unsigned int rparam_count=0, rdata_count=0;
 
140
        unsigned int sid_len;
 
141
        unsigned int offset;
 
142
 
 
143
        if (!cli||!pqt) {
 
144
                smb_panic("cli_get_user_quota() called with NULL Pointer!");
 
145
        }
 
146
 
 
147
        setup = NT_TRANSACT_GET_USER_QUOTA;
 
148
 
 
149
        SSVAL(params, 0,quota_fnum);
 
150
        SSVAL(params, 2,TRANSACT_GET_USER_QUOTA_FOR_SID);
 
151
        SIVAL(params, 4,0x00000024);
 
152
        SIVAL(params, 8,0x00000000);
 
153
        SIVAL(params,12,0x00000024);
 
154
 
 
155
        sid_len = ndr_size_dom_sid(&pqt->sid, NULL, 0);
 
156
        data_len = sid_len+8;
 
157
        SIVAL(data, 0, 0x00000000);
 
158
        SIVAL(data, 4, sid_len);
 
159
        sid_linearize(data+8, sid_len, &pqt->sid);
 
160
 
 
161
        if (!cli_send_nt_trans(cli, 
 
162
                               NT_TRANSACT_GET_USER_QUOTA, 
 
163
                               0, 
 
164
                               &setup, 1, 0,
 
165
                               params, 16, 4,
 
166
                               data, data_len, 112)) {
 
167
                DEBUG(1,("Failed to send NT_TRANSACT_GET_USER_QUOTA\n"));
 
168
                goto cleanup;
 
169
        }
 
170
 
 
171
 
 
172
        if (!cli_receive_nt_trans(cli,
 
173
                                  &rparam, &rparam_count,
 
174
                                  &rdata, &rdata_count)) {
 
175
                DEBUG(1,("Failed to recv NT_TRANSACT_GET_USER_QUOTA\n"));
 
176
                goto cleanup;
 
177
        }
 
178
 
 
179
        if (cli_is_error(cli)) {
 
180
                ret = False;
 
181
                goto cleanup;
 
182
        } else {
 
183
                ret = True;
 
184
        }
 
185
 
 
186
        if ((rparam&&rdata)&&(rparam_count>=4&&rdata_count>=8)) {
 
187
                ret = parse_user_quota_record(rdata, rdata_count, &offset, pqt);
 
188
        } else {
 
189
                DEBUG(0,("Got INVALID NT_TRANSACT_GET_USER_QUOTA reply.\n"));
 
190
                ret = False; 
 
191
        }
 
192
 
 
193
 cleanup:
 
194
        SAFE_FREE(rparam);
 
195
        SAFE_FREE(rdata); 
 
196
        return ret;
 
197
}
 
198
 
 
199
bool cli_set_user_quota(struct cli_state *cli, int quota_fnum, SMB_NTQUOTA_STRUCT *pqt)
 
200
{
 
201
        bool ret = False;
 
202
        uint16 setup;
 
203
        char params[2];
 
204
        char data[112];
 
205
        char *rparam=NULL, *rdata=NULL;
 
206
        unsigned int rparam_count=0, rdata_count=0;
 
207
        unsigned int sid_len;   
 
208
        memset(data,'\0',112);
 
209
 
 
210
        if (!cli||!pqt) {
 
211
                smb_panic("cli_set_user_quota() called with NULL Pointer!");
 
212
        }
 
213
 
 
214
        setup = NT_TRANSACT_SET_USER_QUOTA;
 
215
 
 
216
        SSVAL(params,0,quota_fnum);
 
217
 
 
218
        sid_len = ndr_size_dom_sid(&pqt->sid, NULL, 0);
 
219
        SIVAL(data,0,0);
 
220
        SIVAL(data,4,sid_len);
 
221
        SBIG_UINT(data, 8,(uint64_t)0);
 
222
        SBIG_UINT(data,16,pqt->usedspace);
 
223
        SBIG_UINT(data,24,pqt->softlim);
 
224
        SBIG_UINT(data,32,pqt->hardlim);
 
225
        sid_linearize(data+40, sid_len, &pqt->sid);
 
226
 
 
227
        if (!cli_send_nt_trans(cli, 
 
228
                               NT_TRANSACT_SET_USER_QUOTA, 
 
229
                               0, 
 
230
                               &setup, 1, 0,
 
231
                               params, 2, 0,
 
232
                               data, 112, 0)) {
 
233
                DEBUG(1,("Failed to send NT_TRANSACT_SET_USER_QUOTA\n"));
 
234
                goto cleanup;
 
235
        }
 
236
 
 
237
 
 
238
        if (!cli_receive_nt_trans(cli, 
 
239
                                  &rparam, &rparam_count,
 
240
                                  &rdata, &rdata_count)) {
 
241
                DEBUG(1,("NT_TRANSACT_SET_USER_QUOTA failed\n"));
 
242
                goto cleanup;
 
243
        }
 
244
 
 
245
        if (cli_is_error(cli)) {
 
246
                ret = False;
 
247
                goto cleanup;
 
248
        } else {
 
249
                ret = True;
 
250
        }
 
251
 
 
252
  cleanup:
 
253
        SAFE_FREE(rparam);
 
254
        SAFE_FREE(rdata);
 
255
        return ret;
 
256
}
 
257
 
 
258
bool cli_list_user_quota(struct cli_state *cli, int quota_fnum, SMB_NTQUOTA_LIST **pqt_list)
 
259
{
 
260
        bool ret = False;
 
261
        uint16 setup;
 
262
        char params[16];
 
263
        char *rparam=NULL, *rdata=NULL;
 
264
        unsigned int rparam_count=0, rdata_count=0;
 
265
        unsigned int offset;
 
266
        const char *curdata = NULL;
 
267
        unsigned int curdata_count = 0;
 
268
        TALLOC_CTX *mem_ctx = NULL;
 
269
        SMB_NTQUOTA_STRUCT qt;
 
270
        SMB_NTQUOTA_LIST *tmp_list_ent;
 
271
 
 
272
        if (!cli||!pqt_list) {
 
273
                smb_panic("cli_list_user_quota() called with NULL Pointer!");
 
274
        }
 
275
 
 
276
        setup = NT_TRANSACT_GET_USER_QUOTA;
 
277
 
 
278
        SSVAL(params, 0,quota_fnum);
 
279
        SSVAL(params, 2,TRANSACT_GET_USER_QUOTA_LIST_START);
 
280
        SIVAL(params, 4,0x00000000);
 
281
        SIVAL(params, 8,0x00000000);
 
282
        SIVAL(params,12,0x00000000);
 
283
 
 
284
        if (!cli_send_nt_trans(cli, 
 
285
                               NT_TRANSACT_GET_USER_QUOTA, 
 
286
                               0, 
 
287
                               &setup, 1, 0,
 
288
                               params, 16, 4,
 
289
                               NULL, 0, 2048)) {
 
290
                DEBUG(1,("Failed to send NT_TRANSACT_GET_USER_QUOTA\n"));
 
291
                goto cleanup;
 
292
        }
 
293
 
 
294
 
 
295
        if (!cli_receive_nt_trans(cli,
 
296
                                  &rparam, &rparam_count,
 
297
                                  &rdata, &rdata_count)) {
 
298
                DEBUG(1,("Failed to recv NT_TRANSACT_GET_USER_QUOTA\n"));
 
299
                goto cleanup;
 
300
        }
 
301
 
 
302
        if (cli_is_error(cli)) {
 
303
                ret = False;
 
304
                goto cleanup;
 
305
        } else {
 
306
                ret = True;
 
307
        }
 
308
 
 
309
        if (rdata_count == 0) {
 
310
                *pqt_list = NULL;
 
311
                return True;
 
312
        }
 
313
 
 
314
        if ((mem_ctx=talloc_init("SMB_USER_QUOTA_LIST"))==NULL) {
 
315
                DEBUG(0,("talloc_init() failed\n"));
 
316
                return (-1);
 
317
        }
 
318
 
 
319
        offset = 1;
 
320
        for (curdata=rdata,curdata_count=rdata_count;
 
321
                ((curdata)&&(curdata_count>=8)&&(offset>0));
 
322
                curdata +=offset,curdata_count -= offset) {
 
323
                ZERO_STRUCT(qt);
 
324
                if (!parse_user_quota_record(curdata, curdata_count, &offset, &qt)) {
 
325
                        DEBUG(1,("Failed to parse the quota record\n"));
 
326
                        goto cleanup;
 
327
                }
 
328
 
 
329
                if ((tmp_list_ent=TALLOC_ZERO_P(mem_ctx,SMB_NTQUOTA_LIST))==NULL) {
 
330
                        DEBUG(0,("TALLOC_ZERO() failed\n"));
 
331
                        talloc_destroy(mem_ctx);
 
332
                        return (-1);
 
333
                }
 
334
 
 
335
                if ((tmp_list_ent->quotas=TALLOC_ZERO_P(mem_ctx,SMB_NTQUOTA_STRUCT))==NULL) {
 
336
                        DEBUG(0,("TALLOC_ZERO() failed\n"));
 
337
                        talloc_destroy(mem_ctx);
 
338
                        return (-1);
 
339
                }
 
340
 
 
341
                memcpy(tmp_list_ent->quotas,&qt,sizeof(qt));
 
342
                tmp_list_ent->mem_ctx = mem_ctx;                
 
343
 
 
344
                DLIST_ADD((*pqt_list),tmp_list_ent);
 
345
        }
 
346
 
 
347
        SSVAL(params, 2,TRANSACT_GET_USER_QUOTA_LIST_CONTINUE); 
 
348
        while(1) {
 
349
                if (!cli_send_nt_trans(cli, 
 
350
                                       NT_TRANSACT_GET_USER_QUOTA, 
 
351
                                       0, 
 
352
                                       &setup, 1, 0,
 
353
                                       params, 16, 4,
 
354
                                       NULL, 0, 2048)) {
 
355
                        DEBUG(1,("Failed to send NT_TRANSACT_GET_USER_QUOTA\n"));
 
356
                        goto cleanup;
 
357
                }
 
358
 
 
359
                SAFE_FREE(rparam);
 
360
                SAFE_FREE(rdata);
 
361
                if (!cli_receive_nt_trans(cli,
 
362
                                          &rparam, &rparam_count,
 
363
                                          &rdata, &rdata_count)) {
 
364
                        DEBUG(1,("Failed to recv NT_TRANSACT_GET_USER_QUOTA\n"));
 
365
                        goto cleanup;
 
366
                }
 
367
 
 
368
                if (cli_is_error(cli)) {
 
369
                        ret = False;
 
370
                        goto cleanup;
 
371
                } else {
 
372
                        ret = True;
 
373
                }
 
374
 
 
375
                if (rdata_count == 0) {
 
376
                        break;  
 
377
                }
 
378
 
 
379
                offset = 1;
 
380
                for (curdata=rdata,curdata_count=rdata_count;
 
381
                        ((curdata)&&(curdata_count>=8)&&(offset>0));
 
382
                        curdata +=offset,curdata_count -= offset) {
 
383
                        ZERO_STRUCT(qt);
 
384
                        if (!parse_user_quota_record(curdata, curdata_count, &offset, &qt)) {
 
385
                                DEBUG(1,("Failed to parse the quota record\n"));
 
386
                                goto cleanup;
 
387
                        }
 
388
 
 
389
                        if ((tmp_list_ent=TALLOC_ZERO_P(mem_ctx,SMB_NTQUOTA_LIST))==NULL) {
 
390
                                DEBUG(0,("TALLOC_ZERO() failed\n"));
 
391
                                talloc_destroy(mem_ctx);
 
392
                                goto cleanup;
 
393
                        }
 
394
 
 
395
                        if ((tmp_list_ent->quotas=TALLOC_ZERO_P(mem_ctx,SMB_NTQUOTA_STRUCT))==NULL) {
 
396
                                DEBUG(0,("TALLOC_ZERO() failed\n"));
 
397
                                talloc_destroy(mem_ctx);
 
398
                                goto cleanup;
 
399
                        }
 
400
 
 
401
                        memcpy(tmp_list_ent->quotas,&qt,sizeof(qt));
 
402
                        tmp_list_ent->mem_ctx = mem_ctx;                
 
403
 
 
404
                        DLIST_ADD((*pqt_list),tmp_list_ent);
 
405
                }
 
406
        }
 
407
 
 
408
 
 
409
        ret = True;
 
410
 cleanup:
 
411
        SAFE_FREE(rparam);
 
412
        SAFE_FREE(rdata);
 
413
 
 
414
        return ret;
 
415
}
 
416
 
 
417
bool cli_get_fs_quota_info(struct cli_state *cli, int quota_fnum, SMB_NTQUOTA_STRUCT *pqt)
 
418
{
 
419
        bool ret = False;
 
420
        uint16 setup;
 
421
        char param[2];
 
422
        char *rparam=NULL, *rdata=NULL;
 
423
        unsigned int rparam_count=0, rdata_count=0;
 
424
        SMB_NTQUOTA_STRUCT qt;
 
425
        ZERO_STRUCT(qt);
 
426
 
 
427
        if (!cli||!pqt) {
 
428
                smb_panic("cli_get_fs_quota_info() called with NULL Pointer!");
 
429
        }
 
430
 
 
431
        setup = TRANSACT2_QFSINFO;
 
432
 
 
433
        SSVAL(param,0,SMB_FS_QUOTA_INFORMATION);
 
434
 
 
435
        if (!cli_send_trans(cli, SMBtrans2, 
 
436
                    NULL, 
 
437
                    0, 0,
 
438
                    &setup, 1, 0,
 
439
                    param, 2, 0,
 
440
                    NULL, 0, 560)) {
 
441
                goto cleanup;
 
442
        }
 
443
 
 
444
        if (!cli_receive_trans(cli, SMBtrans2,
 
445
                              &rparam, &rparam_count,
 
446
                              &rdata, &rdata_count)) {
 
447
                goto cleanup;
 
448
        }
 
449
 
 
450
        if (cli_is_error(cli)) {
 
451
                ret = False;
 
452
                goto cleanup;
 
453
        } else {
 
454
                ret = True;
 
455
        }
 
456
 
 
457
        if (rdata_count < 48) {
 
458
                goto cleanup;
 
459
        }
 
460
 
 
461
        /* unknown_1 24 NULL bytes in pdata*/
 
462
 
 
463
        /* the soft quotas 8 bytes (uint64_t)*/
 
464
        qt.softlim = (uint64_t)IVAL(rdata,24);
 
465
#ifdef LARGE_SMB_OFF_T
 
466
        qt.softlim |= (((uint64_t)IVAL(rdata,28)) << 32);
 
467
#else /* LARGE_SMB_OFF_T */
 
468
        if ((IVAL(rdata,28) != 0)&&
 
469
                ((qt.softlim != 0xFFFFFFFF)||
 
470
                 (IVAL(rdata,28)!=0xFFFFFFFF))) {
 
471
                /* more than 32 bits? */
 
472
                goto cleanup;
 
473
        }
 
474
#endif /* LARGE_SMB_OFF_T */
 
475
 
 
476
        /* the hard quotas 8 bytes (uint64_t)*/
 
477
        qt.hardlim = (uint64_t)IVAL(rdata,32);
 
478
#ifdef LARGE_SMB_OFF_T
 
479
        qt.hardlim |= (((uint64_t)IVAL(rdata,36)) << 32);
 
480
#else /* LARGE_SMB_OFF_T */
 
481
        if ((IVAL(rdata,36) != 0)&&
 
482
                ((qt.hardlim != 0xFFFFFFFF)||
 
483
                 (IVAL(rdata,36)!=0xFFFFFFFF))) {
 
484
                /* more than 32 bits? */
 
485
                goto cleanup;
 
486
        }
 
487
#endif /* LARGE_SMB_OFF_T */
 
488
 
 
489
        /* quota_flags 2 bytes **/
 
490
        qt.qflags = SVAL(rdata,40);
 
491
 
 
492
        qt.qtype = SMB_USER_FS_QUOTA_TYPE;
 
493
 
 
494
        *pqt = qt;
 
495
 
 
496
        ret = True;
 
497
cleanup:
 
498
        SAFE_FREE(rparam);
 
499
        SAFE_FREE(rdata);
 
500
 
 
501
        return ret;     
 
502
}
 
503
 
 
504
bool cli_set_fs_quota_info(struct cli_state *cli, int quota_fnum, SMB_NTQUOTA_STRUCT *pqt)
 
505
{
 
506
        bool ret = False;
 
507
        uint16 setup;
 
508
        char param[4];
 
509
        char data[48];
 
510
        char *rparam=NULL, *rdata=NULL;
 
511
        unsigned int rparam_count=0, rdata_count=0;
 
512
        SMB_NTQUOTA_STRUCT qt;
 
513
        ZERO_STRUCT(qt);
 
514
        memset(data,'\0',48);
 
515
 
 
516
        if (!cli||!pqt) {
 
517
                smb_panic("cli_set_fs_quota_info() called with NULL Pointer!");
 
518
        }
 
519
 
 
520
        setup = TRANSACT2_SETFSINFO;
 
521
 
 
522
        SSVAL(param,0,quota_fnum);
 
523
        SSVAL(param,2,SMB_FS_QUOTA_INFORMATION);
 
524
 
 
525
        /* Unknown1 24 NULL bytes*/
 
526
 
 
527
        /* Default Soft Quota 8 bytes */
 
528
        SBIG_UINT(data,24,pqt->softlim);
 
529
 
 
530
        /* Default Hard Quota 8 bytes */
 
531
        SBIG_UINT(data,32,pqt->hardlim);
 
532
 
 
533
        /* Quota flag 2 bytes */
 
534
        SSVAL(data,40,pqt->qflags);
 
535
 
 
536
        /* Unknown3 6 NULL bytes */
 
537
 
 
538
        if (!cli_send_trans(cli, SMBtrans2, 
 
539
                    NULL, 
 
540
                    0, 0,
 
541
                    &setup, 1, 0,
 
542
                    param, 4, 0,
 
543
                    data, 48, 0)) {
 
544
                goto cleanup;
 
545
        }
 
546
 
 
547
        if (!cli_receive_trans(cli, SMBtrans2,
 
548
                              &rparam, &rparam_count,
 
549
                              &rdata, &rdata_count)) {
 
550
                goto cleanup;
 
551
        }
 
552
 
 
553
        if (cli_is_error(cli)) {
 
554
                ret = False;
 
555
                goto cleanup;
 
556
        } else {
 
557
                ret = True;
 
558
        }
 
559
 
 
560
cleanup:
 
561
        SAFE_FREE(rparam);
 
562
        SAFE_FREE(rdata);
 
563
 
 
564
        return ret;     
 
565
}
 
566
 
 
567
static const char *quota_str_static(uint64_t val, bool special, bool _numeric)
 
568
{
 
569
        const char *result;
 
570
 
 
571
        if (!_numeric&&special&&(val == SMB_NTQUOTAS_NO_LIMIT)) {
 
572
                return "NO LIMIT";
 
573
        }
 
574
        result = talloc_asprintf(talloc_tos(), "%"PRIu64, val);
 
575
        SMB_ASSERT(result != NULL);
 
576
        return result;
 
577
}
 
578
 
 
579
void dump_ntquota(SMB_NTQUOTA_STRUCT *qt, bool _verbose, bool _numeric, void (*_sidtostring)(fstring str, DOM_SID *sid, bool _numeric))
 
580
{
 
581
        TALLOC_CTX *frame = talloc_stackframe();
 
582
 
 
583
        if (!qt) {
 
584
                smb_panic("dump_ntquota() called with NULL pointer");
 
585
        }
 
586
 
 
587
        switch (qt->qtype) {
 
588
                case SMB_USER_FS_QUOTA_TYPE:
 
589
                        {
 
590
                                d_printf("File System QUOTAS:\n");
 
591
                                d_printf("Limits:\n");
 
592
                                d_printf(" Default Soft Limit: %15s\n",quota_str_static(qt->softlim,True,_numeric));
 
593
                                d_printf(" Default Hard Limit: %15s\n",quota_str_static(qt->hardlim,True,_numeric));
 
594
                                d_printf("Quota Flags:\n");
 
595
                                d_printf(" Quotas Enabled: %s\n",
 
596
                                        ((qt->qflags&QUOTAS_ENABLED)||(qt->qflags&QUOTAS_DENY_DISK))?"On":"Off");
 
597
                                d_printf(" Deny Disk:      %s\n",(qt->qflags&QUOTAS_DENY_DISK)?"On":"Off");
 
598
                                d_printf(" Log Soft Limit: %s\n",(qt->qflags&QUOTAS_LOG_THRESHOLD)?"On":"Off");
 
599
                                d_printf(" Log Hard Limit: %s\n",(qt->qflags&QUOTAS_LOG_LIMIT)?"On":"Off");
 
600
                        }
 
601
                        break;
 
602
                case SMB_USER_QUOTA_TYPE:
 
603
                        {
 
604
                                fstring username_str = {0};
 
605
 
 
606
                                if (_sidtostring) {
 
607
                                        _sidtostring(username_str,&qt->sid,_numeric);
 
608
                                } else {
 
609
                                        sid_to_fstring(username_str, &qt->sid);
 
610
                                }
 
611
 
 
612
                                if (_verbose) { 
 
613
                                        d_printf("Quotas for User: %s\n",username_str);
 
614
                                        d_printf("Used Space: %15s\n",quota_str_static(qt->usedspace,False,_numeric));
 
615
                                        d_printf("Soft Limit: %15s\n",quota_str_static(qt->softlim,True,_numeric));
 
616
                                        d_printf("Hard Limit: %15s\n",quota_str_static(qt->hardlim,True,_numeric));
 
617
                                } else {
 
618
                                        d_printf("%-30s: ",username_str);
 
619
                                        d_printf("%15s/",quota_str_static(qt->usedspace,False,_numeric));
 
620
                                        d_printf("%15s/",quota_str_static(qt->softlim,True,_numeric));
 
621
                                        d_printf("%15s\n",quota_str_static(qt->hardlim,True,_numeric));
 
622
                                }
 
623
                        }
 
624
                        break;
 
625
                default:
 
626
                        d_printf("dump_ntquota() invalid qtype(%d)\n",qt->qtype);
 
627
        }
 
628
        TALLOC_FREE(frame);
 
629
        return;
 
630
}
 
631
 
 
632
void dump_ntquota_list(SMB_NTQUOTA_LIST **qtl, bool _verbose, bool _numeric, void (*_sidtostring)(fstring str, DOM_SID *sid, bool _numeric))
 
633
{
 
634
        SMB_NTQUOTA_LIST *cur;
 
635
 
 
636
        for (cur = *qtl;cur;cur = cur->next) {
 
637
                if (cur->quotas)
 
638
                        dump_ntquota(cur->quotas,_verbose,_numeric,_sidtostring);
 
639
        }       
 
640
}