s3fs-utils: Free the popt context in smbcacls and smbquotas.
[kai/samba.git] / source3 / utils / smbcquotas.c
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
33 static 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 */
37 static bool numeric;
38 static bool verbose;
39
40 enum todo_values {NOOP_QUOTA=0,FS_QUOTA,USER_QUOTA,LIST_QUOTA,SET_QUOTA};
41 enum exit_values {EXIT_OK, EXIT_FAILED, EXIT_PARSE_ERROR};
42
43 static struct cli_state *cli_ipc;
44 static struct rpc_pipe_client *global_pipe_hnd;
45 static struct policy_handle pol;
46 static bool got_policy_hnd;
47 static struct user_auth_info *smbcquotas_auth_info;
48
49 static struct cli_state *connect_one(const char *share);
50
51 /* Open cli connection and policy handle */
52
53 static 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 */
87 static 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 */
115 static 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
144 enum {PARSE_FLAGS,PARSE_LIM};
145
146 static 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
233 static 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
245 static 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
316 static 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
331 static 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
504 static struct cli_state *connect_one(const char *share)
505 {
506         struct cli_state *c;
507         NTSTATUS nt_status;
508         uint32_t flags = 0;
509
510         if (get_cmdline_auth_info_use_machine_account(smbcquotas_auth_info) &&
511             !set_cmdline_auth_info_machine_account_creds(smbcquotas_auth_info)) {
512                 return NULL;
513         }
514
515         if (get_cmdline_auth_info_use_kerberos(smbcquotas_auth_info)) {
516                 flags |= CLI_FULL_CONNECTION_USE_KERBEROS |
517                          CLI_FULL_CONNECTION_FALLBACK_AFTER_KERBEROS;
518
519         }
520
521         set_cmdline_auth_info_getpass(smbcquotas_auth_info);
522
523         nt_status = cli_full_connection(&c, lp_netbios_name(), server,
524                                             NULL, 0,
525                                             share, "?????",
526                                             get_cmdline_auth_info_username(smbcquotas_auth_info),
527                                             lp_workgroup(),
528                                             get_cmdline_auth_info_password(smbcquotas_auth_info),
529                                             flags,
530                                             get_cmdline_auth_info_signing_state(smbcquotas_auth_info));
531         if (!NT_STATUS_IS_OK(nt_status)) {
532                 DEBUG(0,("cli_full_connection failed! (%s)\n", nt_errstr(nt_status)));
533                 return NULL;
534         }
535
536         if (get_cmdline_auth_info_smb_encrypt(smbcquotas_auth_info)) {
537                 nt_status = cli_cm_force_encryption(c,
538                                         get_cmdline_auth_info_username(smbcquotas_auth_info),
539                                         get_cmdline_auth_info_password(smbcquotas_auth_info),
540                                         lp_workgroup(),
541                                         share);
542                 if (!NT_STATUS_IS_OK(nt_status)) {
543                         cli_shutdown(c);
544                         return NULL;
545                 }
546         }
547
548         return c;
549 }
550
551 /****************************************************************************
552   main program
553 ****************************************************************************/
554  int main(int argc, const char *argv[])
555 {
556         char *share;
557         int opt;
558         int result;
559         int todo = 0;
560         char *username_str = NULL;
561         char *path = NULL;
562         char *set_str = NULL;
563         enum SMB_QUOTA_TYPE qtype = SMB_INVALID_QUOTA_TYPE;
564         int cmd = 0;
565         static bool test_args = False;
566         struct cli_state *cli;
567         bool fix_user = False;
568         SMB_NTQUOTA_STRUCT qt;
569         TALLOC_CTX *frame = talloc_stackframe();
570         poptContext pc;
571         struct poptOption long_options[] = {
572                 POPT_AUTOHELP
573                 { "user", 'u', POPT_ARG_STRING, NULL, 'u', "Show quotas for user", "user" },
574                 { "list", 'L', POPT_ARG_NONE, NULL, 'L', "List user quotas" },
575                 { "fs", 'F', POPT_ARG_NONE, NULL, 'F', "Show filesystem quotas" },
576                 { "set", 'S', POPT_ARG_STRING, NULL, 'S', "Set acls\n\
577 SETSTRING:\n\
578 UQLIM:<username>/<softlimit>/<hardlimit> for user quotas\n\
579 FSQLIM:<softlimit>/<hardlimit> for filesystem defaults\n\
580 FSQFLAGS:QUOTA_ENABLED/DENY_DISK/LOG_SOFTLIMIT/LOG_HARD_LIMIT", "SETSTRING" },
581                 { "numeric", 'n', POPT_ARG_NONE, NULL, 'n', "Don't resolve sids or limits to names" },
582                 { "verbose", 'v', POPT_ARG_NONE, NULL, 'v', "be verbose" },
583                 { "test-args", 't', POPT_ARG_NONE, NULL, 'r', "Test arguments"},
584                 POPT_COMMON_SAMBA
585                 POPT_COMMON_CREDENTIALS
586                 { NULL }
587         };
588
589         load_case_tables();
590
591         ZERO_STRUCT(qt);
592
593         /* set default debug level to 1 regardless of what smb.conf sets */
594         setup_logging( "smbcquotas", DEBUG_STDERR);
595         lp_set_cmdline("log level", "1");
596
597         setlinebuf(stdout);
598
599         fault_setup();
600
601         lp_load_global(get_dyn_CONFIGFILE());
602         load_interfaces();
603
604         smbcquotas_auth_info = user_auth_info_init(frame);
605         if (smbcquotas_auth_info == NULL) {
606                 exit(1);
607         }
608         popt_common_set_auth_info(smbcquotas_auth_info);
609
610         pc = poptGetContext("smbcquotas", argc, argv, long_options, 0);
611
612         poptSetOtherOptionHelp(pc, "//server1/share1");
613
614         while ((opt = poptGetNextOpt(pc)) != -1) {
615                 switch (opt) {
616                 case 'n':
617                         numeric = true;
618                         break;
619                 case 'v':
620                         verbose = true;
621                         break;
622                 case 't':
623                         test_args = true;
624                         break;
625                 case 'L':
626                         if (todo != 0) {
627                                 d_printf("Please specify only one option of <-L|-F|-S|-u>\n");
628                                 exit(EXIT_PARSE_ERROR);
629                         }
630                         todo = LIST_QUOTA;
631                         break;
632
633                 case 'F':
634                         if (todo != 0) {
635                                 d_printf("Please specify only one option of <-L|-F|-S|-u>\n");
636                                 exit(EXIT_PARSE_ERROR);
637                         }
638                         todo = FS_QUOTA;
639                         break;
640
641                 case 'u':
642                         if (todo != 0) {
643                                 d_printf("Please specify only one option of <-L|-F|-S|-u>\n");
644                                 exit(EXIT_PARSE_ERROR);
645                         }
646                         username_str = talloc_strdup(frame, poptGetOptArg(pc));
647                         if (!username_str) {
648                                 exit(EXIT_PARSE_ERROR);
649                         }
650                         todo = USER_QUOTA;
651                         fix_user = True;
652                         break;
653
654                 case 'S':
655                         if (todo != 0) {
656                                 d_printf("Please specify only one option of <-L|-F|-S|-u>\n");
657                                 exit(EXIT_PARSE_ERROR);
658                         }
659                         set_str = talloc_strdup(frame, poptGetOptArg(pc));
660                         if (!set_str) {
661                                 exit(EXIT_PARSE_ERROR);
662                         }
663                         todo = SET_QUOTA;
664                         break;
665                 }
666         }
667
668         if (todo == 0)
669                 todo = USER_QUOTA;
670
671         if (!fix_user) {
672                 username_str = talloc_strdup(
673                         frame, get_cmdline_auth_info_username(smbcquotas_auth_info));
674                 if (!username_str) {
675                         exit(EXIT_PARSE_ERROR);
676                 }
677         }
678
679         /* Make connection to server */
680         if(!poptPeekArg(pc)) {
681                 poptPrintUsage(pc, stderr, 0);
682                 exit(EXIT_PARSE_ERROR);
683         }
684
685         path = talloc_strdup(frame, poptGetArg(pc));
686         if (!path) {
687                 printf("Out of memory\n");
688                 exit(EXIT_PARSE_ERROR);
689         }
690
691         poptFreeContext(pc);
692
693         string_replace(path, '/', '\\');
694
695         server = SMB_STRDUP(path+2);
696         if (!server) {
697                 printf("Out of memory\n");
698                 exit(EXIT_PARSE_ERROR);
699         }
700         share = strchr_m(server,'\\');
701         if (!share) {
702                 printf("Invalid argument: %s\n", share);
703                 exit(EXIT_PARSE_ERROR);
704         }
705
706         *share = 0;
707         share++;
708
709         if (todo == SET_QUOTA) {
710                 if (parse_quota_set(talloc_tos(), set_str, &username_str, &qtype, &cmd, &qt)) {
711                         printf("Invalid argument: -S %s\n", set_str);
712                         exit(EXIT_PARSE_ERROR);
713                 }
714         }
715
716         if (!test_args) {
717                 cli = connect_one(share);
718                 if (!cli) {
719                         exit(EXIT_FAILED);
720                 }
721         } else {
722                 exit(EXIT_OK);
723         }
724
725
726         /* Perform requested action */
727
728         switch (todo) {
729                 case FS_QUOTA:
730                         result = do_quota(cli,SMB_USER_FS_QUOTA_TYPE, QUOTA_GET, username_str, NULL);
731                         break;
732                 case LIST_QUOTA:
733                         result = do_quota(cli,SMB_USER_QUOTA_TYPE, QUOTA_LIST, username_str, NULL);
734                         break;
735                 case USER_QUOTA:
736                         result = do_quota(cli,SMB_USER_QUOTA_TYPE, QUOTA_GET, username_str, NULL);
737                         break;
738                 case SET_QUOTA:
739                         result = do_quota(cli, qtype, cmd, username_str, &qt);
740                         break;
741                 default: 
742                         result = EXIT_FAILED;
743                         break;
744         }
745
746         talloc_free(frame);
747
748         return result;
749 }