VirtualBox

Ignore:
Timestamp:
Apr 24, 2008 8:17:46 PM (17 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
30163
Message:

remove some superflous braces; list Darwin and Solaris options as well when all options are listed

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManage.cpp

    r8371 r8373  
    260260        fLinux = true;
    261261        fWin = true;
     262        fSolaris = true;
     263        fDarwin = true;
    262264        fVRDP = true;
    263265        u64Cmd = USAGE_ALL;
    … …  
    24302432    /* at least one option: the UUID or name of the VM */
    24312433    if (argc < 1)
    2432     {
    24332434        return errorSyntax(USAGE_SHOWVMINFO, "Incorrect number of parameters");
    2434     }
    24352435
    24362436    /* try to find the given machine */
    … …  
    25042504    /* exactly one option: the object */
    25052505    if (argc != 1)
    2506     {
    25072506        return errorSyntax(USAGE_LIST, "Incorrect number of parameters");
    2508     }
    25092507
    25102508    /* which object? */
    … …  
    29822980    }
    29832981    else
    2984     {
    29852982        return errorSyntax(USAGE_LIST, "Invalid parameter '%s'", Utf8Str(argv[0]).raw());
    2986     }
     2983
    29872984    return SUCCEEDED(rc) ? 0 : 1;
    29882985}
    … …  
    29942991
    29952992    if (argc != 1)
    2996     {
    29972993        return errorSyntax(USAGE_REGISTERVM, "Incorrect number of parameters");
    2998     }
    29992994
    30002995    ComPtr<IMachine> machine;
    … …  
    30143009
    30153010    if ((argc != 1) && (argc != 2))
    3016     {
    30173011        return errorSyntax(USAGE_UNREGISTERVM, "Incorrect number of parameters");
    3018     }
    30193012
    30203013    ComPtr<IMachine> machine;
    … …  
    30613054        {
    30623055            if (argc <= i + 1)
    3063             {
    30643056                return errorArgument("Missing argument to '%s'", argv[i]);
    3065             }
    30663057            i++;
    30673058            filename = argv[i];
    … …  
    30703061        {
    30713062            if (argc <= i + 1)
    3072             {
    30733063                return errorArgument("Missing argument to '%s'", argv[i]);
    3074             }
    30753064            i++;
    30763065            sizeMB = RTStrToUInt64(argv[i]);
    … …  
    30833072        {
    30843073            if (argc <= i + 1)
    3085             {
    30863074                return errorArgument("Missing argument to '%s'", argv[i]);
    3087             }
    30883075            i++;
    30893076            comment = argv[i];
    … …  
    30963083        {
    30973084            if (argc <= i + 1)
    3098             {
    30993085                return errorArgument("Missing argument to '%s'", argv[i]);
    3100             }
    31013086            i++;
    31023087            type = argv[i];
    31033088        }
    31043089        else
    3105         {
    31063090            return errorSyntax(USAGE_CREATEVDI, "Invalid parameter '%s'", Utf8Str(argv[i]).raw());
    3107         }
    31083091    }
    31093092    /* check the outcome */
    31103093    if (!filename || (sizeMB == 0))
    3111     {
    31123094        return errorSyntax(USAGE_CREATEVDI, "Parameters -filename and -size are required");
    3113     }
     3095
    31143096    if (strcmp(type, "normal") && strcmp(type, "writethrough"))
    3115     {
    31163097        return errorArgument("Invalid VDI type '%s' specified", Utf8Str(type).raw());
    3117     }
    31183098
    31193099    ComPtr<IHardDisk> hardDisk;
    … …  
    31463126                    com::ProgressErrorInfo info(progress);
    31473127                    if (info.isBasicAvailable())
    3148                     {
    31493128                        RTPrintf("Error: failed to create disk image. Error message: %lS\n", info.getText().raw());
    3150                     }
    31513129                    else
    3152                     {
    31533130                        RTPrintf("Error: failed to create disk image. No error message available!\n");
    3154                     }
    31553131                }
    31563132                else
    … …  
    32043180    /* The uuid/filename and a command */
    32053181    if (argc < 2)
    3206     {
    32073182        return errorSyntax(USAGE_MODIFYVDI, "Incorrect number of parameters");
    3208     }
    32093183
    32103184    ComPtr<IHardDisk> hardDisk;
    … …  
    32373211
    32383212            if (argc <= 2)
    3239             {
    32403213                return errorArgument("Missing argument to for settype");
    3241             }
     3214
    32423215            type = argv[2];
    32433216
    … …  
    32673240        }
    32683241        else
    3269         {
    32703242            return errorArgument("Hard disk image not registered");
    3271         }
    32723243    }
    32733244    else if (strcmp(argv[1], "compact") == 0)
    … …  
    32803251            virtualBox->OpenVirtualDiskImage(Bstr(argv[0]), vdi.asOutParam());
    32813252            if (!vdi)
    3282             {
    32833253                return errorArgument("Hard disk image not found");
    3284             }
    32853254        }
    32863255        else
    … …  
    33083277    }
    33093278    else
    3310     {
    33113279        return errorSyntax(USAGE_MODIFYVDI, "Invalid parameter '%s'", Utf8Str(argv[1]).raw());
    3312     }
     3280
    33133281    return SUCCEEDED(rc) ? 0 : 1;
    33143282}
    … …  
    33213289    /* source VDI and target path */
    33223290    if (argc != 2)
    3323     {
    33243291        return errorSyntax(USAGE_CLONEVDI, "Incorrect number of parameters");
    3325     }
    33263292
    33273293    /* first guess is that it's a UUID */
    … …  
    34673433    /* at least server and target */
    34683434    if (argc < 4)
    3469     {
    34703435        return errorSyntax(USAGE_ADDISCSIDISK, "Not enough parameters");
    3471     }
    34723436
    34733437    /* let's have a closer look at the arguments */
    … …  
    34773441        {
    34783442            if (argc <= i + 1)
    3479             {
    34803443                return errorArgument("Missing argument to '%s'", argv[i]);
    3481             }
    34823444            i++;
    34833445            server = argv[i];
    … …  
    34863448        {
    34873449            if (argc <= i + 1)
    3488             {
    34893450                return errorArgument("Missing argument to '%s'", argv[i]);
    3490             }
    34913451            i++;
    34923452            target = argv[i];
    … …  
    34953455        {
    34963456            if (argc <= i + 1)
    3497             {
    34983457                return errorArgument("Missing argument to '%s'", argv[i]);
    3499             }
    35003458            i++;
    35013459            port = atoi(argv[i]);
    … …  
    35053463            /** @todo move the LUN encoding algorithm into IISCSIHardDisk, add decoding */
    35063464            if (argc <= i + 1)
    3507             {
    35083465                return errorArgument("Missing argument to '%s'", argv[i]);
    3509             }
    35103466            i++;
    35113467            char *pszNext;
    … …  
    35273483        {
    35283484            if (argc <= i + 1)
    3529             {
    35303485                return errorArgument("Missing argument to '%s'", argv[i]);
    3531             }
    35323486            i++;
    35333487            char *pszNext;
    … …  
    35393493        {
    35403494            if (argc <= i + 1)
    3541             {
    35423495                return errorArgument("Missing argument to '%s'", argv[i]);
    3543             }
    35443496            i++;
    35453497            username = argv[i];
    … …  
    35483500        {
    35493501            if (argc <= i + 1)
    3550             {
    35513502                return errorArgument("Missing argument to '%s'", argv[i]);
    3552             }
    35533503            i++;
    35543504            password = argv[i];
    … …  
    35573507        {
    35583508            if (argc <= i + 1)
    3559             {
    35603509                return errorArgument("Missing argument to '%s'", argv[i]);
    3561             }
    35623510            i++;
    35633511            comment = argv[i];
    35643512        }
    35653513        else
    3566         {
    35673514            return errorSyntax(USAGE_ADDISCSIDISK, "Invalid parameter '%s'", Utf8Str(argv[i]).raw());
    3568         }
    35693515    }
    35703516
    35713517    /* check for required options */
    35723518    if (!server || !target)
    3573     {
    35743519        return errorSyntax(USAGE_ADDISCSIDISK, "Parameters -server and -target are required");
    3575     }
    35763520
    35773521    ComPtr<IHardDisk> hardDisk;
    … …  
    36223566        {
    36233567            if (argc <= i + 1)
    3624             {
    36253568                return errorArgument("Missing argument to '%s'", argv[i]);
    3626             }
    36273569            i++;
    36283570            baseFolder = argv[i];
    … …  
    36313573        {
    36323574            if (argc <= i + 1)
    3633             {
    36343575                return errorArgument("Missing argument to '%s'", argv[i]);
    3635             }
    36363576            i++;
    36373577            settingsFile = argv[i];
    … …  
    36403580        {
    36413581            if (argc <= i + 1)
    3642             {
    36433582                return errorArgument("Missing argument to '%s'", argv[i]);
    3644             }
    36453583            i++;
    36463584            name = argv[i];
    … …  
    36493587        {
    36503588            if (argc <= i + 1)
    3651             {
    36523589                return errorArgument("Missing argument to '%s'", argv[i]);
    3653             }
    36543590            i++;
    36553591            if (VBOX_FAILURE(RTUuidFromStr(&id, argv[i])))
    3656             {
    36573592                return errorArgument("Invalid UUID format %s\n", argv[i]);
    3658             }
    36593593        }
    36603594        else if (strcmp(argv[i], "-register") == 0)
    … …  
    36633597        }
    36643598        else
    3665         {
    36663599            return errorSyntax(USAGE_CREATEVM, "Invalid parameter '%s'", Utf8Str(argv[i]).raw());
    3667         }
    36683600    }
    36693601    if (!name)
    3670     {
    36713602        return errorSyntax(USAGE_CREATEVM, "Parameter -name is required");
    3672     }
     3603
    36733604    if (!!baseFolder && !!settingsFile)
    3674     {
    36753605        return errorSyntax(USAGE_CREATEVM, "Either -basefolder or -settingsfile must be specified");
    3676     }
    36773606
    36783607    do
    … …  
    38153744        {
    38163745            if (argc <= i + 1)
    3817             {
    38183746                return errorArgument("Missing argument to '%s'", argv[i]);
    3819             }
    38203747            i++;
    38213748            name = argv[i];
    … …  
    38243751        {
    38253752            if (argc <= i + 1)
    3826             {
    38273753                return errorArgument("Missing argument to '%s'", argv[i]);
    3828             }
    38293754            i++;
    38303755            ostype = argv[i];
    … …  
    38333758        {
    38343759            if (argc <= i + 1)
    3835             {
    38363760                return errorArgument("Missing argument to '%s'", argv[i]);
    3837             }
    38383761            i++;
    38393762            memorySize = atoi(argv[i]);
    … …  
    38423765        {
    38433766            if (argc <= i + 1)
    3844             {
    38453767                return errorArgument("Missing argument to '%s'", argv[i]);
    3846             }
    38473768            i++;
    38483769            vramSize = atoi(argv[i]);
    … …  
    38513772        {
    38523773            if (argc <= i + 1)
    3853             {
    38543774                return errorArgument("Missing argument to '%s'", argv[i]);
    3855             }
    38563775            i++;
    38573776            acpi = argv[i];
    … …  
    38603779        {
    38613780            if (argc <= i + 1)
    3862             {
    38633781                return errorArgument("Missing argument to '%s'", argv[i]);
    3864             }
    38653782            i++;
    38663783            ioapic = argv[i];
    … …  
    38693786        {
    38703787            if (argc <= i + 1)
    3871             {
    38723788                return errorArgument("Missing argument to '%s'", argv[i]);
    3873             }
    38743789            i++;
    38753790            hwvirtex = argv[i];
    … …  
    38783793        {
    38793794            if (argc <= i + 1)
    3880             {
    38813795                return errorArgument("Missing argument to '%s'", argv[i]);
    3882             }
    38833796            i++;
    38843797            pae = argv[i];
    … …  
    38873800        {
    38883801            if (argc <= i + 1)
    3889             {
    38903802                return errorArgument("Missing argument to '%s'", argv[i]);
    3891             }
    38923803            i++;
    38933804            monitorcount = atoi(argv[i]);
    … …  
    38963807        {
    38973808            if (argc <= i + 1)
    3898             {
    38993809                return errorArgument("Missing argument to '%s'", argv[i]);
    3900             }
    39013810            i++;
    39023811            bioslogofadein = argv[i];
    … …  
    39053814        {
    39063815            if (argc <= i + 1)
    3907             {
    39083816                return errorArgument("Missing argument to '%s'", argv[i]);
    3909             }
    39103817            i++;
    39113818            bioslogofadeout = argv[i];
    … …  
    39143821        {
    39153822            if (argc <= i + 1)
    3916             {
    39173823                return errorArgument("Missing argument to '%s'", argv[i]);
    3918             }
    39193824            i++;
    39203825            bioslogodisplaytime = atoi(argv[i]);
    … …  
    39233828        {
    39243829            if (argc <= i + 1)
    3925             {
    39263830                return errorArgument("Missing argument to '%s'", argv[i]);
    3927             }
    39283831            i++;
    39293832            bioslogoimagepath = argv[i];
    … …  
    39323835        {
    39333836            if (argc <= i + 1)
    3934             {
    39353837                return errorArgument("Missing argument to '%s'", argv[i]);
    3936             }
    39373838            i++;
    39383839            biosbootmenumode = argv[i];
    … …  
    39413842        {
    39423843            if (argc <= i + 1)
    3943             {
    39443844                return errorArgument("Missing argument to '%s'", argv[i]);
    3945             }
    39463845            i++;
    39473846            biossystemtimeoffset = argv[i];
    … …  
    39503849        {
    39513850            if (argc <= i + 1)
    3952             {
    39533851                return errorArgument("Missing argument to '%s'", argv[i]);
    3954             }
    39553852            i++;
    39563853            biospxedebug = argv[i];
    … …  
    39603857            ULONG n = 0;
    39613858            if (!argv[i][5])
    3962             {
    39633859                return errorSyntax(USAGE_MODIFYVM, "Missing boot slot number in '%s'", argv[i]);
    3964             }
    39653860            if ((n = strtoul(&argv[i][5], NULL, 10)) < 1)
    3966             {
    39673861                return errorSyntax(USAGE_MODIFYVM, "Invalid boot slot number in '%s'", argv[i]);
    3968             }
    39693862            if (argc <= i + 1)
    3970             {
    39713863                return errorArgument("Missing argument to '%s'", argv[i]);
    3972             }
    39733864            i++;
    39743865            if (strcmp(argv[i], "none") == 0)
    … …  
    39933884            }
    39943885            else
    3995             {
    39963886                return errorArgument("Invalid boot device '%s'", argv[i]);
    3997             }
     3887
    39983888            bootDeviceChanged[n - 1] = true;
    39993889        }
    … …  
    40013891        {
    40023892            if (argc <= i + 1)
    4003             {
    40043893                return errorArgument("Missing argument to '%s'", argv[i]);
    4005             }
    40063894            i++;
    40073895            hdds[0] = argv[i];
    … …  
    40103898        {
    40113899            if (argc <= i + 1)
    4012             {
    40133900                return errorArgument("Missing argument to '%s'", argv[i]);
    4014             }
    40153901            i++;
    40163902            hdds[1] = argv[i];
    … …  
    40193905        {
    40203906            if (argc <= i + 1)
    4021             {
    40223907                return errorArgument("Missing argument to '%s'", argv[i]);
    4023             }
    40243908            i++;
    40253909            hdds[2] = argv[i];
    … …  
    40283912        {
    40293913            if (argc <= i + 1)
    4030             {
    40313914                return errorArgument("Missing argument to '%s'", argv[i]);
    4032             }
    40333915            i++;
    40343916            dvd = argv[i];
    … …  
    40373919        {
    40383920            if (argc <= i + 1)
    4039             {
    40403921                return errorArgument("Missing argument to '%s'", argv[i]);
    4041             }
    40423922            i++;
    40433923            dvdpassthrough = argv[i];
    … …  
    40463926        {
    40473927            if (argc <= i + 1)
    4048             {
    40493928                return errorArgument("Missing argument to '%s'", argv[i]);
    4050             }
    40513929            i++;
    40523930            floppy = argv[i];
    … …  
    40553933        {
    40563934            if (argc <= i + 1)
    4057             {
    40583935                return errorArgument("Missing argument to '%s'", argv[i]);
    4059             }
    40603936            i++;
    40613937            audio = argv[i];
    … …  
    40643940        {
    40653941            if (argc <= i + 1)
    4066             {
    40673942                return errorArgument("Missing argument to '%s'", argv[i]);
    4068             }
    40693943            i++;
    40703944            audiocontroller = argv[i];
    … …  
    40733947        {
    40743948            if (argc <= i + 1)
    4075             {
    40763949                return errorArgument("Missing argument to '%s'", argv[i]);
    4077             }
    40783950            i++;
    40793951            clipboard = argv[i];
    … …  
    40843956            if (!n)
    40853957                return 1;
     3958
    40863959            if (argc <= i + 1)
    4087             {
    40883960                return errorArgument("Missing argument to '%s'", argv[i]);
    4089             }
     3961
    40903962            cableconnected[n - 1] = argv[i + 1];
    40913963            i++;
    … …  
    41103982                return 1;
    41113983            if (argc <= i + 1)
    4112             {
    41133984                return errorArgument("Missing argument to '%s'", argv[i]);
    4114             }
    41153985            nictrace[n - 1] = argv[i + 1];
    41163986            i++;
    … …  
    41223992                return 1;
    41233993            if (argc <= i + 1)
    4124             {
    41253994                return errorArgument("Missing argument to '%s'", argv[i]);
    4126             }
    41273995            nictype[n - 1] = argv[i + 1];
    41283996            i++;
    … …  
    41344002                return 1;
    41354003            if (argc <= i + 1)
    4136             {
    41374004                return errorArgument("Missing argument to '%s'", argv[i]);
    4138             }
    41394005            nicspeed[n - 1] = argv[i + 1];
    41404006            i++;
    … …  
    41464012                return 1;
    41474013            if (argc <= i + 1)
    4148             {
    41494014                return errorArgument("Missing argument to '%s'", argv[i]);
    4150             }
    41514015            nics[n - 1] = argv[i + 1];
    41524016            i++;
    … …  
    41584022                return 1;
    41594023            if (argc <= i + 1)
    4160             {
    41614024                return errorArgument("Missing argument to '%s'", argv[i]);
    4162             }
    41634025            hostifdev[n - 1] = argv[i + 1];
    41644026            i++;
    … …  
    41704032                return 1;
    41714033            if (argc <= i + 1)
    4172             {
    41734034                return errorArgument("Missing argument to '%s'", argv[i]);
    4174             }
    41754035            intnet[n - 1] = argv[i + 1];
    41764036            i++;
    … …  
    41824042                return 1;
    41834043            if (argc <= i + 1)
    4184             {
    41854044                return errorArgument("Missing argument to '%s'", argv[i]);
    4186             }
     4045
    41874046            RTIPV4ADDR Network;
    41884047            RTIPV4ADDR Netmask;
    … …  
    42024061                return 1;
    42034062            if (argc <= i + 1)
    4204             {
    42054063                return errorArgument("Missing argument to '%s'", argv[i]);
    4206             }
    42074064            tapsetup[n - 1] = argv[i + 1];
    42084065            i++;
    … …  
    42144071                return 1;
    42154072            if (argc <= i + 1)
    4216             {
    42174073                return errorArgument("Missing argument to '%s'", argv[i]);
    4218             }
    42194074            tapterm[n - 1] = argv[i + 1];
    42204075            i++;
    … …  
    42274082                return 1;
    42284083            if (argc <= i + 1)
    4229             {
    42304084                return errorArgument("Missing argument to '%s'", argv[i]);
    4231             }
    42324085            macs[n - 1] = argv[i + 1];
    42334086            i++;
    … …  
    42374090        {
    42384091            if (argc <= i + 1)
    4239             {
    42404092                return errorArgument("Missing argument to '%s'", argv[i]);
    4241             }
    42424093            i++;
    42434094            vrdp = argv[i];
    … …  
    42464097        {
    42474098            if (argc <= i + 1)
    4248             {
    42494099                return errorArgument("Missing argument to '%s'", argv[i]);
    4250             }
    42514100            i++;
    42524101            if (strcmp(argv[i], "default") == 0)
    … …  
    42584107        {
    42594108            if (argc <= i + 1)
    4260             {
    42614109                return errorArgument("Missing argument to '%s'", argv[i]);
    4262             }
    42634110            i++;
    42644111            vrdpaddress = argv[i];
    … …  
    42674114        {
    42684115            if (argc <= i + 1)
    4269             {
    42704116                return errorArgument("Missing argument to '%s'", argv[i]);
    4271             }
    42724117            i++;
    42734118            vrdpauthtype = argv[i];
    … …  
    42764121        {
    42774122            if (argc <= i + 1)
    4278             {
    42794123                return errorArgument("Missing argument to '%s'", argv[i]);
    4280             }
    42814124            i++;
    42824125            vrdpmulticon = argv[i];
    … …  
    42864129        {
    42874130            if (argc <= i + 1)
    4288             {
    42894131                return errorArgument("Missing argument to '%s'", argv[i]);
    4290             }
    42914132            i++;
    42924133            if (strcmp(argv[i], "on") == 0 || strcmp(argv[i], "enable") == 0)
    … …  
    43004141        {
    43014142            if (argc <= i + 1)
    4302             {
    43034143                return errorArgument("Missing argument to '%s'", argv[i]);
    4304             }
    43054144            i++;
    43064145            if (strcmp(argv[i], "on") == 0 || strcmp(argv[i], "enable") == 0)
    … …  
    43144153        {
    43154154            if (argc <= i + 1)
    4316             {
    43174155                return errorArgument("Missing argument to '%s'", argv[i]);
    4318             }
    43194156            i++;
    43204157            snapshotFolder = argv[i];
    … …  
    43464183                }
    43474184                if (argc <= i)
    4348                 {
    43494185                    return errorArgument("Missing argument to -uartmode");
    4350                 }
    43514186                uarts_path[n - 1] = argv[i];
    43524187            }
    … …  
    43584193                return 1;
    43594194            if (argc <= i + 1)
    4360             {
    43614195                return errorArgument("Missing argument to '%s'", argv[i]);
    4362             }
    43634196            i++;
    43644197            if (strcmp(argv[i], "off") == 0 || strcmp(argv[i], "disable") == 0)
    … …  
    43694202            {
    43704203                if (argc <= i + 1)
    4371                 {
    43724204                    return errorArgument("Missing argument to '%s'", argv[i-1]);
    4373                 }
    43744205                uint32_t uVal;
    43754206                int vrc;
    … …  
    44144245        {
    44154246            if (argc <= i + 1)
    4416             {
    44174247                return errorArgument("Missing argument to '%s'", argv[i]);
    4418             }
    44194248            i++;
    44204249            if (strcmp(argv[i], "on") == 0 || strcmp(argv[i], "enable") == 0)
    … …  
    44304259
    44314260            if (argc <= i + 1)
    4432             {
    44334261                return errorArgument("Missing arguments to '%s'", argv[i]);
    4434             }
    44354262            i++;
    44364263
    … …  
    44464273                return 1;
    44474274            if (argc <= i + 1)
    4448             {
    44494275                return errorArgument("Missing argument to '%s'", argv[i]);
    4450             }
    44514276            i++;
    44524277            hdds[n-1+4] = argv[i];
    … …  
    44634288
    44644289            if (argc <= i + 1)
    4465             {
    44664290                return errorArgument("Missing arguments to '%s'", argv[i]);
    4467             }
    44684291            i++;
    44694292
    … …  
    44754298        }
    44764299        else
    4477         {
    44784300            return errorSyntax(USAGE_MODIFYVM, "Invalid parameter '%s'", Utf8Str(argv[i]).raw());
    4479         }
    44804301    }
    44814302
    … …  
    55725393
    55735394    if (argc < 1)
    5574     {
    55755395        return errorSyntax(USAGE_STARTVM, "Not enough parameters");
    5576     }
    55775396
    55785397    ComPtr<IMachine> machine;
    … …  
    56075426            }
    56085427            else
    5609             {
    56105428                return errorArgument("Invalid session type argument '%s'", argv[2]);
    5611             }
    56125429        }
    56135430
    … …  
    56585475
    56595476    if (argc < 2)
    5660     {
    56615477        return errorSyntax(USAGE_CONTROLVM, "Not enough parameters");
    5662     }
    56635478
    56645479    /* try to find the given machine */
    … …  
    60715886
    60725887    if (argc != 1)
    6073     {
    60745888        return errorSyntax(USAGE_DISCARDSTATE, "Incorrect number of parameters");
    6075     }
    60765889
    60775890    ComPtr<IMachine> machine;
    … …  
    61125925
    61135926    if (argc != 2)
    6114     {
    61155927        return errorSyntax(USAGE_ADOPTSTATE, "Incorrect number of parameters");
    6116     }
    61175928
    61185929    ComPtr<IMachine> machine;
    … …  
    61545965    /* we need at least a VM and a command */
    61555966    if (argc < 2)
    6156     {
    61575967        return errorSyntax(USAGE_SNAPSHOT, "Not enough parameters");
    6158     }
    61595968
    61605969    /* the first argument must be the VM */
    … …  
    62106019                com::ProgressErrorInfo info(progress);
    62116020                if (info.isBasicAvailable())
    6212                 {
    62136021                    RTPrintf("Error: failed to take snapshot. Error message: %lS\n", info.getText().raw());
    6214                 }
    62156022                else
    6216                 {
    62176023                    RTPrintf("Error: failed to take snapshot. No error message available!\n");
    6218                 }
    62196024            }
    62206025        }
    … …  
    62546059                com::ProgressErrorInfo info(progress);
    62556060                if (info.isBasicAvailable())
    6256                 {
    62576061                    RTPrintf("Error: failed to discard snapshot. Error message: %lS\n", info.getText().raw());
    6258                 }
    62596062                else
    6260                 {
    62616063                    RTPrintf("Error: failed to discard snapshot. No error message available!\n");
    6262                 }
    62636064            }
    62646065        }
    … …  
    62946095                com::ProgressErrorInfo info(progress);
    62956096                if (info.isBasicAvailable())
    6296                 {
    62976097                    RTPrintf("Error: failed to discard. Error message: %lS\n", info.getText().raw());
    6298                 }
    62996098                else
    6300                 {
    63016099                    RTPrintf("Error: failed to discard. No error message available!\n");
    6302                 }
    63036100            }
    63046101
    … …  
    64156212
    64166213    if (argc != 1)
    6417     {
    64186214        return errorSyntax(USAGE_SHOWVDIINFO, "Incorrect number of parameters");
    6419     }
    64206215
    64216216    ComPtr<IHardDisk> hardDisk;
    … …  
    65426337
    65436338    if (argc < 2)
    6544     {
    65456339        return errorSyntax(USAGE_REGISTERIMAGE, "Not enough parameters");
    6546     }
    65476340
    65486341    Bstr filepath(argv[1]);
    … …  
    65536346        /* there can be a type parameter */
    65546347        if ((argc > 2) && (argc != 4))
    6555         {
    65566348            return errorSyntax(USAGE_REGISTERIMAGE, "Incorrect number of parameters");
    6557         }
    65586349        if (argc == 4)
    65596350        {
    65606351            if (strcmp(argv[2], "-type") != 0)
    6561             {
    65626352                return errorSyntax(USAGE_REGISTERIMAGE, "Invalid parameter '%s'", Utf8Str(argv[2]).raw());
    6563             }
    65646353            if (   (strcmp(argv[3], "normal") != 0)
    65656354                && (strcmp(argv[3], "immutable") != 0)
    65666355                && (strcmp(argv[3], "writethrough") != 0))
    6567             {
    65686356                return errorArgument("Invalid VDI type '%s' specified", Utf8Str(argv[3]).raw());
    6569             }
    65706357            type = argv[3];
    65716358        }
    … …  
    66086395    }
    66096396    else
    6610     {
    66116397        return errorSyntax(USAGE_REGISTERIMAGE, "Invalid parameter '%s'", Utf8Str(argv[1]).raw());
    6612     }
     6398
    66136399    return SUCCEEDED(rc) ? 0 : 1;
    66146400}
    … …  
    66206406
    66216407    if (argc != 2)
    6622     {
    66236408        return errorSyntax(USAGE_UNREGISTERIMAGE, "Incorrect number of parameters");
    6624     }
    66256409
    66266410    /* first guess is that it's a UUID */
    … …  
    66816465    }
    66826466    else
    6683     {
    66846467        return errorSyntax(USAGE_UNREGISTERIMAGE, "Invalid parameter '%s'", Utf8Str(argv[1]).raw());
    6685     }
     6468
    66866469    return SUCCEEDED(rc) ? 0 : 1;
    66876470}
    … …  
    66926475{
    66936476    if (argc != 1)
    6694     {
    66956477        return errorSyntax(USAGE_CREATEHOSTIF, "Incorrect number of parameters");
    6696     }
    66976478
    66986479    HRESULT rc = S_OK;
    … …  
    67296510{
    67306511    if (argc != 1)
    6731     {
    67326512        return errorSyntax(USAGE_REMOVEHOSTIF, "Incorrect number of parameters");
    6733     }
    67346513
    67356514    HRESULT rc = S_OK;
    … …  
    67816560
    67826561    if (argc != 2)
    6783     {
    67846562        return errorSyntax(USAGE_GETEXTRADATA, "Incorrect number of parameters");
    6785     }
     6563
    67866564    /* global data? */
    67876565    if (strcmp(argv[0], "global") == 0)
    … …  
    68016579
    68026580                if (SUCCEEDED(rcEnum) && extraDataKey)
    6803                 {
    68046581                    RTPrintf("Key: %lS, Value: %lS\n", nextExtraDataKey.raw(), nextExtraDataValue.raw());
    6805                 }
    68066582            } while (extraDataKey);
    68076583        }
    … …  
    68676643
    68686644    if (argc < 2)
    6869     {
    68706645        return errorSyntax(USAGE_SETEXTRADATA, "Not enough parameters");
    6871     }
     6646
    68726647    /* global data? */
    68736648    if (strcmp(argv[0], "global") == 0)
    … …  
    69106685    /* there must be two arguments: property name and value */
    69116686    if (argc != 2)
    6912     {
    69136687        return errorSyntax(USAGE_SETPROPERTY, "Incorrect number of parameters");
    6914     }
     6688
    69156689    ComPtr<ISystemProperties> systemProperties;
    69166690    virtualBox->COMGETTER(SystemProperties)(systemProperties.asOutParam());
    … …  
    69806754    /* at least: 0: command, 1: index, 2: -target, 3: <target value> */
    69816755    if (argc < 4)
    6982     {
    69836756        return errorSyntax(USAGE_USBFILTER, "Not enough parameters");
    6984     }
    69856757
    69866758    /* which command? */
    … …  
    69916763
    69926764    if (cmd.mAction == USBFilterCmd::Invalid)
    6993     {
    69946765        return errorSyntax(USAGE_USBFILTER, "Invalid parameter '%s'", argv[0]);
    6995     }
    69966766
    69976767    /* which index? */
    … …  
    69996769    cmd.mIndex = strtoul (argv[1], &endptr, 10);
    70006770    if (!endptr || *endptr)
    7001     {
    70026771        return errorSyntax(USAGE_USBFILTER, "Invalid index '%s'", argv[1]);
    7003     }
    70046772
    70056773    switch (cmd.mAction)
    … …  
    70126780            {
    70136781                if (cmd.mAction == USBFilterCmd::Add)
    7014                 {
    70156782                    return errorSyntax(USAGE_USBFILTER_ADD, "Not enough parameters");
    7016                 }
     6783
    70176784                return errorSyntax(USAGE_USBFILTER_MODIFY, "Not enough parameters");
    70186785            }
    … …  
    70296796                {
    70306797                    if (argc <= i + 1 || !*argv[i+1])
    7031                     {
    70326798                        return errorArgument("Missing argument to '%s'", argv[i]);
    7033                     }
    70346799                    i++;
    70356800                    if (strcmp (argv [i], "global") == 0)
    … …  
    70496814                {
    70506815                    if (argc <= i + 1 || !*argv[i+1])
    7051                     {
    70526816                        return errorArgument("Missing argument to '%s'", argv[i]);
    7053                     }
    70546817                    i++;
    70556818                    cmd.mFilter.mName = argv [i];
    … …  
    70586821                {
    70596822                    if (argc <= i + 1)
    7060                     {
    70616823                        return errorArgument("Missing argument to '%s'", argv[i]);
    7062                     }
    70636824                    i++;
    70646825                    if (strcmp (argv [i], "yes") == 0)
    … …  
    70676828                        cmd.mFilter.mActive = false;
    70686829                    else
    7069                     {
    70706830                        return errorArgument("Invalid -active argument '%s'", argv[i]);
    7071                     }
    70726831                }
    70736832                else if (strcmp(argv [i], "-vendorid") == 0)
    70746833                {
    70756834                    if (argc <= i + 1)
    7076                     {
    70776835                        return errorArgument("Missing argument to '%s'", argv[i]);
    7078                     }
    70796836                    i++;
    70806837                    cmd.mFilter.mVendorId = argv [i];
    … …  
    70836840                {
    70846841                    if (argc <= i + 1)
    7085                     {
    70866842                        return errorArgument("Missing argument to '%s'", argv[i]);
    7087                     }
    70886843                    i++;
    70896844                    cmd.mFilter.mProductId = argv [i];
    … …  
    70926847                {
    70936848                    if (argc <= i + 1)
    7094                     {
    70956849                        return errorArgument("Missing argument to '%s'", argv[i]);
    7096                     }
    70976850                    i++;
    70986851                    cmd.mFilter.mRevision = argv [i];
    … …  
    71016854                {
    71026855                    if (argc <= i + 1)
    7103                     {
    71046856                        return errorArgument("Missing argument to '%s'", argv[i]);
    7105                     }
    71066857                    i++;
    71076858                    cmd.mFilter.mManufacturer = argv [i];
    … …  
    71106861                {
    71116862                    if (argc <= i + 1)
    7112                     {
    71136863                        return errorArgument("Missing argument to '%s'", argv[i]);
    7114                     }
    71156864                    i++;
    71166865                    cmd.mFilter.mProduct = argv [i];
    … …  
    71196868                {
    71206869                    if (argc <= i + 1)
    7121                     {
    71226870                        return errorArgument("Missing argument to '%s'", argv[i]);
    7123                     }
    71246871                    i++;
    71256872                    cmd.mFilter.mRemote = argv[i];
    … …  
    71286875                {
    71296876                    if (argc <= i + 1)
    7130                     {
    71316877                        return errorArgument("Missing argument to '%s'", argv[i]);
    7132                     }
    71336878                    i++;
    71346879                    cmd.mFilter.mSerialNumber = argv [i];
    … …  
    71376882                {
    71386883                    if (argc <= i + 1)
    7139                     {
    71406884                        return errorArgument("Missing argument to '%s'", argv[i]);
    7141                     }
    71426885                    i++;
    71436886                    uint32_t u32;
    71446887                    rc = RTStrToUInt32Full(argv[i], 0, &u32);
    71456888                    if (RT_FAILURE(rc))
    7146                     {
    71476889                        return errorArgument("Failed to convert the -maskedinterfaces value '%s' to a number, rc=%Rrc", argv[i], rc);
    7148                     }
    71496890                    cmd.mFilter.mMaskedInterfaces = u32;
    71506891                }
    … …  
    71526893                {
    71536894                    if (argc <= i + 1)
    7154                     {
    71556895                        return errorArgument("Missing argument to '%s'", argv[i]);
    7156                     }
    71576896                    i++;
    71586897                    if (strcmp (argv [i], "ignore") == 0)
    … …  
    71616900                        cmd.mFilter.mAction = USBDeviceFilterAction_Hold;
    71626901                    else
    7163                     {
    71646902                        return errorArgument("Invalid USB filter action '%s'", argv[i]);
    7165                     }
    71666903                }
    71676904                else
    7168                 {
    71696905                    return errorSyntax(cmd.mAction == USBFilterCmd::Add ? USAGE_USBFILTER_ADD : USAGE_USBFILTER_MODIFY,
    71706906                                       "Unknown option '%s'", argv[i]);
    7171                 }
    71726907            }
    71736908
    … …  
    71966931            /* at least: 0: command, 1: index, 2: -target, 3: <target value> */
    71976932            if (argc < 4)
    7198             {
    71996933                return errorSyntax(USAGE_USBFILTER_REMOVE, "Not enough parameters");
    7200             }
    72016934
    72026935            for (int i = 2; i < argc; i++)
    … …  
    72056938                {
    72066939                    if (argc <= i + 1 || !*argv[i+1])
    7207                     {
    72086940                        return errorArgument("Missing argument to '%s'", argv[i]);
    7209                     }
    72106941                    i++;
    72116942                    if (strcmp (argv [i], "global") == 0)
    … …  
    72266957            // mandatory options
    72276958            if (!cmd.mGlobal && !cmd.mMachine)
    7228             {
    72296959                return errorSyntax(USAGE_USBFILTER_REMOVE, "Mandatory options not supplied");
    7230             }
    72316960
    72326961            break;
    … …  
    74027131    /* we need at least a command and target */
    74037132    if (argc < 2)
    7404     {
    74057133        return errorSyntax(USAGE_SHAREDFOLDER, "Not enough parameters");
    7406     }
    74077134
    74087135    ComPtr<IMachine> machine;
    … …  
    74237150        /* we need at least four more parameters */
    74247151        if (argc < 5)
    7425         {
    74267152            return errorSyntax(USAGE_SHAREDFOLDER_ADD, "Not enough parameters");
    7427         }
    74287153
    74297154        char *name = NULL;
    … …  
    74377162            {
    74387163                if (argc <= i + 1 || !*argv[i+1])
    7439                 {
    74407164                    return errorArgument("Missing argument to '%s'", argv[i]);
    7441                 }
    74427165                i++;
    74437166                name = argv[i];
    … …  
    74467169            {
    74477170                if (argc <= i + 1 || !*argv[i+1])
    7448                 {
    74497171                    return errorArgument("Missing argument to '%s'", argv[i]);
    7450                 }
    74517172                i++;
    74527173                hostpath = argv[i];
    … …  
    74617182            }
    74627183            else
    7463             {
    74647184                return errorSyntax(USAGE_SHAREDFOLDER_ADD, "Invalid parameter '%s'", Utf8Str(argv[i]).raw());
    7465             }
    74667185        }
    74677186
    … …  
    75087227        /* we need at least two more parameters */
    75097228        if (argc < 3)
    7510         {
    75117229            return errorSyntax(USAGE_SHAREDFOLDER_REMOVE, "Not enough parameters");
    7512         }
    75137230
    75147231        char *name = NULL;
    … …  
    75207237            {
    75217238                if (argc <= i + 1 || !*argv[i+1])
    7522                 {
    75237239                    return errorArgument("Missing argument to '%s'", argv[i]);
    7524                 }
    75257240                i++;
    75267241                name = argv[i];
    … …  
    75317246            }
    75327247            else
    7533             {
    75347248                return errorSyntax(USAGE_SHAREDFOLDER_REMOVE, "Invalid parameter '%s'", Utf8Str(argv[i]).raw());
    7535             }
    75367249        }
    75377250
    75387251        /* required arguments */
    75397252        if (!name)
    7540         {
    75417253            return errorSyntax(USAGE_SHAREDFOLDER_REMOVE, "Parameter -name is required");
    7542         }
    75437254
    75447255        if (fTransient)
    … …  
    75747285    }
    75757286    else
    7576     {
    75777287        return errorSyntax(USAGE_SETPROPERTY, "Invalid parameter '%s'", Utf8Str(argv[0]).raw());
    7578     }
     7288
    75797289    return 0;
    75807290}
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette