source: trunk/server/source3/utils/smbcquotas.c

Last change on this file was 745, checked in by Silvan Scherrer, 13 years ago

Samba Server: updated trunk to 3.6.0
File size: 18.7 KB
RevLine 
[745]1/*
2 Unix SMB/CIFS implementation.
3 QUOTA get/set utility
4
5 Copyright (C) Andrew Tridgell 2000
6 Copyright (C) Tim Potter 2000
7 Copyright (C) Jeremy Allison 2000
8 Copyright (C) Stefan (metze) Metzmacher 2003
9
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>.
22*/
23
24#include "includes.h"
25#include "popt_common.h"
26#include "rpc_client/cli_pipe.h"
27#include "../librpc/gen_ndr/ndr_lsa.h"
28#include "rpc_client/cli_lsarpc.h"
29#include "fake_file.h"
30#include "../libcli/security/security.h"
31#include "libsmb/libsmb.h"
32
33static char *server;
34
35/* numeric is set when the user wants numeric SIDs and ACEs rather
36 than going via LSA calls to resolve them */
37static bool numeric;
38static bool verbose;
39
40enum todo_values {NOOP_QUOTA=0,FS_QUOTA,USER_QUOTA,LIST_QUOTA,SET_QUOTA};
41enum exit_values {EXIT_OK, EXIT_FAILED, EXIT_PARSE_ERROR};
42
43static struct cli_state *cli_ipc;
44static struct rpc_pipe_client *global_pipe_hnd;
45static struct policy_handle pol;
46static bool got_policy_hnd;
47static struct user_auth_info *smbcquotas_auth_info;
48
49static struct cli_state *connect_one(const char *share);
50
51/* Open cli connection and policy handle */
52
53static bool cli_open_policy_hnd(void)
54{
55 /* Initialise cli LSA connection */
56
57 if (!cli_ipc) {
58 NTSTATUS ret;
59 cli_ipc = connect_one("IPC$");
60 ret = cli_rpc_pipe_open_noauth(cli_ipc,
61 &ndr_table_lsarpc.syntax_id,
62 &global_pipe_hnd);
63 if (!NT_STATUS_IS_OK(ret)) {
64 return False;
65 }
66 }
67
68 /* Open policy handle */
69
70 if (!got_policy_hnd) {
71
72 /* Some systems don't support SEC_FLAG_MAXIMUM_ALLOWED,
73 but NT sends 0x2000000 so we might as well do it too. */
74
75 if (!NT_STATUS_IS_OK(rpccli_lsa_open_policy(global_pipe_hnd, talloc_tos(), True,
76 GENERIC_EXECUTE_ACCESS, &pol))) {
77 return False;
78 }
79
80 got_policy_hnd = True;
81 }
82
83 return True;
84}
85
86/* convert a SID to a string, either numeric or username/group */
87static void SidToString(fstring str, struct dom_sid *sid, bool _numeric)
88{
89 char **domains = NULL;
90 char **names = NULL;
91 enum lsa_SidType *types = NULL;
92
93 sid_to_fstring(str, sid);
94
95 if (_numeric) return;
96
97 /* Ask LSA to convert the sid to a name */
98
99 if (!cli_open_policy_hnd() ||
100 !NT_STATUS_IS_OK(rpccli_lsa_lookup_sids(global_pipe_hnd, talloc_tos(),
101 &pol, 1, sid, &domains,
102 &names, &types)) ||
103 !domains || !domains[0] || !names || !names[0]) {
104 return;
105 }
106
107 /* Converted OK */
108
109 slprintf(str, sizeof(fstring) - 1, "%s%s%s",
110 domains[0], lp_winbind_separator(),
111 names[0]);
112}
113
114/* convert a string to a SID, either numeric or username/group */
115static bool StringToSid(struct dom_sid *sid, const char *str)
116{
117 enum lsa_SidType *types = NULL;
118 struct dom_sid *sids = NULL;
119 bool result = True;
120
121 if (string_to_sid(sid, str)) {
122 return true;
123 }
124
125 if (!cli_open_policy_hnd() ||
126 !NT_STATUS_IS_OK(rpccli_lsa_lookup_names(global_pipe_hnd, talloc_tos(),
127 &pol, 1, &str, NULL, 1, &sids,
128 &types))) {
129 result = False;
130 goto done;
131 }
132
133 sid_copy(sid, &sids[0]);
134 done:
135
136 return result;
137}
138
139#define QUOTA_GET 1
140#define QUOTA_SETLIM 2
141#define QUOTA_SETFLAGS 3
142#define QUOTA_LIST 4
143
144enum {PARSE_FLAGS,PARSE_LIM};
145
146static int parse_quota_set(TALLOC_CTX *ctx,
147 char *set_str,
148 char **pp_username_str,
149 enum SMB_QUOTA_TYPE *qtype,
150 int *cmd,
151 SMB_NTQUOTA_STRUCT *pqt)
152{
153 char *p = set_str,*p2;
154 int todo;
155 bool stop = False;
156 bool enable = False;
157 bool deny = False;
158
159 *pp_username_str = NULL;
160 if (strnequal(set_str,"UQLIM:",6)) {
161 p += 6;
162 *qtype = SMB_USER_QUOTA_TYPE;
163 *cmd = QUOTA_SETLIM;
164 todo = PARSE_LIM;
165 if ((p2=strstr(p,":"))==NULL) {
166 return -1;
167 }
168
169 *p2 = '\0';
170 p2++;
171
172 *pp_username_str = talloc_strdup(ctx, p);
173 p = p2;
174 } else if (strnequal(set_str,"FSQLIM:",7)) {
175 p +=7;
176 *qtype = SMB_USER_FS_QUOTA_TYPE;
177 *cmd = QUOTA_SETLIM;
178 todo = PARSE_LIM;
179 } else if (strnequal(set_str,"FSQFLAGS:",9)) {
180 p +=9;
181 todo = PARSE_FLAGS;
182 *qtype = SMB_USER_FS_QUOTA_TYPE;
183 *cmd = QUOTA_SETFLAGS;
184 } else {
185 return -1;
186 }
187
188 switch (todo) {
189 case PARSE_LIM:
190 if (sscanf(p,"%"PRIu64"/%"PRIu64,&pqt->softlim,&pqt->hardlim)!=2) {
191 return -1;
192 }
193
194 break;
195 case PARSE_FLAGS:
196 while (!stop) {
197
198 if ((p2=strstr(p,"/"))==NULL) {
199 stop = True;
200 } else {
201 *p2 = '\0';
202 p2++;
203 }
204
205 if (strnequal(p,"QUOTA_ENABLED",13)) {
206 enable = True;
207 } else if (strnequal(p,"DENY_DISK",9)) {
208 deny = True;
209 } else if (strnequal(p,"LOG_SOFTLIMIT",13)) {
210 pqt->qflags |= QUOTAS_LOG_THRESHOLD;
211 } else if (strnequal(p,"LOG_HARDLIMIT",13)) {
212 pqt->qflags |= QUOTAS_LOG_LIMIT;
213 } else {
214 return -1;
215 }
216
217 p=p2;
218 }
219
220 if (deny) {
221 pqt->qflags |= QUOTAS_DENY_DISK;
222 } else if (enable) {
223 pqt->qflags |= QUOTAS_ENABLED;
224 }
225
226 break;
227 }
228
229 return 0;
230}
231
232
233static const char *quota_str_static(uint64_t val, bool special, bool _numeric)
234{
235 const char *result;
236
237 if (!_numeric&&special&&(val == SMB_NTQUOTAS_NO_LIMIT)) {
238 return "NO LIMIT";
239 }
240 result = talloc_asprintf(talloc_tos(), "%"PRIu64, val);
241 SMB_ASSERT(result != NULL);
242 return result;
243}
244
245static void dump_ntquota(SMB_NTQUOTA_STRUCT *qt, bool _verbose,
246 bool _numeric,
247 void (*_sidtostring)(fstring str,
248 struct dom_sid *sid,
249 bool _numeric))
250{
251 TALLOC_CTX *frame = talloc_stackframe();
252
253 if (!qt) {
254 smb_panic("dump_ntquota() called with NULL pointer");
255 }
256
257 switch (qt->qtype) {
258 case SMB_USER_FS_QUOTA_TYPE:
259 {
260 d_printf("File System QUOTAS:\n");
261 d_printf("Limits:\n");
262 d_printf(" Default Soft Limit: %15s\n",
263 quota_str_static(qt->softlim,True,_numeric));
264 d_printf(" Default Hard Limit: %15s\n",
265 quota_str_static(qt->hardlim,True,_numeric));
266 d_printf("Quota Flags:\n");
267 d_printf(" Quotas Enabled: %s\n",
268 ((qt->qflags&QUOTAS_ENABLED)
269 ||(qt->qflags&QUOTAS_DENY_DISK))?"On":"Off");
270 d_printf(" Deny Disk: %s\n",
271 (qt->qflags&QUOTAS_DENY_DISK)?"On":"Off");
272 d_printf(" Log Soft Limit: %s\n",
273 (qt->qflags&QUOTAS_LOG_THRESHOLD)?"On":"Off");
274 d_printf(" Log Hard Limit: %s\n",
275 (qt->qflags&QUOTAS_LOG_LIMIT)?"On":"Off");
276 }
277 break;
278 case SMB_USER_QUOTA_TYPE:
279 {
280 fstring username_str = {0};
281
282 if (_sidtostring) {
283 _sidtostring(username_str,&qt->sid,_numeric);
284 } else {
285 sid_to_fstring(username_str, &qt->sid);
286 }
287
288 if (_verbose) {
289 d_printf("Quotas for User: %s\n",username_str);
290 d_printf("Used Space: %15s\n",
291 quota_str_static(qt->usedspace,False,
292 _numeric));
293 d_printf("Soft Limit: %15s\n",
294 quota_str_static(qt->softlim,True,
295 _numeric));
296 d_printf("Hard Limit: %15s\n",
297 quota_str_static(qt->hardlim,True,_numeric));
298 } else {
299 d_printf("%-30s: ",username_str);
300 d_printf("%15s/",quota_str_static(
301 qt->usedspace,False,_numeric));
302 d_printf("%15s/",quota_str_static(
303 qt->softlim,True,_numeric));
304 d_printf("%15s\n",quota_str_static(
305 qt->hardlim,True,_numeric));
306 }
307 }
308 break;
309 default:
310 d_printf("dump_ntquota() invalid qtype(%d)\n",qt->qtype);
311 }
312 TALLOC_FREE(frame);
313 return;
314}
315
316static void dump_ntquota_list(SMB_NTQUOTA_LIST **qtl, bool _verbose,
317 bool _numeric,
318 void (*_sidtostring)(fstring str,
319 struct dom_sid *sid,
320 bool _numeric))
321{
322 SMB_NTQUOTA_LIST *cur;
323
324 for (cur = *qtl;cur;cur = cur->next) {
325 if (cur->quotas)
326 dump_ntquota(cur->quotas,_verbose,_numeric,
327 _sidtostring);
328 }
329}
330
331static int do_quota(struct cli_state *cli,
332 enum SMB_QUOTA_TYPE qtype,
333 uint16 cmd,
334 const char *username_str,
335 SMB_NTQUOTA_STRUCT *pqt)
336{
337 uint32 fs_attrs = 0;
338 uint16_t quota_fnum = 0;
339 SMB_NTQUOTA_LIST *qtl = NULL;
340 SMB_NTQUOTA_STRUCT qt;
341 NTSTATUS status;
342
343 ZERO_STRUCT(qt);
344
345 status = cli_get_fs_attr_info(cli, &fs_attrs);
346 if (!NT_STATUS_IS_OK(status)) {
347 d_printf("Failed to get the filesystem attributes %s.\n",
348 nt_errstr(status));
349 return -1;
350 }
351
352 if (!(fs_attrs & FILE_VOLUME_QUOTAS)) {
353 d_printf("Quotas are not supported by the server.\n");
354 return 0;
355 }
356
357 status = cli_get_quota_handle(cli, &quota_fnum);
358 if (!NT_STATUS_IS_OK(status)) {
359 d_printf("Quotas are not enabled on this share.\n");
360 d_printf("Failed to open %s %s.\n",
361 FAKE_FILE_NAME_QUOTA_WIN32,
362 nt_errstr(status));
363 return -1;
364 }
365
366 switch(qtype) {
367 case SMB_USER_QUOTA_TYPE:
368 if (!StringToSid(&qt.sid, username_str)) {
369 d_printf("StringToSid() failed for [%s]\n",username_str);
370 return -1;
371 }
372
373 switch(cmd) {
374 case QUOTA_GET:
375 status = cli_get_user_quota(
376 cli, quota_fnum, &qt);
377 if (!NT_STATUS_IS_OK(status)) {
378 d_printf("%s cli_get_user_quota %s\n",
379 nt_errstr(status),
380 username_str);
381 return -1;
382 }
383 dump_ntquota(&qt,verbose,numeric,SidToString);
384 break;
385 case QUOTA_SETLIM:
386 pqt->sid = qt.sid;
387 status = cli_set_user_quota(
388 cli, quota_fnum, pqt);
389 if (!NT_STATUS_IS_OK(status)) {
390 d_printf("%s cli_set_user_quota %s\n",
391 nt_errstr(status),
392 username_str);
393 return -1;
394 }
395 status = cli_get_user_quota(
396 cli, quota_fnum, &qt);
397 if (!NT_STATUS_IS_OK(status)) {
398 d_printf("%s cli_get_user_quota %s\n",
399 nt_errstr(status),
400 username_str);
401 return -1;
402 }
403 dump_ntquota(&qt,verbose,numeric,SidToString);
404 break;
405 case QUOTA_LIST:
406 status = cli_list_user_quota(
407 cli, quota_fnum, &qtl);
408 if (!NT_STATUS_IS_OK(status)) {
409 d_printf("%s cli_set_user_quota %s\n",
410 nt_errstr(status),
411 username_str);
412 return -1;
413 }
414 dump_ntquota_list(&qtl,verbose,numeric,SidToString);
415 free_ntquota_list(&qtl);
416 break;
417 default:
418 d_printf("Unknown Error\n");
419 return -1;
420 }
421 break;
422 case SMB_USER_FS_QUOTA_TYPE:
423 switch(cmd) {
424 case QUOTA_GET:
425 status = cli_get_fs_quota_info(
426 cli, quota_fnum, &qt);
427 if (!NT_STATUS_IS_OK(status)) {
428 d_printf("%s cli_get_fs_quota_info\n",
429 nt_errstr(status));
430 return -1;
431 }
432 dump_ntquota(&qt,True,numeric,NULL);
433 break;
434 case QUOTA_SETLIM:
435 status = cli_get_fs_quota_info(
436 cli, quota_fnum, &qt);
437 if (!NT_STATUS_IS_OK(status)) {
438 d_printf("%s cli_get_fs_quota_info\n",
439 nt_errstr(status));
440 return -1;
441 }
442 qt.softlim = pqt->softlim;
443 qt.hardlim = pqt->hardlim;
444 status = cli_set_fs_quota_info(
445 cli, quota_fnum, &qt);
446 if (!NT_STATUS_IS_OK(status)) {
447 d_printf("%s cli_set_fs_quota_info\n",
448 nt_errstr(status));
449 return -1;
450 }
451 status = cli_get_fs_quota_info(
452 cli, quota_fnum, &qt);
453 if (!NT_STATUS_IS_OK(status)) {
454 d_printf("%s cli_get_fs_quota_info\n",
455 nt_errstr(status));
456 return -1;
457 }
458 dump_ntquota(&qt,True,numeric,NULL);
459 break;
460 case QUOTA_SETFLAGS:
461 status = cli_get_fs_quota_info(
462 cli, quota_fnum, &qt);
463 if (!NT_STATUS_IS_OK(status)) {
464 d_printf("%s cli_get_fs_quota_info\n",
465 nt_errstr(status));
466 return -1;
467 }
468 qt.qflags = pqt->qflags;
469 status = cli_set_fs_quota_info(
470 cli, quota_fnum, &qt);
471 if (!NT_STATUS_IS_OK(status)) {
472 d_printf("%s cli_set_fs_quota_info\n",
473 nt_errstr(status));
474 return -1;
475 }
476 status = cli_get_fs_quota_info(
477 cli, quota_fnum, &qt);
478 if (!NT_STATUS_IS_OK(status)) {
479 d_printf("%s cli_get_fs_quota_info\n",
480 nt_errstr(status));
481 return -1;
482 }
483 dump_ntquota(&qt,True,numeric,NULL);
484 break;
485 default:
486 d_printf("Unknown Error\n");
487 return -1;
488 }
489 break;
490 default:
491 d_printf("Unknown Error\n");
492 return -1;
493 }
494
495 cli_close(cli, quota_fnum);
496
497 return 0;
498}
499
500/*****************************************************
501 Return a connection to a server.
502*******************************************************/
503
504static struct cli_state *connect_one(const char *share)
505{
506 struct cli_state *c;
507 struct sockaddr_storage ss;
508 NTSTATUS nt_status;
509 uint32_t flags = 0;
510
511 zero_sockaddr(&ss);
512
513 if (get_cmdline_auth_info_use_machine_account(smbcquotas_auth_info) &&
514 !set_cmdline_auth_info_machine_account_creds(smbcquotas_auth_info)) {
515 return NULL;
516 }
517
518 if (get_cmdline_auth_info_use_kerberos(smbcquotas_auth_info)) {
519 flags |= CLI_FULL_CONNECTION_USE_KERBEROS |
520 CLI_FULL_CONNECTION_FALLBACK_AFTER_KERBEROS;
521
522 }
523
524 set_cmdline_auth_info_getpass(smbcquotas_auth_info);
525
526 nt_status = cli_full_connection(&c, global_myname(), server,
527 &ss, 0,
528 share, "?????",
529 get_cmdline_auth_info_username(smbcquotas_auth_info),
530 lp_workgroup(),
531 get_cmdline_auth_info_password(smbcquotas_auth_info),
532 flags,
533 get_cmdline_auth_info_signing_state(smbcquotas_auth_info));
534 if (!NT_STATUS_IS_OK(nt_status)) {
535 DEBUG(0,("cli_full_connection failed! (%s)\n", nt_errstr(nt_status)));
536 return NULL;
537 }
538
539 if (get_cmdline_auth_info_smb_encrypt(smbcquotas_auth_info)) {
540 nt_status = cli_cm_force_encryption(c,
541 get_cmdline_auth_info_username(smbcquotas_auth_info),
542 get_cmdline_auth_info_password(smbcquotas_auth_info),
543 lp_workgroup(),
544 share);
545 if (!NT_STATUS_IS_OK(nt_status)) {
546 cli_shutdown(c);
547 return NULL;
548 }
549 }
550
551 return c;
552}
553
554/****************************************************************************
555 main program
556****************************************************************************/
557 int main(int argc, const char *argv[])
558{
559 char *share;
560 int opt;
561 int result;
562 int todo = 0;
563 char *username_str = NULL;
564 char *path = NULL;
565 char *set_str = NULL;
566 enum SMB_QUOTA_TYPE qtype = SMB_INVALID_QUOTA_TYPE;
567 int cmd = 0;
568 static bool test_args = False;
569 struct cli_state *cli;
570 bool fix_user = False;
571 SMB_NTQUOTA_STRUCT qt;
572 TALLOC_CTX *frame = talloc_stackframe();
573 poptContext pc;
574 struct poptOption long_options[] = {
575 POPT_AUTOHELP
576 { "user", 'u', POPT_ARG_STRING, NULL, 'u', "Show quotas for user", "user" },
577 { "list", 'L', POPT_ARG_NONE, NULL, 'L', "List user quotas" },
578 { "fs", 'F', POPT_ARG_NONE, NULL, 'F', "Show filesystem quotas" },
579 { "set", 'S', POPT_ARG_STRING, NULL, 'S', "Set acls\n\
580SETSTRING:\n\
581UQLIM:<username>/<softlimit>/<hardlimit> for user quotas\n\
582FSQLIM:<softlimit>/<hardlimit> for filesystem defaults\n\
583FSQFLAGS:QUOTA_ENABLED/DENY_DISK/LOG_SOFTLIMIT/LOG_HARD_LIMIT", "SETSTRING" },
584 { "numeric", 'n', POPT_ARG_NONE, NULL, 'n', "Don't resolve sids or limits to names" },
585 { "verbose", 'v', POPT_ARG_NONE, NULL, 'v', "be verbose" },
586 { "test-args", 't', POPT_ARG_NONE, NULL, 'r', "Test arguments"},
587 POPT_COMMON_SAMBA
588 POPT_COMMON_CREDENTIALS
589 { NULL }
590 };
591
592 load_case_tables();
593
594 ZERO_STRUCT(qt);
595
596 /* set default debug level to 1 regardless of what smb.conf sets */
597 setup_logging( "smbcquotas", DEBUG_STDERR);
598 lp_set_cmdline("log level", "1");
599
600 setlinebuf(stdout);
601
602 fault_setup(NULL);
603
604 lp_load(get_dyn_CONFIGFILE(),True,False,False,True);
605 load_interfaces();
606
607 smbcquotas_auth_info = user_auth_info_init(frame);
608 if (smbcquotas_auth_info == NULL) {
609 exit(1);
610 }
611 popt_common_set_auth_info(smbcquotas_auth_info);
612
613 pc = poptGetContext("smbcquotas", argc, argv, long_options, 0);
614
615 poptSetOtherOptionHelp(pc, "//server1/share1");
616
617 while ((opt = poptGetNextOpt(pc)) != -1) {
618 switch (opt) {
619 case 'n':
620 numeric = true;
621 break;
622 case 'v':
623 verbose = true;
624 break;
625 case 't':
626 test_args = true;
627 break;
628 case 'L':
629 if (todo != 0) {
630 d_printf("Please specify only one option of <-L|-F|-S|-u>\n");
631 exit(EXIT_PARSE_ERROR);
632 }
633 todo = LIST_QUOTA;
634 break;
635
636 case 'F':
637 if (todo != 0) {
638 d_printf("Please specify only one option of <-L|-F|-S|-u>\n");
639 exit(EXIT_PARSE_ERROR);
640 }
641 todo = FS_QUOTA;
642 break;
643
644 case 'u':
645 if (todo != 0) {
646 d_printf("Please specify only one option of <-L|-F|-S|-u>\n");
647 exit(EXIT_PARSE_ERROR);
648 }
649 username_str = talloc_strdup(frame, poptGetOptArg(pc));
650 if (!username_str) {
651 exit(EXIT_PARSE_ERROR);
652 }
653 todo = USER_QUOTA;
654 fix_user = True;
655 break;
656
657 case 'S':
658 if (todo != 0) {
659 d_printf("Please specify only one option of <-L|-F|-S|-u>\n");
660 exit(EXIT_PARSE_ERROR);
661 }
662 set_str = talloc_strdup(frame, poptGetOptArg(pc));
663 if (!set_str) {
664 exit(EXIT_PARSE_ERROR);
665 }
666 todo = SET_QUOTA;
667 break;
668 }
669 }
670
671 if (todo == 0)
672 todo = USER_QUOTA;
673
674 if (!fix_user) {
675 username_str = talloc_strdup(
676 frame, get_cmdline_auth_info_username(smbcquotas_auth_info));
677 if (!username_str) {
678 exit(EXIT_PARSE_ERROR);
679 }
680 }
681
682 /* Make connection to server */
683 if(!poptPeekArg(pc)) {
684 poptPrintUsage(pc, stderr, 0);
685 exit(EXIT_PARSE_ERROR);
686 }
687
688 path = talloc_strdup(frame, poptGetArg(pc));
689 if (!path) {
690 printf("Out of memory\n");
691 exit(EXIT_PARSE_ERROR);
692 }
693
694 string_replace(path, '/', '\\');
695
696 server = SMB_STRDUP(path+2);
697 if (!server) {
698 printf("Out of memory\n");
699 exit(EXIT_PARSE_ERROR);
700 }
701 share = strchr_m(server,'\\');
702 if (!share) {
703 printf("Invalid argument: %s\n", share);
704 exit(EXIT_PARSE_ERROR);
705 }
706
707 *share = 0;
708 share++;
709
710 if (todo == SET_QUOTA) {
711 if (parse_quota_set(talloc_tos(), set_str, &username_str, &qtype, &cmd, &qt)) {
712 printf("Invalid argument: -S %s\n", set_str);
713 exit(EXIT_PARSE_ERROR);
714 }
715 }
716
717 if (!test_args) {
718 cli = connect_one(share);
719 if (!cli) {
720 exit(EXIT_FAILED);
721 }
722 } else {
723 exit(EXIT_OK);
724 }
725
726
727 /* Perform requested action */
728
729 switch (todo) {
730 case FS_QUOTA:
731 result = do_quota(cli,SMB_USER_FS_QUOTA_TYPE, QUOTA_GET, username_str, NULL);
732 break;
733 case LIST_QUOTA:
734 result = do_quota(cli,SMB_USER_QUOTA_TYPE, QUOTA_LIST, username_str, NULL);
735 break;
736 case USER_QUOTA:
737 result = do_quota(cli,SMB_USER_QUOTA_TYPE, QUOTA_GET, username_str, NULL);
738 break;
739 case SET_QUOTA:
740 result = do_quota(cli, qtype, cmd, username_str, &qt);
741 break;
742 default:
743 result = EXIT_FAILED;
744 break;
745 }
746
747 talloc_free(frame);
748
749 return result;
750}
Note: See TracBrowser for help on using the repository browser.