Changeset 586

Show
Ignore:
Timestamp:
05/14/07 02:14:26 (2 years ago)
Author:
chtekk
Message:

Update TODO. Fixup vcc/vce, and make the four vcd-provided tools consistent and easily readable.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/TODO

    r574 r586  
    88NEEDED FEATURES: 
    99- debian/ dir, RPM .spec file, init scripts (done for Gentoo!), distrib make targets, pathprog probably 
     10- support _ and - in vserver names (needs a new string checking function in Lucid) 
    1011 
    1112WANTED FEATURES: 
  • trunk/src/vcc/vcc/create.c

    r548 r586  
    2525void cmd_create(xmlrpc_env *env, int argc, char **argv) 
    2626{ 
    27         char *name, *template, *vdir = ""
     27        char *name, *template, *vdir
    2828        int force = 0, copy = 0; 
    2929 
     
    4242        if (argc > 4) 
    4343                vdir = argv[4]; 
     44        else 
     45                vdir = ""; 
    4446 
    45         client_call("vx.create", "{s:s,s:s,s:b,s:b,s:s}", 
    46                         "name", name, 
    47                         "template", template, 
    48                         "force", force, 
    49                         "copy", copy, 
    50                         "vdir", vdir); 
     47        client_call("vx.create", 
     48                "{s:s,s:s,s:b,s:b,s:s}", 
     49                "name", name, 
     50                "template", template, 
     51                "force", force, 
     52                "copy", copy, 
     53                "vdir", vdir); 
    5154} 
  • trunk/src/vcc/vcc/exec.c

    r548 r586  
    4343                log_perror_and_die("strtok_tostr"); 
    4444 
    45         result = client_call("vx.exec", "{s:s,s:s}", "name", name, 
    46                         "command", command); 
     45        result = client_call("vx.exec", 
     46                "{s:s,s:s}", 
     47                "name", name, 
     48                "command", command); 
    4749        return_if_fault(env); 
    4850 
     
    5052        return_if_fault(env); 
    5153 
    52         printf("%s", output); 
     54        printf("%s\n", output); 
    5355 
    5456        xmlrpc_DECREF(result); 
  • trunk/src/vcc/vcc/kill.c

    r548 r586  
    2525void cmd_kill(xmlrpc_env *env, int argc, char **argv) 
    2626{ 
     27        char *name; 
    2728        int pid = 0, sig = 0; 
    2829 
     
    3031                usage(EXIT_FAILURE); 
    3132 
    32         char *name = argv[0]; 
    33  
     33        name = argv[0]; 
    3434        sscanf(argv[1], "%d", &pid); 
    3535        sscanf(argv[2], "%d", &sig); 
    3636 
    37         client_call("vx.kill", "{s:s,s:i,s:i}", 
    38                         "name", name, 
    39                         "pid", pid, 
    40                         "sig", sig); 
     37        client_call("vx.kill", 
     38                "{s:s,s:i,s:i}", 
     39                "name", name, 
     40                "pid", pid, 
     41                "sig", sig); 
    4142} 
  • trunk/src/vcc/vcc/list.c

    r548 r586  
    2424{ 
    2525        xmlrpc_value *response, *result; 
    26         char *username = ""
     26        char *username
    2727        int len, i; 
    2828 
    2929        if (argc > 0) 
    3030                username = argv[0]; 
     31        else 
     32                username = ""; 
    3133 
    32         response = client_call("vxdb.list", "{s:s}", "username", username); 
     34        response = client_call("vxdb.list", 
     35                "{s:s}", 
     36                "username", username); 
    3337        return_if_fault(env); 
    3438 
  • trunk/src/vcc/vcc/login.c

    r548 r586  
    3838        name = argv[0]; 
    3939 
    40         result = client_call("vxdb.xid.get", "{s:s}", "name", name); 
     40        result = client_call("vxdb.xid.get", 
     41                "{s:s}", 
     42                "name", name); 
    4143        return_if_fault(env); 
    4244 
     
    4648        xmlrpc_DECREF(result); 
    4749 
    48         result = client_call("vxdb.vdir.get", "{s:s}", "name", name); 
     50        result = client_call("vxdb.vdir.get", 
     51                "{s:s}", 
     52                "name", name); 
    4953        return_if_fault(env); 
    5054 
     
    5559 
    5660        if (ns_enter(xid, 0) == -1) 
    57                 log_perror_and_die("vx_enter_namespace"); 
     61                log_perror_and_die("ns_enter"); 
    5862 
    5963        if (chroot_secure_chdir(vdir, "/") == -1) 
  • trunk/src/vcc/vcc/reboot.c

    r548 r586  
    2323void cmd_reboot(xmlrpc_env *env, int argc, char **argv) 
    2424{ 
     25        char *name; 
     26 
    2527        if (argc < 1) 
    2628                usage(EXIT_FAILURE); 
    2729 
    28         char *name = argv[0]; 
     30        name = argv[0]; 
    2931 
    30         client_call("vx.reboot", "{s:s}", "name", name); 
     32        client_call("vx.reboot", 
     33                "{s:s}", 
     34                "name", name); 
    3135} 
  • trunk/src/vcc/vcc/remove.c

    r548 r586  
    2323void cmd_remove(xmlrpc_env *env, int argc, char **argv) 
    2424{ 
     25        char *name; 
     26 
    2527        if (argc < 1) 
    2628                usage(EXIT_FAILURE); 
    2729 
    28         char *name = argv[0]; 
     30        name = argv[0]; 
    2931 
    30         client_call("vx.remove", "{s:s}", "name", name); 
     32        client_call("vx.remove", 
     33                "{s:s}", 
     34                "name", name); 
    3135} 
  • trunk/src/vcc/vcc/rename.c

    r548 r586  
    3131        newname = argv[1]; 
    3232 
    33         client_call("vx.rename", "{s:s,s:s}", "name", name, "newname", newname); 
     33        client_call("vx.rename", 
     34                "{s:s,s:s}", 
     35                "name", name, 
     36                "newname", newname); 
    3437} 
  • trunk/src/vcc/vcc/restart.c

    r548 r586  
    1717 
    1818#include <stdlib.h> 
     19 
    1920#include "vcc.h" 
    2021#include "cmd.h" 
     
    2223void cmd_restart(xmlrpc_env *env, int argc, char **argv) 
    2324{ 
     25        char *name; 
     26 
    2427        if (argc < 1) 
    2528                usage(EXIT_FAILURE); 
    2629 
    27         char *name = argv[0]; 
     30        name = argv[0]; 
    2831 
    29         client_call("vx.restart", "{s:s}", "name", name); 
     32        client_call("vx.restart", 
     33                "{s:s}", 
     34                "name", name); 
    3035} 
  • trunk/src/vcc/vcc/start.c

    r548 r586  
    2323void cmd_start(xmlrpc_env *env, int argc, char **argv) 
    2424{ 
     25        char *name; 
     26 
    2527        if (argc < 1) 
    2628                usage(EXIT_FAILURE); 
    2729 
    28         char *name = argv[0]; 
     30        name = argv[0]; 
    2931 
    30         client_call("vx.start", "{s:s}", "name", name); 
     32        client_call("vx.start", 
     33                "{s:s}", 
     34                "name", name); 
    3135} 
  • trunk/src/vcc/vcc/status.c

    r579 r586  
    5050{ 
    5151        xmlrpc_value *result; 
    52         int running, nproc, uptime; 
     52        char *name; 
     53        int running = 0, nproc = 0, uptime = 0; 
    5354        char *loadavg1m, *loadavg5m, *loadavg15m; 
    5455 
     
    5657                usage(EXIT_FAILURE); 
    5758 
    58         char *name = argv[0]; 
     59        name = argv[0]; 
    5960 
    60         result = client_call("vx.status", "{s:s}", "name", name); 
     61        result = client_call("vx.status", 
     62                "{s:s}", 
     63                "name", name); 
    6164        return_if_fault(env); 
    6265 
  • trunk/src/vcc/vcc/stop.c

    r548 r586  
    2323void cmd_stop(xmlrpc_env *env, int argc, char **argv) 
    2424{ 
     25        char *name; 
     26 
    2527        if (argc < 1) 
    2628                usage(EXIT_FAILURE); 
    2729 
    28         char *name = argv[0]; 
     30        name = argv[0]; 
    2931 
    30         client_call("vx.stop", "{s:s}", "name", name); 
     32        client_call("vx.stop", 
     33                "{s:s}", 
     34                "name", name); 
    3135} 
  • trunk/src/vcc/vcc/templates.c

    r548 r586  
    2424{ 
    2525        xmlrpc_value *response, *result; 
    26         char *name = "", *description; 
     26        char *name, *description; 
    2727        int len, i; 
    2828 
    2929        if (argc > 0) 
    3030                name = argv[0]; 
     31        else 
     32                name = ""; 
    3133 
    32         response = client_call("vx.templates", "{s:s}", "name", name); 
     34        response = client_call("vx.templates", 
     35                "{s:s}", 
     36                "name", name); 
    3337        return_if_fault(env); 
    3438 
     
    4044                return_if_fault(env); 
    4145 
    42                 xmlrpc_decompose_value(env, result, "{s:s,s:s,*}", 
     46                xmlrpc_decompose_value(env, result, 
     47                                "{s:s,s:s,*}", 
    4348                                "name", &name, 
    4449                                "description", &description); 
  • trunk/src/vcc/vcdadm/status.c

    r547 r586  
    4848{ 
    4949        xmlrpc_value *result; 
    50         int uptime, requests, nomethod, flogins
     50        int uptime = 0, requests = 0, nomethod = 0, flogins = 0
    5151 
    5252        result = client_call0("vcd.status"); 
  • trunk/src/vcc/vcdadm/user.c

    r585 r586  
    3535                username = ""; 
    3636 
    37         response = client_call("vcd.user.get", "{s:s}", 
     37        response = client_call("vcd.user.get", 
     38                "{s:s}", 
    3839                "username", username); 
    3940        return_if_fault(env); 
     
    7071        username = argv[0]; 
    7172 
    72         client_call("vcd.user.remove", "{s:s}", 
     73        client_call("vcd.user.remove", 
     74                "{s:s}", 
    7375                "username", username); 
    7476} 
     
    7779{ 
    7880        char *username, *password; 
    79         int admin
     81        int admin = 0
    8082 
    8183        if (argc < 2) 
     
    8385 
    8486        username = argv[0]; 
    85  
    8687        sscanf(argv[1], "%d", &admin); 
    8788 
     
    9192                password = ""; 
    9293 
    93         client_call("vcd.user.set", "{s:s,s:s,s:b}", 
     94        client_call("vcd.user.set", 
     95                "{s:s,s:s,s:b}", 
    9496                "username", username, 
    9597                "password", password, 
  • trunk/src/vcc/vcdadm/user_caps.c

    r585 r586  
    3333        cap = argv[1]; 
    3434 
    35         client_call("vcd.user.caps.add", "{s:s,s:s}", 
    36                         "username", username, 
    37                         "cap", cap); 
     35        client_call("vcd.user.caps.add", 
     36                "{s:s,s:s}", 
     37                "username", username, 
     38                "cap", cap); 
    3839} 
    3940 
     
    4950        username = argv[0]; 
    5051 
    51         response = client_call("vcd.user.caps.get", "{s:s}", 
    52                         "username", username); 
     52        response = client_call("vcd.user.caps.get", 
     53                "{s:s}", 
     54                "username", username); 
    5355        return_if_fault(env); 
    5456 
     
    8587                cap = ""; 
    8688 
    87         client_call("vcd.user.caps.remove", "{s:s,s:s}", 
     89        client_call("vcd.user.caps.remove", 
     90                "{s:s,s:s}", 
    8891                "username", username, 
    8992                "cap", cap); 
  • trunk/src/vcc/vce/dx_limit.c

    r550 r586  
    2727void cmd_dx_limit_get(xmlrpc_env *env, int argc, char **argv) 
    2828{ 
    29         char *space, *inodes; 
    30         int reserved; 
    3129        xmlrpc_value *response; 
     30        char *name, *space, *inodes; 
     31        int reserved = 0; 
    3232 
    3333        if (argc < 1) 
    3434                usage(EXIT_FAILURE); 
    3535 
    36         char *name = argv[0]; 
     36        name = argv[0]; 
    3737 
    3838        response = client_call("vxdb.dx.limit.get", 
     
    5656void cmd_dx_limit_remove(xmlrpc_env *env, int argc, char **argv) 
    5757{ 
     58        char *name; 
     59 
    5860        if (argc < 1) 
    5961                usage(EXIT_FAILURE); 
    6062 
    61         char *name = argv[0]; 
     63        name = argv[0]; 
    6264 
    6365        client_call("vxdb.dx.limit.remove", 
     
    6971{ 
    7072        char *name, *space, *inodes; 
    71         int reserved
     73        int reserved = 0
    7274 
    7375        if (argc < 4) 
  • trunk/src/vcc/vce/init.c

    r550 r586  
    2626void cmd_init_get(xmlrpc_env *env, int argc, char **argv) 
    2727{ 
    28         char *init, *halt, *reboot; 
    29         int timeout; 
    3028        xmlrpc_value *response; 
     29        char *name, *init, *halt, *reboot; 
     30        int timeout = 0; 
    3131 
    3232        if (argc < 1) 
    3333                usage(EXIT_FAILURE); 
    3434 
    35         char *name = argv[0]; 
     35        name = argv[0]; 
    3636 
    37         response = client_call("vxdb.init.get", "{s:s}", "name", name); 
     37        response = client_call("vxdb.init.get", 
     38                "{s:s}", 
     39                "name", name); 
    3840        return_if_fault(env); 
    3941 
     
    5658void cmd_init_set(xmlrpc_env *env, int argc, char **argv) 
    5759{ 
    58         char *init, *halt, *reboot; 
    59         int timeout
     60        char *name, *init, *halt, *reboot; 
     61        int timeout = 0
    6062 
    6163        if (argc < 1) 
    6264                usage(EXIT_FAILURE); 
    6365 
    64         char *name = argv[0]; 
     66        name = argv[0]; 
    6567 
    6668        if (argc > 1) 
     
    8183        if (argc > 4) 
    8284                sscanf(argv[4], "%d", &timeout); 
    83         else 
    84                 timeout = 0; 
    8585 
    86         client_call("vxdb.init.set", "{s:s,s:s,s:s,s:s,s:i}", 
     86        client_call("vxdb.init.set", 
     87                "{s:s,s:s,s:s,s:s,s:i}", 
    8788                "name", name, 
    8889                "init", init, 
  • trunk/src/vcc/vce/list.c

    r550 r586  
    2424{ 
    2525        xmlrpc_value *response, *result; 
    26         char *username = ""
     26        char *username
    2727        int len, i; 
    2828 
    2929        if (argc > 0) 
    3030                username = argv[0]; 
     31        else 
     32                username = ""; 
    3133 
    3234        response = client_call("vxdb.list", 
  • trunk/src/vcc/vce/mount.c

    r550 r586  
    2525void cmd_mount_get(xmlrpc_env *env, int argc, char **argv) 
    2626{ 
    27         char *src, *dst, *type, *opts; 
    2827        xmlrpc_value *response, *result; 
     28        char *name, *src, *dst, *type, *opts; 
    2929        int len, i; 
    3030 
     
    3232                usage(EXIT_FAILURE); 
    3333 
    34         char *name = argv[0]; 
     34        name = argv[0]; 
    3535 
    36         if (argc < 2) 
     36        if (argc > 1) 
     37                dst = argv[1]; 
     38        else 
    3739                dst = ""; 
    38         else 
    39                 dst = argv[1]; 
    4040 
    41         response = client_call("vxdb.mount.get", "{s:s,s:s}", 
     41        response = client_call("vxdb.mount.get", 
     42                "{s:s,s:s}", 
    4243                "name", name, 
    4344                "dst", dst); 
     
    6970void cmd_mount_remove(xmlrpc_env *env, int argc, char **argv) 
    7071{ 
    71         char *dst; 
     72        char *name, *dst; 
    7273 
    7374        if (argc < 1) 
    7475                usage(EXIT_FAILURE); 
    7576 
    76         char *name = argv[0]; 
     77        name = argv[0]; 
    7778 
    78         if (argc < 2) 
     79        if (argc > 1) 
     80                dst = argv[1]; 
     81        else 
    7982                dst = ""; 
    80         else 
    81                 dst = argv[1]; 
    8283 
    83         client_call("vxdb.mount.remove", "{s:s,s:s}", 
     84        client_call("vxdb.mount.remove", 
     85                "{s:s,s:s}", 
    8486                "name", name, 
    8587                "dst", dst); 
     
    107109                opts = ""; 
    108110 
    109         client_call("vxdb.mount.set", "{s:s,s:s,s:s,s:s,s:s}", 
     111        client_call("vxdb.mount.set", 
     112                "{s:s,s:s,s:s,s:s,s:s}", 
    110113                "name", name, 
    111114                "src", src, 
  • trunk/src/vcc/vce/nx_addr.c

    r550 r586  
    2525void cmd_nx_addr_get(xmlrpc_env *env, int argc, char **argv) 
    2626{ 
    27         char *addr, *netmask; 
    2827        xmlrpc_value *response, *result; 
     28        char *name, *addr, *netmask; 
    2929        int len, i; 
    3030 
     
    3232                usage(EXIT_FAILURE); 
    3333 
    34         char *name = argv[0]; 
     34        name = argv[0]; 
    3535 
    36         if (argc < 2) 
     36        if (argc > 1) 
     37                addr = argv[1]; 
     38        else 
    3739                addr = ""; 
    38         else 
    39                 addr = argv[1]; 
    4040 
    41         response = client_call("vxdb.nx.addr.get", "{s:s,s:s}", 
     41        response = client_call("vxdb.nx.addr.get", 
     42                "{s:s,s:s}", 
    4243                "name", name, 
    4344                "addr", addr); 
     
    6768void cmd_nx_addr_remove(xmlrpc_env *env, int argc, char **argv) 
    6869{ 
    69         char *addr; 
     70        char *name, *addr; 
    7071 
    7172        if (argc < 1) 
    7273                usage(EXIT_FAILURE); 
    7374 
    74         char *name = argv[0]; 
     75        name = argv[0]; 
    7576 
    76         if (argc < 2) 
     77        if (argc > 1) 
     78                addr = argv[1]; 
     79        else 
    7780                addr = ""; 
    78         else 
    79                 addr = argv[1]; 
    8081 
    81         client_call("vxdb.nx.addr.remove", "{s:s,s:s}", 
     82        client_call("vxdb.nx.addr.remove", 
     83                "{s:s,s:s}", 
    8284                "name", name, 
    8385                "addr", addr); 
     
    8688void cmd_nx_addr_set(xmlrpc_env *env, int argc, char **argv) 
    8789{ 
    88         xmlrpc_value *response, *result; 
    89         char *name, *addr, *netmask = "255.255.255.255"; 
     90        char *name, *addr, *netmask; 
    9091 
    9192        if (argc < 2) 
     
    9596        addr = argv[1]; 
    9697 
    97         response = client_call("vxdb.nx.addr.get", "{s:s,s:s}", 
    98                 "name", name, 
    99                "addr", addr); 
    100         return_if_fault(env)
     98        if (argc > 2) 
     99                netmask = argv[2]; 
     100        else 
     101               netmask = ""
    101102 
    102         if (xmlrpc_array_size(env, response) > 0) { 
    103                 xmlrpc_array_read_item(env, response, 0, &result); 
    104                 return_if_fault(env); 
    105  
    106                 xmlrpc_decompose_value(env, result, 
    107                         "{s:s,*}", 
    108                         "netmask", &netmask); 
    109                 return_if_fault(env); 
    110  
    111                 xmlrpc_DECREF(result); 
    112                 xmlrpc_DECREF(response); 
    113         } 
    114  
    115         if (argc > 1) 
    116                 netmask = argv[1]; 
    117  
    118         client_call("vxdb.nx.addr.set", "{s:s,s:s,s:s}", 
     103        client_call("vxdb.nx.addr.set", 
     104                "{s:s,s:s,s:s}", 
    119105                "name", name, 
    120106                "addr", addr, 
  • trunk/src/vcc/vce/nx_broadcast.c

    r550 r586  
    2727{ 
    2828        xmlrpc_value *response; 
    29         char *broadcast; 
     29        char *name, *broadcast; 
    3030 
    3131        if (argc < 1) 
    3232                usage(EXIT_FAILURE); 
    3333 
    34         char *name = argv[0]; 
     34        name = argv[0]; 
    3535 
    36         response = client_call("vxdb.nx.broadcast.get", "{s:s}", "name", name); 
     36        response = client_call("vxdb.nx.broadcast.get", 
     37                "{s:s}", 
     38                "name", name); 
    3739        return_if_fault(env); 
    3840 
     
    4648void cmd_nx_broadcast_remove(xmlrpc_env *env, int argc, char **argv) 
    4749{ 
     50        char *name; 
     51 
    4852        if (argc < 1) 
    4953                usage(EXIT_FAILURE); 
    5054 
    51         char *name = argv[0]; 
     55        name = argv[0]; 
    5256 
    53         client_call("vxdb.nx.broadcast.remove", "{s:s}", "name", name); 
     57        client_call("vxdb.nx.broadcast.remove", 
     58                "{s:s}", 
     59                "name", name); 
    5460} 
    5561 
     
    6470        broadcast = argv[1]; 
    6571 
    66         client_call("vxdb.nx.broadcast.set", "{s:s,s:s}", 
     72        client_call("vxdb.nx.broadcast.set", 
     73                "{s:s,s:s}", 
    6774                "name", name, 
    6875                "broadcast", broadcast); 
  • trunk/src/vcc/vce/vx_bcaps.c

    r550 r586  
    3333        bcap = argv[1]; 
    3434 
    35         client_call("vxdb.vx.bcaps.add", "{s:s,s:s}", 
     35        client_call("vxdb.vx.bcaps.add", 
     36                "{s:s,s:s}", 
    3637                "name", name, 
    3738                "bcap", bcap); 
     
    4041void cmd_vx_bcaps_get(xmlrpc_env *env, int argc, char **argv) 
    4142{ 
    42         char *bcap; 
    4343        xmlrpc_value *response, *result; 
     44        char *name, *bcap; 
    4445        int len, i; 
    4546 
     
    4748                usage(EXIT_FAILURE); 
    4849 
    49         char *name = argv[0]; 
     50        name = argv[0]; 
    5051 
    51         response = client_call("vxdb.vx.bcaps.get", "{s:s}", "name", name); 
     52        response = client_call("vxdb.vx.bcaps.get", 
     53                "{s:s}", 
     54                "name", name); 
    5255        return_if_fault(env); 
    5356 
     
    7275void cmd_vx_bcaps_remove(xmlrpc_env *env, int argc, char **argv) 
    7376{ 
    74         char *bcap; 
     77        char *name, *bcap; 
    7578 
    7679        if (argc < 1) 
    7780                usage(EXIT_FAILURE); 
    7881 
    79         char *name = argv[0]; 
     82        name = argv[0]; 
    8083 
    81         if (argc < 2) 
     84        if (argc > 1) 
     85                bcap = argv[1]; 
     86        else 
    8287                bcap = ""; 
    83         else 
    84                 bcap = argv[1]; 
    8588 
    86         client_call("vxdb.vx.bcaps.remove", "{s:s,s:s}", 
     89        client_call("vxdb.vx.bcaps.remove", 
     90                "{s:s,s:s}", 
    8791                "name", name, 
    8892                "bcap", bcap); 
  • trunk/src/vcc/vce/vx_ccaps.c

    r550 r586  
    3333        ccap = argv[1]; 
    3434 
    35         client_call("vxdb.vx.ccaps.add", "{s:s,s:s}", 
     35        client_call("vxdb.vx.ccaps.add", 
     36                "{s:s,s:s}", 
    3637                "name", name, 
    3738                "ccap", ccap); 
     
    4041void cmd_vx_ccaps_get(xmlrpc_env *env, int argc, char **argv) 
    4142{ 
    42         char *ccap; 
    4343        xmlrpc_value *response, *result; 
     44        char *name, *ccap; 
    4445        int len, i; 
    4546 
     
    4748                usage(EXIT_FAILURE); 
    4849 
    49         char *name = argv[0]; 
     50        name = argv[0]; 
    5051 
    51         response = client_call("vxdb.vx.ccaps.get", "{s:s}", "name", name); 
     52        response = client_call("vxdb.vx.ccaps.get", 
     53                "{s:s}", 
     54                "name", name); 
    5255        return_if_fault(env); 
    5356 
     
    7275void cmd_vx_ccaps_remove(xmlrpc_env *env, int argc, char **argv) 
    7376{ 
    74         char *ccap; 
     77        char *name, *ccap; 
    7578 
    7679        if (argc < 1) 
    7780                usage(EXIT_FAILURE); 
    7881 
    79         char *name = argv[0]; 
     82        name = argv[0]; 
    8083 
    81         if (argc < 2) 
     84        if (argc > 1) 
     85                ccap = argv[1]; 
     86        else 
    8287                ccap = ""; 
    83         else 
    84                 ccap = argv[1]; 
    8588 
    86         client_call("vxdb.vx.ccaps.remove", "{s:s,s:s}", 
     89        client_call("vxdb.vx.ccaps.remove", 
     90                "{s:s,s:s}", 
    8791                "name", name, 
    8892                "ccap", ccap); 
  • trunk/src/vcc/vce/vx_flags.c

    r550 r586  
    3333        flag = argv[1]; 
    3434 
    35         client_call("vxdb.vx.flags.add", "{s:s,s:s}", 
     35        client_call("vxdb.vx.flags.add", 
     36                "{s:s,s:s}", 
    3637                "name", name, 
    3738                "flag", flag); 
     
    4041void cmd_vx_flags_get(xmlrpc_env *env, int argc, char **argv) 
    4142{ 
    42         char *flag; 
    4343        xmlrpc_value *response, *result; 
     44        char *name, *flag; 
    4445        int len, i; 
    4546 
     
    4748                usage(EXIT_FAILURE); 
    4849 
    49         char *name = argv[0]; 
     50        name = argv[0]; 
    5051 
    51         response = client_call("vxdb.vx.flags.get", "{s:s}", "name", name); 
     52        response = client_call("vxdb.vx.flags.get", 
     53                "{s:s}", 
     54                "name", name); 
    5255        return_if_fault(env); 
    5356 
     
    7275void cmd_vx_flags_remove(xmlrpc_env *env, int argc, char **argv) 
    7376{ 
    74         char *flag; 
     77        char *name, *flag; 
    7578 
    7679        if (argc < 1) 
    7780                usage(EXIT_FAILURE); 
    7881 
    79         char *name = argv[0]; 
     82        name = argv[0]; 
    8083 
    81         if (argc < 2) 
     84        if (argc > 1) 
     85                flag = argv[1]; 
     86        else 
    8287                flag = ""; 
    83         else 
    84                 flag = argv[1]; 
    8588 
    86         client_call("vxdb.vx.flags.remove", "{s:s,s:s}", 
     89        client_call("vxdb.vx.flags.remove", 
     90                "{s:s,s:s}", 
    8791                "name", name, 
    8892                "flag", flag); 
  • trunk/src/vcc/vce/vx_limit.c

    r571 r586  
    2626void cmd_vx_limit_get(xmlrpc_env *env, int argc, char **argv) 
    2727{ 
    28         char *type, *soft, *max; 
    2928        xmlrpc_value *response, *result; 
     29        char *name, *type, *soft, *max; 
    3030        int len, i; 
    3131 
     
    3333                usage(EXIT_FAILURE); 
    3434 
    35         char *name = argv[0]; 
     35        name = argv[0]; 
    3636 
    37