source: vendor/current/source3/utils/smbcquotas.c

Last change on this file was 989, checked in by Silvan Scherrer, 9 years ago

Samba Server: update vendor to version 4.4.7
File size: 18.2 KB
Line 
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,
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,"%"SCNu64"/%"SCNu64,&pqt->softlim,
191 &pqt->hardlim) != 2)
192 {
193 return -1;
194 }
195
196 break;
197 case PARSE_FLAGS:
198 while (!stop) {
199
200 if ((p2=strstr(p,"/"))==NULL) {
201 stop = True;
202 } else {
203 *p2 = '\0';
204 p2++;
205 }
206
207 if (strnequal(p,"QUOTA_ENABLED",13)) {
208 enable = True;
209 } else if (strnequal(p,"DENY_DISK",9)) {
210 deny = True;
211 } else if (strnequal(p,"LOG_SOFTLIMIT",13)) {
212 pqt->qflags |= QUOTAS_LOG_THRESHOLD;
213 } else if (strnequal(p,"LOG_HARDLIMIT",13)) {
214 pqt->qflags |= QUOTAS_LOG_LIMIT;
215 } else {
216 return -1;
217 }
218
219 p=p2;
220 }
221
222 if (deny) {
223 pqt->qflags |= QUOTAS_DENY_DISK;
224 } else if (enable) {
225 pqt->qflags |= QUOTAS_ENABLED;
226 }
227
228 break;
229 }
230
231 return 0;
232}
233
234
235static const char *quota_str_static(uint64_t val, bool special, bool _numeric)
236{
237 const char *result;
238
239 if (!_numeric && special && val == 0) {
240 return "NO LIMIT";
241 }
242 result = talloc_asprintf(talloc_tos(), "%"PRIu64, val);
243 SMB_ASSERT(result != NULL);
244 return result;
245}
246
247static void dump_ntquota(SMB_NTQUOTA_STRUCT *qt, bool _verbose,
248 bool _numeric,
249 void (*_sidtostring)(fstring str,
250 struct dom_sid *sid,
251 bool _numeric))
252{
253 TALLOC_CTX *frame = talloc_stackframe();
254
255 if (!qt) {
256 smb_panic("dump_ntquota() called with NULL pointer");
257 }
258
259 switch (qt->qtype) {
260 case SMB_USER_FS_QUOTA_TYPE:
261 {
262 d_printf("File System QUOTAS:\n");
263 d_printf("Limits:\n");
264 d_printf(" Default Soft Limit: %15s\n",
265 quota_str_static(qt->softlim,True,_numeric));
266 d_printf(" Default Hard Limit: %15s\n",
267 quota_str_static(qt->hardlim,True,_numeric));
268 d_printf("Quota Flags:\n");
269 d_printf(" Quotas Enabled: %s\n",
270 ((qt->qflags&QUOTAS_ENABLED)
271 ||(qt->qflags&QUOTAS_DENY_DISK))?"On":"Off");
272 d_printf(" Deny Disk: %s\n",
273 (qt->qflags&QUOTAS_DENY_DISK)?"On":"Off");
274 d_printf(" Log Soft Limit: %s\n",
275 (qt->qflags&QUOTAS_LOG_THRESHOLD)?"On":"Off");
276 d_printf(" Log Hard Limit: %s\n",
277 (qt->qflags&QUOTAS_LOG_LIMIT)?"On":"Off");
278 }
279 break;
280 case SMB_USER_QUOTA_TYPE:
281 {
282 fstring username_str = {0};
283
284 if (_sidtostring) {
285 _sidtostring(username_str,&qt->sid,_numeric);
286 } else {
287 sid_to_fstring(username_str, &qt->sid);
288 }
289
290 if (_verbose) {
291 d_printf("Quotas for User: %s\n",username_str);
292 d_printf("Used Space: %15s\n",
293 quota_str_static(qt->usedspace,False,
294 _numeric));
295 d_printf("Soft Limit: %15s\n",
296 quota_str_static(qt->softlim,True,
297 _numeric));
298 d_printf("Hard Limit: %15s\n",
299 quota_str_static(qt->hardlim,True,_numeric));
300 } else {
301 d_printf("%-30s: ",username_str);
302 d_printf("%15s/",quota_str_static(
303 qt->usedspace,False,_numeric));
304 d_printf("%15s/",quota_str_static(
305 qt->softlim,True,_numeric));
306 d_printf("%15s\n",quota_str_static(
307 qt->hardlim,True,_numeric));
308 }
309 }
310 break;
311 default:
312 d_printf("dump_ntquota() invalid qtype(%d)\n",qt->qtype);
313 }
314 TALLOC_FREE(frame);
315 return;
316}
317
318static void dump_ntquota_list(SMB_NTQUOTA_LIST **qtl, bool _verbose,
319 bool _numeric,
320 void (*_sidtostring)(fstring str,
321 struct dom_sid *sid,
322 bool _numeric))
323{
324 SMB_NTQUOTA_LIST *cur;
325
326 for (cur = *qtl;cur;cur = cur->next) {
327 if (cur->quotas)
328 dump_ntquota(cur->quotas,_verbose,_numeric,
329 _sidtostring);
330 }
331}
332
333static int do_quota(struct cli_state *cli,
334 enum SMB_QUOTA_TYPE qtype,
335 uint16_t cmd,
336 const char *username_str,
337 SMB_NTQUOTA_STRUCT *pqt)
338{
339 uint32_t fs_attrs = 0;
340 uint16_t quota_fnum = 0;
341 SMB_NTQUOTA_LIST *qtl = NULL;
342 SMB_NTQUOTA_STRUCT qt;
343 NTSTATUS status;
344
345 ZERO_STRUCT(qt);
346
347 status = cli_get_fs_attr_info(cli, &fs_attrs);
348 if (!NT_STATUS_IS_OK(status)) {
349 d_printf("Failed to get the filesystem attributes %s.\n",
350 nt_errstr(status));
351 return -1;
352 }
353
354 if (!(fs_attrs & FILE_VOLUME_QUOTAS)) {
355 d_printf("Quotas are not supported by the server.\n");
356 return 0;
357 }
358
359 status = cli_get_quota_handle(cli, &quota_fnum);
360 if (!NT_STATUS_IS_OK(status)) {
361 d_printf("Quotas are not enabled on this share.\n");
362 d_printf("Failed to open %s %s.\n",
363 FAKE_FILE_NAME_QUOTA_WIN32,
364 nt_errstr(status));
365 return -1;
366 }
367
368 switch(qtype) {
369 case SMB_USER_QUOTA_TYPE:
370 if (!StringToSid(&qt.sid, username_str)) {
371 d_printf("StringToSid() failed for [%s]\n",username_str);
372 return -1;
373 }
374
375 switch(cmd) {
376 case QUOTA_GET:
377 status = cli_get_user_quota(
378 cli, quota_fnum, &qt);
379 if (!NT_STATUS_IS_OK(status)) {
380 d_printf("%s cli_get_user_quota %s\n",
381 nt_errstr(status),
382 username_str);
383 return -1;
384 }
385 dump_ntquota(&qt,verbose,numeric,SidToString);
386 break;
387 case QUOTA_SETLIM:
388 pqt->sid = qt.sid;
389 status = cli_set_user_quota(
390 cli, quota_fnum, pqt);
391 if (!NT_STATUS_IS_OK(status)) {
392 d_printf("%s cli_set_user_quota %s\n",
393 nt_errstr(status),
394 username_str);
395 return -1;
396 }
397 status = cli_get_user_quota(
398 cli, quota_fnum, &qt);
399 if (!NT_STATUS_IS_OK(status)) {
400 d_printf("%s cli_get_user_quota %s\n",
401 nt_errstr(status),
402 username_str);
403 return -1;
404 }
405 dump_ntquota(&qt,verbose,numeric,SidToString);
406 break;
407 case QUOTA_LIST:
408 status = cli_list_user_quota(
409 cli, quota_fnum, &qtl);
410 if (!NT_STATUS_IS_OK(status)) {
411 d_printf("%s cli_set_user_quota %s\n",
412 nt_errstr(status),
413 username_str);
414 return -1;
415 }
416 dump_ntquota_list(&qtl,verbose,numeric,SidToString);
417 free_ntquota_list(&qtl);
418 break;
419 default:
420 d_printf("Unknown Error\n");
421 return -1;
422 }
423 break;
424 case SMB_USER_FS_QUOTA_TYPE:
425 switch(cmd) {
426 case QUOTA_GET:
427 status = cli_get_fs_quota_info(
428 cli, quota_fnum, &qt);
429 if (!NT_STATUS_IS_OK(status)) {
430 d_printf("%s cli_get_fs_quota_info\n",
431 nt_errstr(status));
432 return -1;
433 }
434 dump_ntquota(&qt,True,numeric,NULL);
435 break;
436 case QUOTA_SETLIM:
437 status = cli_get_fs_quota_info(
438 cli, quota_fnum, &qt);
439 if (!NT_STATUS_IS_OK(status)) {
440 d_printf("%s cli_get_fs_quota_info\n",
441 nt_errstr(status));
442 return -1;
443 }
444 qt.softlim = pqt->softlim;
445 qt.hardlim = pqt->hardlim;
446 status = cli_set_fs_quota_info(
447 cli, quota_fnum, &qt);
448 if (!NT_STATUS_IS_OK(status)) {
449 d_printf("%s cli_set_fs_quota_info\n",
450 nt_errstr(status));
451 return -1;
452 }
453 status = cli_get_fs_quota_info(
454 cli, quota_fnum, &qt);
455 if (!NT_STATUS_IS_OK(status)) {
456 d_printf("%s cli_get_fs_quota_info\n",
457 nt_errstr(status));
458 return -1;
459 }
460 dump_ntquota(&qt,True,numeric,NULL);
461 break;
462 case QUOTA_SETFLAGS:
463 status = cli_get_fs_quota_info(
464 cli, quota_fnum, &qt);
465 if (!NT_STATUS_IS_OK(status)) {
466 d_printf("%s cli_get_fs_quota_info\n",
467 nt_errstr(status));
468 return -1;
469 }
470 qt.qflags = pqt->qflags;
471 status = cli_set_fs_quota_info(
472 cli, quota_fnum, &qt);
473 if (!NT_STATUS_IS_OK(status)) {
474 d_printf("%s cli_set_fs_quota_info\n",
475 nt_errstr(status));
476 return -1;
477 }
478 status = cli_get_fs_quota_info(
479 cli, quota_fnum, &qt);
480 if (!NT_STATUS_IS_OK(status)) {
481 d_printf("%s cli_get_fs_quota_info\n",
482 nt_errstr(status));
483 return -1;
484 }
485 dump_ntquota(&qt,True,numeric,NULL);
486 break;
487 default:
488 d_printf("Unknown Error\n");
489 return -1;
490 }
491 break;
492 default:
493 d_printf("Unknown Error\n");
494 return -1;
495 }
496
497 cli_close(cli, quota_fnum);
498
499 return 0;
500}
501
502/*****************************************************
503 Return a connection to a server.
504*******************************************************/
505
506static struct cli_state *connect_one(const char *share)
507{
508 struct cli_state *c;
509 NTSTATUS nt_status;
510 uint32_t flags = 0;
511
512 if (get_cmdline_auth_info_use_machine_account(smbcquotas_auth_info) &&
513 !set_cmdline_auth_info_machine_account_creds(smbcquotas_auth_info)) {
514 return NULL;
515 }
516
517 if (get_cmdline_auth_info_use_kerberos(smbcquotas_auth_info)) {
518 flags |= CLI_FULL_CONNECTION_USE_KERBEROS |
519 CLI_FULL_CONNECTION_FALLBACK_AFTER_KERBEROS;
520
521 }
522
523 set_cmdline_auth_info_getpass(smbcquotas_auth_info);
524
525 nt_status = cli_full_connection(&c, lp_netbios_name(), server,
526 NULL, 0,
527 share, "?????",
528 get_cmdline_auth_info_username(smbcquotas_auth_info),
529 lp_workgroup(),
530 get_cmdline_auth_info_password(smbcquotas_auth_info),
531 flags,
532 get_cmdline_auth_info_signing_state(smbcquotas_auth_info));
533 if (!NT_STATUS_IS_OK(nt_status)) {
534 DEBUG(0,("cli_full_connection failed! (%s)\n", nt_errstr(nt_status)));
535 return NULL;
536 }
537
538 if (get_cmdline_auth_info_smb_encrypt(smbcquotas_auth_info)) {
539 nt_status = cli_cm_force_encryption(c,
540 get_cmdline_auth_info_username(smbcquotas_auth_info),
541 get_cmdline_auth_info_password(smbcquotas_auth_info),
542 lp_workgroup(),
543 share);
544 if (!NT_STATUS_IS_OK(nt_status)) {
545 cli_shutdown(c);
546 return NULL;
547 }
548 }
549
550 return c;
551}
552
553/****************************************************************************
554 main program
555****************************************************************************/
556int main(int argc, char *argv[])
557{
558 const char **argv_const = discard_const_p(const char *, argv);
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 bool ok;
572 SMB_NTQUOTA_STRUCT qt;
573 TALLOC_CTX *frame = talloc_stackframe();
574 poptContext pc;
575 struct poptOption long_options[] = {
576 POPT_AUTOHELP
577 { "user", 'u', POPT_ARG_STRING, NULL, 'u', "Show quotas for user", "user" },
578 { "list", 'L', POPT_ARG_NONE, NULL, 'L', "List user quotas" },
579 { "fs", 'F', POPT_ARG_NONE, NULL, 'F', "Show filesystem quotas" },
580 { "set", 'S', POPT_ARG_STRING, NULL, 'S', "Set acls\n\
581SETSTRING:\n\
582UQLIM:<username>/<softlimit>/<hardlimit> for user quotas\n\
583FSQLIM:<softlimit>/<hardlimit> for filesystem defaults\n\
584FSQFLAGS:QUOTA_ENABLED/DENY_DISK/LOG_SOFTLIMIT/LOG_HARD_LIMIT", "SETSTRING" },
585 { "numeric", 'n', POPT_ARG_NONE, NULL, 'n', "Don't resolve sids or limits to names" },
586 { "verbose", 'v', POPT_ARG_NONE, NULL, 'v', "be verbose" },
587 { "test-args", 't', POPT_ARG_NONE, NULL, 't', "Test arguments"},
588 POPT_COMMON_SAMBA
589 POPT_COMMON_CREDENTIALS
590 { NULL }
591 };
592
593 smb_init_locale();
594
595 ZERO_STRUCT(qt);
596
597 /* set default debug level to 1 regardless of what smb.conf sets */
598 setup_logging( "smbcquotas", DEBUG_STDERR);
599 lp_set_cmdline("log level", "1");
600
601 setlinebuf(stdout);
602
603 fault_setup();
604
605 smbcquotas_auth_info = user_auth_info_init(frame);
606 if (smbcquotas_auth_info == NULL) {
607 exit(1);
608 }
609 popt_common_set_auth_info(smbcquotas_auth_info);
610
611 pc = poptGetContext("smbcquotas", argc, argv_const, long_options, 0);
612
613 poptSetOtherOptionHelp(pc, "//server1/share1");
614
615 while ((opt = poptGetNextOpt(pc)) != -1) {
616 switch (opt) {
617 case 'n':
618 numeric = true;
619 break;
620 case 'v':
621 verbose = true;
622 break;
623 case 't':
624 test_args = true;
625 break;
626 case 'L':
627 if (todo != 0) {
628 d_printf("Please specify only one option of <-L|-F|-S|-u>\n");
629 exit(EXIT_PARSE_ERROR);
630 }
631 todo = LIST_QUOTA;
632 break;
633
634 case 'F':
635 if (todo != 0) {
636 d_printf("Please specify only one option of <-L|-F|-S|-u>\n");
637 exit(EXIT_PARSE_ERROR);
638 }
639 todo = FS_QUOTA;
640 break;
641
642 case 'u':
643 if (todo != 0) {
644 d_printf("Please specify only one option of <-L|-F|-S|-u>\n");
645 exit(EXIT_PARSE_ERROR);
646 }
647 username_str = talloc_strdup(frame, poptGetOptArg(pc));
648 if (!username_str) {
649 exit(EXIT_PARSE_ERROR);
650 }
651 todo = USER_QUOTA;
652 fix_user = True;
653 break;
654
655 case 'S':
656 if (todo != 0) {
657 d_printf("Please specify only one option of <-L|-F|-S|-u>\n");
658 exit(EXIT_PARSE_ERROR);
659 }
660 set_str = talloc_strdup(frame, poptGetOptArg(pc));
661 if (!set_str) {
662 exit(EXIT_PARSE_ERROR);
663 }
664 todo = SET_QUOTA;
665 break;
666 }
667 }
668
669 if (todo == 0)
670 todo = USER_QUOTA;
671
672 if (!fix_user) {
673 username_str = talloc_strdup(
674 frame, get_cmdline_auth_info_username(smbcquotas_auth_info));
675 if (!username_str) {
676 exit(EXIT_PARSE_ERROR);
677 }
678 }
679
680 /* Make connection to server */
681 if(!poptPeekArg(pc)) {
682 poptPrintUsage(pc, stderr, 0);
683 exit(EXIT_PARSE_ERROR);
684 }
685
686 path = talloc_strdup(frame, poptGetArg(pc));
687 if (!path) {
688 printf("Out of memory\n");
689 exit(EXIT_PARSE_ERROR);
690 }
691
692 poptFreeContext(pc);
693 popt_burn_cmdline_password(argc, argv);
694
695 ok = lp_load_global(get_dyn_CONFIGFILE());
696 if (!ok) {
697 DBG_ERR("ERROR: Loading config file %s - "
698 "run testparm to debug it\n",
699 get_dyn_CONFIGFILE());
700 exit(EXIT_PARSE_ERROR);
701 }
702
703 /* We must load interfaces after we load the smb.conf */
704 load_interfaces();
705
706 string_replace(path, '/', '\\');
707
708 server = SMB_STRDUP(path+2);
709 if (!server) {
710 printf("Out of memory\n");
711 exit(EXIT_PARSE_ERROR);
712 }
713 share = strchr_m(server,'\\');
714 if (!share) {
715 printf("Invalid argument: %s\n", share);
716 exit(EXIT_PARSE_ERROR);
717 }
718
719 *share = 0;
720 share++;
721
722 if (todo == SET_QUOTA) {
723 if (parse_quota_set(talloc_tos(), set_str, &username_str, &qtype, &cmd, &qt)) {
724 printf("Invalid argument: -S %s\n", set_str);
725 exit(EXIT_PARSE_ERROR);
726 }
727 }
728
729 if (!test_args) {
730 cli = connect_one(share);
731 if (!cli) {
732 exit(EXIT_FAILED);
733 }
734 } else {
735 exit(EXIT_OK);
736 }
737
738
739 /* Perform requested action */
740
741 switch (todo) {
742 case FS_QUOTA:
743 result = do_quota(cli,SMB_USER_FS_QUOTA_TYPE, QUOTA_GET, username_str, NULL);
744 break;
745 case LIST_QUOTA:
746 result = do_quota(cli,SMB_USER_QUOTA_TYPE, QUOTA_LIST, username_str, NULL);
747 break;
748 case USER_QUOTA:
749 result = do_quota(cli,SMB_USER_QUOTA_TYPE, QUOTA_GET, username_str, NULL);
750 break;
751 case SET_QUOTA:
752 result = do_quota(cli, qtype, cmd, username_str, &qt);
753 break;
754 default:
755 result = EXIT_FAILED;
756 break;
757 }
758
759 talloc_free(frame);
760
761 return result;
762}
Note: See TracBrowser for help on using the repository browser.