source: branches/samba-3.2.x/source/utils/smbcquotas.c@ 204

Last change on this file since 204 was 136, checked in by Paul Smedley, 17 years ago

Update trunk to 3.2.0rc1
File size: 14.9 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
26static char *server;
27
28/* numeric is set when the user wants numeric SIDs and ACEs rather
29 than going via LSA calls to resolve them */
30static bool numeric;
31static bool verbose;
32
33enum todo_values {NOOP_QUOTA=0,FS_QUOTA,USER_QUOTA,LIST_QUOTA,SET_QUOTA};
34enum exit_values {EXIT_OK, EXIT_FAILED, EXIT_PARSE_ERROR};
35
36static struct cli_state *cli_ipc;
37static struct rpc_pipe_client *global_pipe_hnd;
38static POLICY_HND pol;
39static bool got_policy_hnd;
40
41static struct cli_state *connect_one(const char *share);
42
43/* Open cli connection and policy handle */
44
45static bool cli_open_policy_hnd(void)
46{
47 /* Initialise cli LSA connection */
48
49 if (!cli_ipc) {
50 NTSTATUS ret;
51 cli_ipc = connect_one("IPC$");
52 global_pipe_hnd = cli_rpc_pipe_open_noauth(cli_ipc, PI_LSARPC, &ret);
53 if (!global_pipe_hnd) {
54 return False;
55 }
56 }
57
58 /* Open policy handle */
59
60 if (!got_policy_hnd) {
61
62 /* Some systems don't support SEC_RIGHTS_MAXIMUM_ALLOWED,
63 but NT sends 0x2000000 so we might as well do it too. */
64
65 if (!NT_STATUS_IS_OK(rpccli_lsa_open_policy(global_pipe_hnd, talloc_tos(), True,
66 GENERIC_EXECUTE_ACCESS, &pol))) {
67 return False;
68 }
69
70 got_policy_hnd = True;
71 }
72
73 return True;
74}
75
76/* convert a SID to a string, either numeric or username/group */
77static void SidToString(fstring str, DOM_SID *sid, bool _numeric)
78{
79 char **domains = NULL;
80 char **names = NULL;
81 enum lsa_SidType *types = NULL;
82
83 sid_to_fstring(str, sid);
84
85 if (_numeric) return;
86
87 /* Ask LSA to convert the sid to a name */
88
89 if (!cli_open_policy_hnd() ||
90 !NT_STATUS_IS_OK(rpccli_lsa_lookup_sids(global_pipe_hnd, talloc_tos(),
91 &pol, 1, sid, &domains,
92 &names, &types)) ||
93 !domains || !domains[0] || !names || !names[0]) {
94 return;
95 }
96
97 /* Converted OK */
98
99 slprintf(str, sizeof(fstring) - 1, "%s%s%s",
100 domains[0], lp_winbind_separator(),
101 names[0]);
102
103}
104
105/* convert a string to a SID, either numeric or username/group */
106static bool StringToSid(DOM_SID *sid, const char *str)
107{
108 enum lsa_SidType *types = NULL;
109 DOM_SID *sids = NULL;
110 bool result = True;
111
112 if (strncmp(str, "S-", 2) == 0) {
113 return string_to_sid(sid, str);
114 }
115
116 if (!cli_open_policy_hnd() ||
117 !NT_STATUS_IS_OK(rpccli_lsa_lookup_names(global_pipe_hnd, talloc_tos(),
118 &pol, 1, &str, NULL, 1, &sids,
119 &types))) {
120 result = False;
121 goto done;
122 }
123
124 sid_copy(sid, &sids[0]);
125 done:
126
127 return result;
128}
129
130#define QUOTA_GET 1
131#define QUOTA_SETLIM 2
132#define QUOTA_SETFLAGS 3
133#define QUOTA_LIST 4
134
135enum {PARSE_FLAGS,PARSE_LIM};
136
137static int parse_quota_set(TALLOC_CTX *ctx,
138 char *set_str,
139 char **pp_username_str,
140 enum SMB_QUOTA_TYPE *qtype,
141 int *cmd,
142 SMB_NTQUOTA_STRUCT *pqt)
143{
144 char *p = set_str,*p2;
145 int todo;
146 bool stop = False;
147 bool enable = False;
148 bool deny = False;
149
150 *pp_username_str = NULL;
151 if (strnequal(set_str,"UQLIM:",6)) {
152 p += 6;
153 *qtype = SMB_USER_QUOTA_TYPE;
154 *cmd = QUOTA_SETLIM;
155 todo = PARSE_LIM;
156 if ((p2=strstr(p,":"))==NULL) {
157 return -1;
158 }
159
160 *p2 = '\0';
161 p2++;
162
163 *pp_username_str = talloc_strdup(ctx, p);
164 p = p2;
165 } else if (strnequal(set_str,"FSQLIM:",7)) {
166 p +=7;
167 *qtype = SMB_USER_FS_QUOTA_TYPE;
168 *cmd = QUOTA_SETLIM;
169 todo = PARSE_LIM;
170 } else if (strnequal(set_str,"FSQFLAGS:",9)) {
171 p +=9;
172 todo = PARSE_FLAGS;
173 *qtype = SMB_USER_FS_QUOTA_TYPE;
174 *cmd = QUOTA_SETFLAGS;
175 } else {
176 return -1;
177 }
178
179 switch (todo) {
180 case PARSE_LIM:
181#if defined(HAVE_LONGLONG)
182 if (sscanf(p,"%llu/%llu",&pqt->softlim,&pqt->hardlim)!=2) {
183#else
184 if (sscanf(p,"%lu/%lu",&pqt->softlim,&pqt->hardlim)!=2) {
185#endif
186 return -1;
187 }
188
189 break;
190 case PARSE_FLAGS:
191 while (!stop) {
192
193 if ((p2=strstr(p,"/"))==NULL) {
194 stop = True;
195 } else {
196 *p2 = '\0';
197 p2++;
198 }
199
200 if (strnequal(p,"QUOTA_ENABLED",13)) {
201 enable = True;
202 } else if (strnequal(p,"DENY_DISK",9)) {
203 deny = True;
204 } else if (strnequal(p,"LOG_SOFTLIMIT",13)) {
205 pqt->qflags |= QUOTAS_LOG_THRESHOLD;
206 } else if (strnequal(p,"LOG_HARDLIMIT",13)) {
207 pqt->qflags |= QUOTAS_LOG_LIMIT;
208 } else {
209 return -1;
210 }
211
212 p=p2;
213 }
214
215 if (deny) {
216 pqt->qflags |= QUOTAS_DENY_DISK;
217 } else if (enable) {
218 pqt->qflags |= QUOTAS_ENABLED;
219 }
220
221 break;
222 }
223
224 return 0;
225}
226
227static int do_quota(struct cli_state *cli,
228 enum SMB_QUOTA_TYPE qtype,
229 uint16 cmd,
230 const char *username_str,
231 SMB_NTQUOTA_STRUCT *pqt)
232{
233 uint32 fs_attrs = 0;
234 int quota_fnum = 0;
235 SMB_NTQUOTA_LIST *qtl = NULL;
236 SMB_NTQUOTA_STRUCT qt;
237 ZERO_STRUCT(qt);
238
239 if (!cli_get_fs_attr_info(cli, &fs_attrs)) {
240 d_printf("Failed to get the filesystem attributes %s.\n",
241 cli_errstr(cli));
242 return -1;
243 }
244
245 if (!(fs_attrs & FILE_VOLUME_QUOTAS)) {
246 d_printf("Quotas are not supported by the server.\n");
247 return 0;
248 }
249
250 if (!cli_get_quota_handle(cli, &quota_fnum)) {
251 d_printf("Quotas are not enabled on this share.\n");
252 d_printf("Failed to open %s %s.\n",
253 FAKE_FILE_NAME_QUOTA_WIN32,cli_errstr(cli));
254 return -1;
255 }
256
257 switch(qtype) {
258 case SMB_USER_QUOTA_TYPE:
259 if (!StringToSid(&qt.sid, username_str)) {
260 d_printf("StringToSid() failed for [%s]\n",username_str);
261 return -1;
262 }
263
264 switch(cmd) {
265 case QUOTA_GET:
266 if (!cli_get_user_quota(cli, quota_fnum, &qt)) {
267 d_printf("%s cli_get_user_quota %s\n",
268 cli_errstr(cli),username_str);
269 return -1;
270 }
271 dump_ntquota(&qt,verbose,numeric,SidToString);
272 break;
273 case QUOTA_SETLIM:
274 pqt->sid = qt.sid;
275 if (!cli_set_user_quota(cli, quota_fnum, pqt)) {
276 d_printf("%s cli_set_user_quota %s\n",
277 cli_errstr(cli),username_str);
278 return -1;
279 }
280 if (!cli_get_user_quota(cli, quota_fnum, &qt)) {
281 d_printf("%s cli_get_user_quota %s\n",
282 cli_errstr(cli),username_str);
283 return -1;
284 }
285 dump_ntquota(&qt,verbose,numeric,SidToString);
286 break;
287 case QUOTA_LIST:
288 if (!cli_list_user_quota(cli, quota_fnum, &qtl)) {
289 d_printf("%s cli_set_user_quota %s\n",
290 cli_errstr(cli),username_str);
291 return -1;
292 }
293 dump_ntquota_list(&qtl,verbose,numeric,SidToString);
294 free_ntquota_list(&qtl);
295 break;
296 default:
297 d_printf("Unknown Error\n");
298 return -1;
299 }
300 break;
301 case SMB_USER_FS_QUOTA_TYPE:
302 switch(cmd) {
303 case QUOTA_GET:
304 if (!cli_get_fs_quota_info(cli, quota_fnum, &qt)) {
305 d_printf("%s cli_get_fs_quota_info\n",
306 cli_errstr(cli));
307 return -1;
308 }
309 dump_ntquota(&qt,True,numeric,NULL);
310 break;
311 case QUOTA_SETLIM:
312 if (!cli_get_fs_quota_info(cli, quota_fnum, &qt)) {
313 d_printf("%s cli_get_fs_quota_info\n",
314 cli_errstr(cli));
315 return -1;
316 }
317 qt.softlim = pqt->softlim;
318 qt.hardlim = pqt->hardlim;
319 if (!cli_set_fs_quota_info(cli, quota_fnum, &qt)) {
320 d_printf("%s cli_set_fs_quota_info\n",
321 cli_errstr(cli));
322 return -1;
323 }
324 if (!cli_get_fs_quota_info(cli, quota_fnum, &qt)) {
325 d_printf("%s cli_get_fs_quota_info\n",
326 cli_errstr(cli));
327 return -1;
328 }
329 dump_ntquota(&qt,True,numeric,NULL);
330 break;
331 case QUOTA_SETFLAGS:
332 if (!cli_get_fs_quota_info(cli, quota_fnum, &qt)) {
333 d_printf("%s cli_get_fs_quota_info\n",
334 cli_errstr(cli));
335 return -1;
336 }
337 qt.qflags = pqt->qflags;
338 if (!cli_set_fs_quota_info(cli, quota_fnum, &qt)) {
339 d_printf("%s cli_set_fs_quota_info\n",
340 cli_errstr(cli));
341 return -1;
342 }
343 if (!cli_get_fs_quota_info(cli, quota_fnum, &qt)) {
344 d_printf("%s cli_get_fs_quota_info\n",
345 cli_errstr(cli));
346 return -1;
347 }
348 dump_ntquota(&qt,True,numeric,NULL);
349 break;
350 default:
351 d_printf("Unknown Error\n");
352 return -1;
353 }
354 break;
355 default:
356 d_printf("Unknown Error\n");
357 return -1;
358 }
359
360 cli_close(cli, quota_fnum);
361
362 return 0;
363}
364
365/*****************************************************
366 Return a connection to a server.
367*******************************************************/
368
369static struct cli_state *connect_one(const char *share)
370{
371 struct cli_state *c;
372 struct sockaddr_storage ss;
373 NTSTATUS nt_status;
374 uint32_t flags = 0;
375
376 zero_addr(&ss);
377
378 if (get_cmdline_auth_info_use_machine_account() &&
379 !set_cmdline_auth_info_machine_account_creds()) {
380 return NULL;
381 }
382
383 if (get_cmdline_auth_info_use_kerberos()) {
384 flags |= CLI_FULL_CONNECTION_USE_KERBEROS |
385 CLI_FULL_CONNECTION_FALLBACK_AFTER_KERBEROS;
386
387 }
388
389 if (!get_cmdline_auth_info_got_pass()) {
390 char *pass = getpass("Password: ");
391 if (pass) {
392 set_cmdline_auth_info_password(pass);
393 }
394 }
395
396 nt_status = cli_full_connection(&c, global_myname(), server,
397 &ss, 0,
398 share, "?????",
399 get_cmdline_auth_info_username(),
400 lp_workgroup(),
401 get_cmdline_auth_info_password(),
402 flags,
403 get_cmdline_auth_info_signing_state(),
404 NULL);
405 if (!NT_STATUS_IS_OK(nt_status)) {
406 DEBUG(0,("cli_full_connection failed! (%s)\n", nt_errstr(nt_status)));
407 return NULL;
408 }
409
410 if (get_cmdline_auth_info_smb_encrypt()) {
411 nt_status = cli_cm_force_encryption(c,
412 get_cmdline_auth_info_username(),
413 get_cmdline_auth_info_password(),
414 lp_workgroup(),
415 share);
416 if (!NT_STATUS_IS_OK(nt_status)) {
417 cli_shutdown(c);
418 return NULL;
419 }
420 }
421
422 return c;
423}
424
425/****************************************************************************
426 main program
427****************************************************************************/
428 int main(int argc, const char *argv[])
429{
430 char *share;
431 int opt;
432 int result;
433 int todo = 0;
434 char *username_str = NULL;
435 char *path = NULL;
436 char *set_str = NULL;
437 enum SMB_QUOTA_TYPE qtype = SMB_INVALID_QUOTA_TYPE;
438 int cmd = 0;
439 static bool test_args = False;
440 struct cli_state *cli;
441 bool fix_user = False;
442 SMB_NTQUOTA_STRUCT qt;
443 TALLOC_CTX *frame = talloc_stackframe();
444 poptContext pc;
445 struct poptOption long_options[] = {
446 POPT_AUTOHELP
447 { "user", 'u', POPT_ARG_STRING, NULL, 'u', "Show quotas for user", "user" },
448 { "list", 'L', POPT_ARG_NONE, NULL, 'L', "List user quotas" },
449 { "fs", 'F', POPT_ARG_NONE, NULL, 'F', "Show filesystem quotas" },
450 { "set", 'S', POPT_ARG_STRING, NULL, 'S', "Set acls\n\
451SETSTRING:\n\
452UQLIM:<username>/<softlimit>/<hardlimit> for user quotas\n\
453FSQLIM:<softlimit>/<hardlimit> for filesystem defaults\n\
454FSQFLAGS:QUOTA_ENABLED/DENY_DISK/LOG_SOFTLIMIT/LOG_HARD_LIMIT", "SETSTRING" },
455 { "numeric", 'n', POPT_ARG_NONE, NULL, 'n', "Don't resolve sids or limits to names" },
456 { "verbose", 'v', POPT_ARG_NONE, NULL, 'v', "be verbose" },
457 { "test-args", 't', POPT_ARG_NONE, NULL, 'r', "Test arguments"},
458 POPT_COMMON_SAMBA
459 POPT_COMMON_CREDENTIALS
460 { NULL }
461 };
462
463 load_case_tables();
464
465 ZERO_STRUCT(qt);
466
467 /* set default debug level to 1 regardless of what smb.conf sets */
468 setup_logging( "smbcquotas", True );
469 DEBUGLEVEL_CLASS[DBGC_ALL] = 1;
470 dbf = x_stderr;
471 x_setbuf( x_stderr, NULL );
472
473 setlinebuf(stdout);
474
475 fault_setup(NULL);
476
477 lp_load(get_dyn_CONFIGFILE(),True,False,False,True);
478 load_interfaces();
479
480 pc = poptGetContext("smbcquotas", argc, argv, long_options, 0);
481
482 poptSetOtherOptionHelp(pc, "//server1/share1");
483
484 while ((opt = poptGetNextOpt(pc)) != -1) {
485 switch (opt) {
486 case 'n':
487 numeric = true;
488 break;
489 case 'v':
490 verbose = true;
491 break;
492 case 't':
493 test_args = true;
494 break;
495 case 'L':
496 if (todo != 0) {
497 d_printf("Please specify only one option of <-L|-F|-S|-u>\n");
498 exit(EXIT_PARSE_ERROR);
499 }
500 todo = LIST_QUOTA;
501 break;
502
503 case 'F':
504 if (todo != 0) {
505 d_printf("Please specify only one option of <-L|-F|-S|-u>\n");
506 exit(EXIT_PARSE_ERROR);
507 }
508 todo = FS_QUOTA;
509 break;
510
511 case 'u':
512 if (todo != 0) {
513 d_printf("Please specify only one option of <-L|-F|-S|-u>\n");
514 exit(EXIT_PARSE_ERROR);
515 }
516 username_str = talloc_strdup(frame, poptGetOptArg(pc));
517 if (!username_str) {
518 exit(EXIT_PARSE_ERROR);
519 }
520 todo = USER_QUOTA;
521 fix_user = True;
522 break;
523
524 case 'S':
525 if (todo != 0) {
526 d_printf("Please specify only one option of <-L|-F|-S|-u>\n");
527 exit(EXIT_PARSE_ERROR);
528 }
529 set_str = talloc_strdup(frame, poptGetOptArg(pc));
530 if (!set_str) {
531 exit(EXIT_PARSE_ERROR);
532 }
533 todo = SET_QUOTA;
534 break;
535 }
536 }
537
538 if (todo == 0)
539 todo = USER_QUOTA;
540
541 if (!fix_user) {
542 username_str = talloc_strdup(frame, get_cmdline_auth_info_username());
543 if (!username_str) {
544 exit(EXIT_PARSE_ERROR);
545 }
546 }
547
548 /* Make connection to server */
549 if(!poptPeekArg(pc)) {
550 poptPrintUsage(pc, stderr, 0);
551 exit(EXIT_PARSE_ERROR);
552 }
553
554 path = talloc_strdup(frame, poptGetArg(pc));
555 if (!path) {
556 printf("Out of memory\n");
557 exit(EXIT_PARSE_ERROR);
558 }
559
560 string_replace(path, '/', '\\');
561
562 server = SMB_STRDUP(path+2);
563 if (!server) {
564 printf("Out of memory\n");
565 exit(EXIT_PARSE_ERROR);
566 }
567 share = strchr_m(server,'\\');
568 if (!share) {
569 printf("Invalid argument: %s\n", share);
570 exit(EXIT_PARSE_ERROR);
571 }
572
573 *share = 0;
574 share++;
575
576 if (todo == SET_QUOTA) {
577 if (parse_quota_set(talloc_tos(), set_str, &username_str, &qtype, &cmd, &qt)) {
578 printf("Invalid argument: -S %s\n", set_str);
579 exit(EXIT_PARSE_ERROR);
580 }
581 }
582
583 if (!test_args) {
584 cli = connect_one(share);
585 if (!cli) {
586 exit(EXIT_FAILED);
587 }
588 } else {
589 exit(EXIT_OK);
590 }
591
592
593 /* Perform requested action */
594
595 switch (todo) {
596 case FS_QUOTA:
597 result = do_quota(cli,SMB_USER_FS_QUOTA_TYPE, QUOTA_GET, username_str, NULL);
598 break;
599 case LIST_QUOTA:
600 result = do_quota(cli,SMB_USER_QUOTA_TYPE, QUOTA_LIST, username_str, NULL);
601 break;
602 case USER_QUOTA:
603 result = do_quota(cli,SMB_USER_QUOTA_TYPE, QUOTA_GET, username_str, NULL);
604 break;
605 case SET_QUOTA:
606 result = do_quota(cli, qtype, cmd, username_str, &qt);
607 break;
608 default:
609
610 result = EXIT_FAILED;
611 break;
612 }
613
614 talloc_free(frame);
615
616 return result;
617}
Note: See TracBrowser for help on using the repository browser.