~ubuntu-branches/ubuntu/maverick/libvirt/maverick

« back to all changes in this revision

Viewing changes to qemud/remote_dispatch_proc_switch.h

  • Committer: Bazaar Package Importer
  • Author(s): Soren Hansen
  • Date: 2008-06-25 18:51:21 UTC
  • mto: (3.1.1 lenny) (1.2.1 upstream) (0.2.1 upstream)
  • mto: This revision was merged to the branch mainline in revision 27.
  • Revision ID: james.westby@ubuntu.com-20080625185121-8dku38gpoluks1bx
Tags: upstream-0.4.4
ImportĀ upstreamĀ versionĀ 0.4.4

Show diffs side-by-side

added added

removed removed

Lines of Context:
3
3
 */
4
4
 
5
5
case REMOTE_PROC_AUTH_LIST:
6
 
        fn = (dispatch_fn) remoteDispatchAuthList;
7
 
        ret_filter = (xdrproc_t) xdr_remote_auth_list_ret;
8
 
        ret = (char *) &lv_remote_auth_list_ret;
9
 
        memset (&lv_remote_auth_list_ret, 0, sizeof lv_remote_auth_list_ret);
10
 
        break;
 
6
        fn = (dispatch_fn) remoteDispatchAuthList;
 
7
        ret_filter = (xdrproc_t) xdr_remote_auth_list_ret;
 
8
        ret = (char *) &lv_remote_auth_list_ret;
 
9
        memset (&lv_remote_auth_list_ret, 0, sizeof lv_remote_auth_list_ret);
 
10
        break;
11
11
case REMOTE_PROC_AUTH_POLKIT:
12
 
        fn = (dispatch_fn) remoteDispatchAuthPolkit;
13
 
        ret_filter = (xdrproc_t) xdr_remote_auth_polkit_ret;
14
 
        ret = (char *) &lv_remote_auth_polkit_ret;
15
 
        memset (&lv_remote_auth_polkit_ret, 0, sizeof lv_remote_auth_polkit_ret);
16
 
        break;
 
12
        fn = (dispatch_fn) remoteDispatchAuthPolkit;
 
13
        ret_filter = (xdrproc_t) xdr_remote_auth_polkit_ret;
 
14
        ret = (char *) &lv_remote_auth_polkit_ret;
 
15
        memset (&lv_remote_auth_polkit_ret, 0, sizeof lv_remote_auth_polkit_ret);
 
16
        break;
17
17
case REMOTE_PROC_AUTH_SASL_INIT:
18
 
        fn = (dispatch_fn) remoteDispatchAuthSaslInit;
19
 
        ret_filter = (xdrproc_t) xdr_remote_auth_sasl_init_ret;
20
 
        ret = (char *) &lv_remote_auth_sasl_init_ret;
21
 
        memset (&lv_remote_auth_sasl_init_ret, 0, sizeof lv_remote_auth_sasl_init_ret);
22
 
        break;
 
18
        fn = (dispatch_fn) remoteDispatchAuthSaslInit;
 
19
        ret_filter = (xdrproc_t) xdr_remote_auth_sasl_init_ret;
 
20
        ret = (char *) &lv_remote_auth_sasl_init_ret;
 
21
        memset (&lv_remote_auth_sasl_init_ret, 0, sizeof lv_remote_auth_sasl_init_ret);
 
22
        break;
23
23
case REMOTE_PROC_AUTH_SASL_START:
24
 
        fn = (dispatch_fn) remoteDispatchAuthSaslStart;
25
 
        args_filter = (xdrproc_t) xdr_remote_auth_sasl_start_args;
26
 
        args = (char *) &lv_remote_auth_sasl_start_args;
27
 
        memset (&lv_remote_auth_sasl_start_args, 0, sizeof lv_remote_auth_sasl_start_args);
28
 
        ret_filter = (xdrproc_t) xdr_remote_auth_sasl_start_ret;
29
 
        ret = (char *) &lv_remote_auth_sasl_start_ret;
30
 
        memset (&lv_remote_auth_sasl_start_ret, 0, sizeof lv_remote_auth_sasl_start_ret);
31
 
        break;
 
24
        fn = (dispatch_fn) remoteDispatchAuthSaslStart;
 
25
        args_filter = (xdrproc_t) xdr_remote_auth_sasl_start_args;
 
26
        args = (char *) &lv_remote_auth_sasl_start_args;
 
27
        memset (&lv_remote_auth_sasl_start_args, 0, sizeof lv_remote_auth_sasl_start_args);
 
28
        ret_filter = (xdrproc_t) xdr_remote_auth_sasl_start_ret;
 
29
        ret = (char *) &lv_remote_auth_sasl_start_ret;
 
30
        memset (&lv_remote_auth_sasl_start_ret, 0, sizeof lv_remote_auth_sasl_start_ret);
 
31
        break;
32
32
case REMOTE_PROC_AUTH_SASL_STEP:
33
 
        fn = (dispatch_fn) remoteDispatchAuthSaslStep;
34
 
        args_filter = (xdrproc_t) xdr_remote_auth_sasl_step_args;
35
 
        args = (char *) &lv_remote_auth_sasl_step_args;
36
 
        memset (&lv_remote_auth_sasl_step_args, 0, sizeof lv_remote_auth_sasl_step_args);
37
 
        ret_filter = (xdrproc_t) xdr_remote_auth_sasl_step_ret;
38
 
        ret = (char *) &lv_remote_auth_sasl_step_ret;
39
 
        memset (&lv_remote_auth_sasl_step_ret, 0, sizeof lv_remote_auth_sasl_step_ret);
40
 
        break;
 
33
        fn = (dispatch_fn) remoteDispatchAuthSaslStep;
 
34
        args_filter = (xdrproc_t) xdr_remote_auth_sasl_step_args;
 
35
        args = (char *) &lv_remote_auth_sasl_step_args;
 
36
        memset (&lv_remote_auth_sasl_step_args, 0, sizeof lv_remote_auth_sasl_step_args);
 
37
        ret_filter = (xdrproc_t) xdr_remote_auth_sasl_step_ret;
 
38
        ret = (char *) &lv_remote_auth_sasl_step_ret;
 
39
        memset (&lv_remote_auth_sasl_step_ret, 0, sizeof lv_remote_auth_sasl_step_ret);
 
40
        break;
41
41
case REMOTE_PROC_CLOSE:
42
 
        fn = (dispatch_fn) remoteDispatchClose;
43
 
        break;
 
42
        fn = (dispatch_fn) remoteDispatchClose;
 
43
        break;
44
44
case REMOTE_PROC_DOMAIN_ATTACH_DEVICE:
45
 
        fn = (dispatch_fn) remoteDispatchDomainAttachDevice;
46
 
        args_filter = (xdrproc_t) xdr_remote_domain_attach_device_args;
47
 
        args = (char *) &lv_remote_domain_attach_device_args;
48
 
        memset (&lv_remote_domain_attach_device_args, 0, sizeof lv_remote_domain_attach_device_args);
49
 
        break;
 
45
        fn = (dispatch_fn) remoteDispatchDomainAttachDevice;
 
46
        args_filter = (xdrproc_t) xdr_remote_domain_attach_device_args;
 
47
        args = (char *) &lv_remote_domain_attach_device_args;
 
48
        memset (&lv_remote_domain_attach_device_args, 0, sizeof lv_remote_domain_attach_device_args);
 
49
        break;
 
50
case REMOTE_PROC_DOMAIN_BLOCK_PEEK:
 
51
        fn = (dispatch_fn) remoteDispatchDomainBlockPeek;
 
52
        args_filter = (xdrproc_t) xdr_remote_domain_block_peek_args;
 
53
        args = (char *) &lv_remote_domain_block_peek_args;
 
54
        memset (&lv_remote_domain_block_peek_args, 0, sizeof lv_remote_domain_block_peek_args);
 
55
        ret_filter = (xdrproc_t) xdr_remote_domain_block_peek_ret;
 
56
        ret = (char *) &lv_remote_domain_block_peek_ret;
 
57
        memset (&lv_remote_domain_block_peek_ret, 0, sizeof lv_remote_domain_block_peek_ret);
 
58
        break;
50
59
case REMOTE_PROC_DOMAIN_BLOCK_STATS:
51
 
        fn = (dispatch_fn) remoteDispatchDomainBlockStats;
52
 
        args_filter = (xdrproc_t) xdr_remote_domain_block_stats_args;
53
 
        args = (char *) &lv_remote_domain_block_stats_args;
54
 
        memset (&lv_remote_domain_block_stats_args, 0, sizeof lv_remote_domain_block_stats_args);
55
 
        ret_filter = (xdrproc_t) xdr_remote_domain_block_stats_ret;
56
 
        ret = (char *) &lv_remote_domain_block_stats_ret;
57
 
        memset (&lv_remote_domain_block_stats_ret, 0, sizeof lv_remote_domain_block_stats_ret);
58
 
        break;
 
60
        fn = (dispatch_fn) remoteDispatchDomainBlockStats;
 
61
        args_filter = (xdrproc_t) xdr_remote_domain_block_stats_args;
 
62
        args = (char *) &lv_remote_domain_block_stats_args;
 
63
        memset (&lv_remote_domain_block_stats_args, 0, sizeof lv_remote_domain_block_stats_args);
 
64
        ret_filter = (xdrproc_t) xdr_remote_domain_block_stats_ret;
 
65
        ret = (char *) &lv_remote_domain_block_stats_ret;
 
66
        memset (&lv_remote_domain_block_stats_ret, 0, sizeof lv_remote_domain_block_stats_ret);
 
67
        break;
59
68
case REMOTE_PROC_DOMAIN_CORE_DUMP:
60
 
        fn = (dispatch_fn) remoteDispatchDomainCoreDump;
61
 
        args_filter = (xdrproc_t) xdr_remote_domain_core_dump_args;
62
 
        args = (char *) &lv_remote_domain_core_dump_args;
63
 
        memset (&lv_remote_domain_core_dump_args, 0, sizeof lv_remote_domain_core_dump_args);
64
 
        break;
 
69
        fn = (dispatch_fn) remoteDispatchDomainCoreDump;
 
70
        args_filter = (xdrproc_t) xdr_remote_domain_core_dump_args;
 
71
        args = (char *) &lv_remote_domain_core_dump_args;
 
72
        memset (&lv_remote_domain_core_dump_args, 0, sizeof lv_remote_domain_core_dump_args);
 
73
        break;
65
74
case REMOTE_PROC_DOMAIN_CREATE:
66
 
        fn = (dispatch_fn) remoteDispatchDomainCreate;
67
 
        args_filter = (xdrproc_t) xdr_remote_domain_create_args;
68
 
        args = (char *) &lv_remote_domain_create_args;
69
 
        memset (&lv_remote_domain_create_args, 0, sizeof lv_remote_domain_create_args);
70
 
        break;
 
75
        fn = (dispatch_fn) remoteDispatchDomainCreate;
 
76
        args_filter = (xdrproc_t) xdr_remote_domain_create_args;
 
77
        args = (char *) &lv_remote_domain_create_args;
 
78
        memset (&lv_remote_domain_create_args, 0, sizeof lv_remote_domain_create_args);
 
79
        break;
71
80
case REMOTE_PROC_DOMAIN_CREATE_LINUX:
72
 
        fn = (dispatch_fn) remoteDispatchDomainCreateLinux;
73
 
        args_filter = (xdrproc_t) xdr_remote_domain_create_linux_args;
74
 
        args = (char *) &lv_remote_domain_create_linux_args;
75
 
        memset (&lv_remote_domain_create_linux_args, 0, sizeof lv_remote_domain_create_linux_args);
76
 
        ret_filter = (xdrproc_t) xdr_remote_domain_create_linux_ret;
77
 
        ret = (char *) &lv_remote_domain_create_linux_ret;
78
 
        memset (&lv_remote_domain_create_linux_ret, 0, sizeof lv_remote_domain_create_linux_ret);
79
 
        break;
 
81
        fn = (dispatch_fn) remoteDispatchDomainCreateLinux;
 
82
        args_filter = (xdrproc_t) xdr_remote_domain_create_linux_args;
 
83
        args = (char *) &lv_remote_domain_create_linux_args;
 
84
        memset (&lv_remote_domain_create_linux_args, 0, sizeof lv_remote_domain_create_linux_args);
 
85
        ret_filter = (xdrproc_t) xdr_remote_domain_create_linux_ret;
 
86
        ret = (char *) &lv_remote_domain_create_linux_ret;
 
87
        memset (&lv_remote_domain_create_linux_ret, 0, sizeof lv_remote_domain_create_linux_ret);
 
88
        break;
80
89
case REMOTE_PROC_DOMAIN_DEFINE_XML:
81
 
        fn = (dispatch_fn) remoteDispatchDomainDefineXml;
82
 
        args_filter = (xdrproc_t) xdr_remote_domain_define_xml_args;
83
 
        args = (char *) &lv_remote_domain_define_xml_args;
84
 
        memset (&lv_remote_domain_define_xml_args, 0, sizeof lv_remote_domain_define_xml_args);
85
 
        ret_filter = (xdrproc_t) xdr_remote_domain_define_xml_ret;
86
 
        ret = (char *) &lv_remote_domain_define_xml_ret;
87
 
        memset (&lv_remote_domain_define_xml_ret, 0, sizeof lv_remote_domain_define_xml_ret);
88
 
        break;
 
90
        fn = (dispatch_fn) remoteDispatchDomainDefineXml;
 
91
        args_filter = (xdrproc_t) xdr_remote_domain_define_xml_args;
 
92
        args = (char *) &lv_remote_domain_define_xml_args;
 
93
        memset (&lv_remote_domain_define_xml_args, 0, sizeof lv_remote_domain_define_xml_args);
 
94
        ret_filter = (xdrproc_t) xdr_remote_domain_define_xml_ret;
 
95
        ret = (char *) &lv_remote_domain_define_xml_ret;
 
96
        memset (&lv_remote_domain_define_xml_ret, 0, sizeof lv_remote_domain_define_xml_ret);
 
97
        break;
89
98
case REMOTE_PROC_DOMAIN_DESTROY:
90
 
        fn = (dispatch_fn) remoteDispatchDomainDestroy;
91
 
        args_filter = (xdrproc_t) xdr_remote_domain_destroy_args;
92
 
        args = (char *) &lv_remote_domain_destroy_args;
93
 
        memset (&lv_remote_domain_destroy_args, 0, sizeof lv_remote_domain_destroy_args);
94
 
        break;
 
99
        fn = (dispatch_fn) remoteDispatchDomainDestroy;
 
100
        args_filter = (xdrproc_t) xdr_remote_domain_destroy_args;
 
101
        args = (char *) &lv_remote_domain_destroy_args;
 
102
        memset (&lv_remote_domain_destroy_args, 0, sizeof lv_remote_domain_destroy_args);
 
103
        break;
95
104
case REMOTE_PROC_DOMAIN_DETACH_DEVICE:
96
 
        fn = (dispatch_fn) remoteDispatchDomainDetachDevice;
97
 
        args_filter = (xdrproc_t) xdr_remote_domain_detach_device_args;
98
 
        args = (char *) &lv_remote_domain_detach_device_args;
99
 
        memset (&lv_remote_domain_detach_device_args, 0, sizeof lv_remote_domain_detach_device_args);
100
 
        break;
 
105
        fn = (dispatch_fn) remoteDispatchDomainDetachDevice;
 
106
        args_filter = (xdrproc_t) xdr_remote_domain_detach_device_args;
 
107
        args = (char *) &lv_remote_domain_detach_device_args;
 
108
        memset (&lv_remote_domain_detach_device_args, 0, sizeof lv_remote_domain_detach_device_args);
 
109
        break;
101
110
case REMOTE_PROC_DOMAIN_DUMP_XML:
102
 
        fn = (dispatch_fn) remoteDispatchDomainDumpXml;
103
 
        args_filter = (xdrproc_t) xdr_remote_domain_dump_xml_args;
104
 
        args = (char *) &lv_remote_domain_dump_xml_args;
105
 
        memset (&lv_remote_domain_dump_xml_args, 0, sizeof lv_remote_domain_dump_xml_args);
106
 
        ret_filter = (xdrproc_t) xdr_remote_domain_dump_xml_ret;
107
 
        ret = (char *) &lv_remote_domain_dump_xml_ret;
108
 
        memset (&lv_remote_domain_dump_xml_ret, 0, sizeof lv_remote_domain_dump_xml_ret);
109
 
        break;
 
111
        fn = (dispatch_fn) remoteDispatchDomainDumpXml;
 
112
        args_filter = (xdrproc_t) xdr_remote_domain_dump_xml_args;
 
113
        args = (char *) &lv_remote_domain_dump_xml_args;
 
114
        memset (&lv_remote_domain_dump_xml_args, 0, sizeof lv_remote_domain_dump_xml_args);
 
115
        ret_filter = (xdrproc_t) xdr_remote_domain_dump_xml_ret;
 
116
        ret = (char *) &lv_remote_domain_dump_xml_ret;
 
117
        memset (&lv_remote_domain_dump_xml_ret, 0, sizeof lv_remote_domain_dump_xml_ret);
 
118
        break;
110
119
case REMOTE_PROC_DOMAIN_GET_AUTOSTART:
111
 
        fn = (dispatch_fn) remoteDispatchDomainGetAutostart;
112
 
        args_filter = (xdrproc_t) xdr_remote_domain_get_autostart_args;
113
 
        args = (char *) &lv_remote_domain_get_autostart_args;
114
 
        memset (&lv_remote_domain_get_autostart_args, 0, sizeof lv_remote_domain_get_autostart_args);
115
 
        ret_filter = (xdrproc_t) xdr_remote_domain_get_autostart_ret;
116
 
        ret = (char *) &lv_remote_domain_get_autostart_ret;
117
 
        memset (&lv_remote_domain_get_autostart_ret, 0, sizeof lv_remote_domain_get_autostart_ret);
118
 
        break;
 
120
        fn = (dispatch_fn) remoteDispatchDomainGetAutostart;
 
121
        args_filter = (xdrproc_t) xdr_remote_domain_get_autostart_args;
 
122
        args = (char *) &lv_remote_domain_get_autostart_args;
 
123
        memset (&lv_remote_domain_get_autostart_args, 0, sizeof lv_remote_domain_get_autostart_args);
 
124
        ret_filter = (xdrproc_t) xdr_remote_domain_get_autostart_ret;
 
125
        ret = (char *) &lv_remote_domain_get_autostart_ret;
 
126
        memset (&lv_remote_domain_get_autostart_ret, 0, sizeof lv_remote_domain_get_autostart_ret);
 
127
        break;
119
128
case REMOTE_PROC_DOMAIN_GET_INFO:
120
 
        fn = (dispatch_fn) remoteDispatchDomainGetInfo;
121
 
        args_filter = (xdrproc_t) xdr_remote_domain_get_info_args;
122
 
        args = (char *) &lv_remote_domain_get_info_args;
123
 
        memset (&lv_remote_domain_get_info_args, 0, sizeof lv_remote_domain_get_info_args);
124
 
        ret_filter = (xdrproc_t) xdr_remote_domain_get_info_ret;
125
 
        ret = (char *) &lv_remote_domain_get_info_ret;
126
 
        memset (&lv_remote_domain_get_info_ret, 0, sizeof lv_remote_domain_get_info_ret);
127
 
        break;
 
129
        fn = (dispatch_fn) remoteDispatchDomainGetInfo;
 
130
        args_filter = (xdrproc_t) xdr_remote_domain_get_info_args;
 
131
        args = (char *) &lv_remote_domain_get_info_args;
 
132
        memset (&lv_remote_domain_get_info_args, 0, sizeof lv_remote_domain_get_info_args);
 
133
        ret_filter = (xdrproc_t) xdr_remote_domain_get_info_ret;
 
134
        ret = (char *) &lv_remote_domain_get_info_ret;
 
135
        memset (&lv_remote_domain_get_info_ret, 0, sizeof lv_remote_domain_get_info_ret);
 
136
        break;
128
137
case REMOTE_PROC_DOMAIN_GET_MAX_MEMORY:
129
 
        fn = (dispatch_fn) remoteDispatchDomainGetMaxMemory;
130
 
        args_filter = (xdrproc_t) xdr_remote_domain_get_max_memory_args;
131
 
        args = (char *) &lv_remote_domain_get_max_memory_args;
132
 
        memset (&lv_remote_domain_get_max_memory_args, 0, sizeof lv_remote_domain_get_max_memory_args);
133
 
        ret_filter = (xdrproc_t) xdr_remote_domain_get_max_memory_ret;
134
 
        ret = (char *) &lv_remote_domain_get_max_memory_ret;
135
 
        memset (&lv_remote_domain_get_max_memory_ret, 0, sizeof lv_remote_domain_get_max_memory_ret);
136
 
        break;
 
138
        fn = (dispatch_fn) remoteDispatchDomainGetMaxMemory;
 
139
        args_filter = (xdrproc_t) xdr_remote_domain_get_max_memory_args;
 
140
        args = (char *) &lv_remote_domain_get_max_memory_args;
 
141
        memset (&lv_remote_domain_get_max_memory_args, 0, sizeof lv_remote_domain_get_max_memory_args);
 
142
        ret_filter = (xdrproc_t) xdr_remote_domain_get_max_memory_ret;
 
143
        ret = (char *) &lv_remote_domain_get_max_memory_ret;
 
144
        memset (&lv_remote_domain_get_max_memory_ret, 0, sizeof lv_remote_domain_get_max_memory_ret);
 
145
        break;
137
146
case REMOTE_PROC_DOMAIN_GET_MAX_VCPUS:
138
 
        fn = (dispatch_fn) remoteDispatchDomainGetMaxVcpus;
139
 
        args_filter = (xdrproc_t) xdr_remote_domain_get_max_vcpus_args;
140
 
        args = (char *) &lv_remote_domain_get_max_vcpus_args;
141
 
        memset (&lv_remote_domain_get_max_vcpus_args, 0, sizeof lv_remote_domain_get_max_vcpus_args);
142
 
        ret_filter = (xdrproc_t) xdr_remote_domain_get_max_vcpus_ret;
143
 
        ret = (char *) &lv_remote_domain_get_max_vcpus_ret;
144
 
        memset (&lv_remote_domain_get_max_vcpus_ret, 0, sizeof lv_remote_domain_get_max_vcpus_ret);
145
 
        break;
 
147
        fn = (dispatch_fn) remoteDispatchDomainGetMaxVcpus;
 
148
        args_filter = (xdrproc_t) xdr_remote_domain_get_max_vcpus_args;
 
149
        args = (char *) &lv_remote_domain_get_max_vcpus_args;
 
150
        memset (&lv_remote_domain_get_max_vcpus_args, 0, sizeof lv_remote_domain_get_max_vcpus_args);
 
151
        ret_filter = (xdrproc_t) xdr_remote_domain_get_max_vcpus_ret;
 
152
        ret = (char *) &lv_remote_domain_get_max_vcpus_ret;
 
153
        memset (&lv_remote_domain_get_max_vcpus_ret, 0, sizeof lv_remote_domain_get_max_vcpus_ret);
 
154
        break;
146
155
case REMOTE_PROC_DOMAIN_GET_OS_TYPE:
147
 
        fn = (dispatch_fn) remoteDispatchDomainGetOsType;
148
 
        args_filter = (xdrproc_t) xdr_remote_domain_get_os_type_args;
149
 
        args = (char *) &lv_remote_domain_get_os_type_args;
150
 
        memset (&lv_remote_domain_get_os_type_args, 0, sizeof lv_remote_domain_get_os_type_args);
151
 
        ret_filter = (xdrproc_t) xdr_remote_domain_get_os_type_ret;
152
 
        ret = (char *) &lv_remote_domain_get_os_type_ret;
153
 
        memset (&lv_remote_domain_get_os_type_ret, 0, sizeof lv_remote_domain_get_os_type_ret);
154
 
        break;
 
156
        fn = (dispatch_fn) remoteDispatchDomainGetOsType;
 
157
        args_filter = (xdrproc_t) xdr_remote_domain_get_os_type_args;
 
158
        args = (char *) &lv_remote_domain_get_os_type_args;
 
159
        memset (&lv_remote_domain_get_os_type_args, 0, sizeof lv_remote_domain_get_os_type_args);
 
160
        ret_filter = (xdrproc_t) xdr_remote_domain_get_os_type_ret;
 
161
        ret = (char *) &lv_remote_domain_get_os_type_ret;
 
162
        memset (&lv_remote_domain_get_os_type_ret, 0, sizeof lv_remote_domain_get_os_type_ret);
 
163
        break;
155
164
case REMOTE_PROC_DOMAIN_GET_SCHEDULER_PARAMETERS:
156
 
        fn = (dispatch_fn) remoteDispatchDomainGetSchedulerParameters;
157
 
        args_filter = (xdrproc_t) xdr_remote_domain_get_scheduler_parameters_args;
158
 
        args = (char *) &lv_remote_domain_get_scheduler_parameters_args;
159
 
        memset (&lv_remote_domain_get_scheduler_parameters_args, 0, sizeof lv_remote_domain_get_scheduler_parameters_args);
160
 
        ret_filter = (xdrproc_t) xdr_remote_domain_get_scheduler_parameters_ret;
161
 
        ret = (char *) &lv_remote_domain_get_scheduler_parameters_ret;
162
 
        memset (&lv_remote_domain_get_scheduler_parameters_ret, 0, sizeof lv_remote_domain_get_scheduler_parameters_ret);
163
 
        break;
 
165
        fn = (dispatch_fn) remoteDispatchDomainGetSchedulerParameters;
 
166
        args_filter = (xdrproc_t) xdr_remote_domain_get_scheduler_parameters_args;
 
167
        args = (char *) &lv_remote_domain_get_scheduler_parameters_args;
 
168
        memset (&lv_remote_domain_get_scheduler_parameters_args, 0, sizeof lv_remote_domain_get_scheduler_parameters_args);
 
169
        ret_filter = (xdrproc_t) xdr_remote_domain_get_scheduler_parameters_ret;
 
170
        ret = (char *) &lv_remote_domain_get_scheduler_parameters_ret;
 
171
        memset (&lv_remote_domain_get_scheduler_parameters_ret, 0, sizeof lv_remote_domain_get_scheduler_parameters_ret);
 
172
        break;
164
173
case REMOTE_PROC_DOMAIN_GET_SCHEDULER_TYPE:
165
 
        fn = (dispatch_fn) remoteDispatchDomainGetSchedulerType;
166
 
        args_filter = (xdrproc_t) xdr_remote_domain_get_scheduler_type_args;
167
 
        args = (char *) &lv_remote_domain_get_scheduler_type_args;
168
 
        memset (&lv_remote_domain_get_scheduler_type_args, 0, sizeof lv_remote_domain_get_scheduler_type_args);
169
 
        ret_filter = (xdrproc_t) xdr_remote_domain_get_scheduler_type_ret;
170
 
        ret = (char *) &lv_remote_domain_get_scheduler_type_ret;
171
 
        memset (&lv_remote_domain_get_scheduler_type_ret, 0, sizeof lv_remote_domain_get_scheduler_type_ret);
172
 
        break;
 
174
        fn = (dispatch_fn) remoteDispatchDomainGetSchedulerType;
 
175
        args_filter = (xdrproc_t) xdr_remote_domain_get_scheduler_type_args;
 
176
        args = (char *) &lv_remote_domain_get_scheduler_type_args;
 
177
        memset (&lv_remote_domain_get_scheduler_type_args, 0, sizeof lv_remote_domain_get_scheduler_type_args);
 
178
        ret_filter = (xdrproc_t) xdr_remote_domain_get_scheduler_type_ret;
 
179
        ret = (char *) &lv_remote_domain_get_scheduler_type_ret;
 
180
        memset (&lv_remote_domain_get_scheduler_type_ret, 0, sizeof lv_remote_domain_get_scheduler_type_ret);
 
181
        break;
173
182
case REMOTE_PROC_DOMAIN_GET_VCPUS:
174
 
        fn = (dispatch_fn) remoteDispatchDomainGetVcpus;
175
 
        args_filter = (xdrproc_t) xdr_remote_domain_get_vcpus_args;
176
 
        args = (char *) &lv_remote_domain_get_vcpus_args;
177
 
        memset (&lv_remote_domain_get_vcpus_args, 0, sizeof lv_remote_domain_get_vcpus_args);
178
 
        ret_filter = (xdrproc_t) xdr_remote_domain_get_vcpus_ret;
179
 
        ret = (char *) &lv_remote_domain_get_vcpus_ret;
180
 
        memset (&lv_remote_domain_get_vcpus_ret, 0, sizeof lv_remote_domain_get_vcpus_ret);
181
 
        break;
 
183
        fn = (dispatch_fn) remoteDispatchDomainGetVcpus;
 
184
        args_filter = (xdrproc_t) xdr_remote_domain_get_vcpus_args;
 
185
        args = (char *) &lv_remote_domain_get_vcpus_args;
 
186
        memset (&lv_remote_domain_get_vcpus_args, 0, sizeof lv_remote_domain_get_vcpus_args);
 
187
        ret_filter = (xdrproc_t) xdr_remote_domain_get_vcpus_ret;
 
188
        ret = (char *) &lv_remote_domain_get_vcpus_ret;
 
189
        memset (&lv_remote_domain_get_vcpus_ret, 0, sizeof lv_remote_domain_get_vcpus_ret);
 
190
        break;
182
191
case REMOTE_PROC_DOMAIN_INTERFACE_STATS:
183
 
        fn = (dispatch_fn) remoteDispatchDomainInterfaceStats;
184
 
        args_filter = (xdrproc_t) xdr_remote_domain_interface_stats_args;
185
 
        args = (char *) &lv_remote_domain_interface_stats_args;
186
 
        memset (&lv_remote_domain_interface_stats_args, 0, sizeof lv_remote_domain_interface_stats_args);
187
 
        ret_filter = (xdrproc_t) xdr_remote_domain_interface_stats_ret;
188
 
        ret = (char *) &lv_remote_domain_interface_stats_ret;
189
 
        memset (&lv_remote_domain_interface_stats_ret, 0, sizeof lv_remote_domain_interface_stats_ret);
190
 
        break;
 
192
        fn = (dispatch_fn) remoteDispatchDomainInterfaceStats;
 
193
        args_filter = (xdrproc_t) xdr_remote_domain_interface_stats_args;
 
194
        args = (char *) &lv_remote_domain_interface_stats_args;
 
195
        memset (&lv_remote_domain_interface_stats_args, 0, sizeof lv_remote_domain_interface_stats_args);
 
196
        ret_filter = (xdrproc_t) xdr_remote_domain_interface_stats_ret;
 
197
        ret = (char *) &lv_remote_domain_interface_stats_ret;
 
198
        memset (&lv_remote_domain_interface_stats_ret, 0, sizeof lv_remote_domain_interface_stats_ret);
 
199
        break;
191
200
case REMOTE_PROC_DOMAIN_LOOKUP_BY_ID:
192
 
        fn = (dispatch_fn) remoteDispatchDomainLookupById;
193
 
        args_filter = (xdrproc_t) xdr_remote_domain_lookup_by_id_args;
194
 
        args = (char *) &lv_remote_domain_lookup_by_id_args;
195
 
        memset (&lv_remote_domain_lookup_by_id_args, 0, sizeof lv_remote_domain_lookup_by_id_args);
196
 
        ret_filter = (xdrproc_t) xdr_remote_domain_lookup_by_id_ret;
197
 
        ret = (char *) &lv_remote_domain_lookup_by_id_ret;
198
 
        memset (&lv_remote_domain_lookup_by_id_ret, 0, sizeof lv_remote_domain_lookup_by_id_ret);
199
 
        break;
 
201
        fn = (dispatch_fn) remoteDispatchDomainLookupById;
 
202
        args_filter = (xdrproc_t) xdr_remote_domain_lookup_by_id_args;
 
203
        args = (char *) &lv_remote_domain_lookup_by_id_args;
 
204
        memset (&lv_remote_domain_lookup_by_id_args, 0, sizeof lv_remote_domain_lookup_by_id_args);
 
205
        ret_filter = (xdrproc_t) xdr_remote_domain_lookup_by_id_ret;
 
206
        ret = (char *) &lv_remote_domain_lookup_by_id_ret;
 
207
        memset (&lv_remote_domain_lookup_by_id_ret, 0, sizeof lv_remote_domain_lookup_by_id_ret);
 
208
        break;
200
209
case REMOTE_PROC_DOMAIN_LOOKUP_BY_NAME:
201
 
        fn = (dispatch_fn) remoteDispatchDomainLookupByName;
202
 
        args_filter = (xdrproc_t) xdr_remote_domain_lookup_by_name_args;
203
 
        args = (char *) &lv_remote_domain_lookup_by_name_args;
204
 
        memset (&lv_remote_domain_lookup_by_name_args, 0, sizeof lv_remote_domain_lookup_by_name_args);
205
 
        ret_filter = (xdrproc_t) xdr_remote_domain_lookup_by_name_ret;
206
 
        ret = (char *) &lv_remote_domain_lookup_by_name_ret;
207
 
        memset (&lv_remote_domain_lookup_by_name_ret, 0, sizeof lv_remote_domain_lookup_by_name_ret);
208
 
        break;
 
210
        fn = (dispatch_fn) remoteDispatchDomainLookupByName;
 
211
        args_filter = (xdrproc_t) xdr_remote_domain_lookup_by_name_args;
 
212
        args = (char *) &lv_remote_domain_lookup_by_name_args;
 
213
        memset (&lv_remote_domain_lookup_by_name_args, 0, sizeof lv_remote_domain_lookup_by_name_args);
 
214
        ret_filter = (xdrproc_t) xdr_remote_domain_lookup_by_name_ret;
 
215
        ret = (char *) &lv_remote_domain_lookup_by_name_ret;
 
216
        memset (&lv_remote_domain_lookup_by_name_ret, 0, sizeof lv_remote_domain_lookup_by_name_ret);
 
217
        break;
209
218
case REMOTE_PROC_DOMAIN_LOOKUP_BY_UUID:
210
 
        fn = (dispatch_fn) remoteDispatchDomainLookupByUuid;
211
 
        args_filter = (xdrproc_t) xdr_remote_domain_lookup_by_uuid_args;
212
 
        args = (char *) &lv_remote_domain_lookup_by_uuid_args;
213
 
        memset (&lv_remote_domain_lookup_by_uuid_args, 0, sizeof lv_remote_domain_lookup_by_uuid_args);
214
 
        ret_filter = (xdrproc_t) xdr_remote_domain_lookup_by_uuid_ret;
215
 
        ret = (char *) &lv_remote_domain_lookup_by_uuid_ret;
216
 
        memset (&lv_remote_domain_lookup_by_uuid_ret, 0, sizeof lv_remote_domain_lookup_by_uuid_ret);
217
 
        break;
 
219
        fn = (dispatch_fn) remoteDispatchDomainLookupByUuid;
 
220
        args_filter = (xdrproc_t) xdr_remote_domain_lookup_by_uuid_args;
 
221
        args = (char *) &lv_remote_domain_lookup_by_uuid_args;
 
222
        memset (&lv_remote_domain_lookup_by_uuid_args, 0, sizeof lv_remote_domain_lookup_by_uuid_args);
 
223
        ret_filter = (xdrproc_t) xdr_remote_domain_lookup_by_uuid_ret;
 
224
        ret = (char *) &lv_remote_domain_lookup_by_uuid_ret;
 
225
        memset (&lv_remote_domain_lookup_by_uuid_ret, 0, sizeof lv_remote_domain_lookup_by_uuid_ret);
 
226
        break;
 
227
case REMOTE_PROC_DOMAIN_MEMORY_PEEK:
 
228
        fn = (dispatch_fn) remoteDispatchDomainMemoryPeek;
 
229
        args_filter = (xdrproc_t) xdr_remote_domain_memory_peek_args;
 
230
        args = (char *) &lv_remote_domain_memory_peek_args;
 
231
        memset (&lv_remote_domain_memory_peek_args, 0, sizeof lv_remote_domain_memory_peek_args);
 
232
        ret_filter = (xdrproc_t) xdr_remote_domain_memory_peek_ret;
 
233
        ret = (char *) &lv_remote_domain_memory_peek_ret;
 
234
        memset (&lv_remote_domain_memory_peek_ret, 0, sizeof lv_remote_domain_memory_peek_ret);
 
235
        break;
218
236
case REMOTE_PROC_DOMAIN_MIGRATE_FINISH:
219
 
        fn = (dispatch_fn) remoteDispatchDomainMigrateFinish;
220
 
        args_filter = (xdrproc_t) xdr_remote_domain_migrate_finish_args;
221
 
        args = (char *) &lv_remote_domain_migrate_finish_args;
222
 
        memset (&lv_remote_domain_migrate_finish_args, 0, sizeof lv_remote_domain_migrate_finish_args);
223
 
        ret_filter = (xdrproc_t) xdr_remote_domain_migrate_finish_ret;
224
 
        ret = (char *) &lv_remote_domain_migrate_finish_ret;
225
 
        memset (&lv_remote_domain_migrate_finish_ret, 0, sizeof lv_remote_domain_migrate_finish_ret);
226
 
        break;
 
237
        fn = (dispatch_fn) remoteDispatchDomainMigrateFinish;
 
238
        args_filter = (xdrproc_t) xdr_remote_domain_migrate_finish_args;
 
239
        args = (char *) &lv_remote_domain_migrate_finish_args;
 
240
        memset (&lv_remote_domain_migrate_finish_args, 0, sizeof lv_remote_domain_migrate_finish_args);
 
241
        ret_filter = (xdrproc_t) xdr_remote_domain_migrate_finish_ret;
 
242
        ret = (char *) &lv_remote_domain_migrate_finish_ret;
 
243
        memset (&lv_remote_domain_migrate_finish_ret, 0, sizeof lv_remote_domain_migrate_finish_ret);
 
244
        break;
227
245
case REMOTE_PROC_DOMAIN_MIGRATE_PERFORM:
228
 
        fn = (dispatch_fn) remoteDispatchDomainMigratePerform;
229
 
        args_filter = (xdrproc_t) xdr_remote_domain_migrate_perform_args;
230
 
        args = (char *) &lv_remote_domain_migrate_perform_args;
231
 
        memset (&lv_remote_domain_migrate_perform_args, 0, sizeof lv_remote_domain_migrate_perform_args);
232
 
        break;
 
246
        fn = (dispatch_fn) remoteDispatchDomainMigratePerform;
 
247
        args_filter = (xdrproc_t) xdr_remote_domain_migrate_perform_args;
 
248
        args = (char *) &lv_remote_domain_migrate_perform_args;
 
249
        memset (&lv_remote_domain_migrate_perform_args, 0, sizeof lv_remote_domain_migrate_perform_args);
 
250
        break;
233
251
case REMOTE_PROC_DOMAIN_MIGRATE_PREPARE:
234
 
        fn = (dispatch_fn) remoteDispatchDomainMigratePrepare;
235
 
        args_filter = (xdrproc_t) xdr_remote_domain_migrate_prepare_args;
236
 
        args = (char *) &lv_remote_domain_migrate_prepare_args;
237
 
        memset (&lv_remote_domain_migrate_prepare_args, 0, sizeof lv_remote_domain_migrate_prepare_args);
238
 
        ret_filter = (xdrproc_t) xdr_remote_domain_migrate_prepare_ret;
239
 
        ret = (char *) &lv_remote_domain_migrate_prepare_ret;
240
 
        memset (&lv_remote_domain_migrate_prepare_ret, 0, sizeof lv_remote_domain_migrate_prepare_ret);
241
 
        break;
 
252
        fn = (dispatch_fn) remoteDispatchDomainMigratePrepare;
 
253
        args_filter = (xdrproc_t) xdr_remote_domain_migrate_prepare_args;
 
254
        args = (char *) &lv_remote_domain_migrate_prepare_args;
 
255
        memset (&lv_remote_domain_migrate_prepare_args, 0, sizeof lv_remote_domain_migrate_prepare_args);
 
256
        ret_filter = (xdrproc_t) xdr_remote_domain_migrate_prepare_ret;
 
257
        ret = (char *) &lv_remote_domain_migrate_prepare_ret;
 
258
        memset (&lv_remote_domain_migrate_prepare_ret, 0, sizeof lv_remote_domain_migrate_prepare_ret);
 
259
        break;
242
260
case REMOTE_PROC_DOMAIN_PIN_VCPU:
243
 
        fn = (dispatch_fn) remoteDispatchDomainPinVcpu;
244
 
        args_filter = (xdrproc_t) xdr_remote_domain_pin_vcpu_args;
245
 
        args = (char *) &lv_remote_domain_pin_vcpu_args;
246
 
        memset (&lv_remote_domain_pin_vcpu_args, 0, sizeof lv_remote_domain_pin_vcpu_args);
247
 
        break;
 
261
        fn = (dispatch_fn) remoteDispatchDomainPinVcpu;
 
262
        args_filter = (xdrproc_t) xdr_remote_domain_pin_vcpu_args;
 
263
        args = (char *) &lv_remote_domain_pin_vcpu_args;
 
264
        memset (&lv_remote_domain_pin_vcpu_args, 0, sizeof lv_remote_domain_pin_vcpu_args);
 
265
        break;
248
266
case REMOTE_PROC_DOMAIN_REBOOT:
249
 
        fn = (dispatch_fn) remoteDispatchDomainReboot;
250
 
        args_filter = (xdrproc_t) xdr_remote_domain_reboot_args;
251
 
        args = (char *) &lv_remote_domain_reboot_args;
252
 
        memset (&lv_remote_domain_reboot_args, 0, sizeof lv_remote_domain_reboot_args);
253
 
        break;
 
267
        fn = (dispatch_fn) remoteDispatchDomainReboot;
 
268
        args_filter = (xdrproc_t) xdr_remote_domain_reboot_args;
 
269
        args = (char *) &lv_remote_domain_reboot_args;
 
270
        memset (&lv_remote_domain_reboot_args, 0, sizeof lv_remote_domain_reboot_args);
 
271
        break;
254
272
case REMOTE_PROC_DOMAIN_RESTORE:
255
 
        fn = (dispatch_fn) remoteDispatchDomainRestore;
256
 
        args_filter = (xdrproc_t) xdr_remote_domain_restore_args;
257
 
        args = (char *) &lv_remote_domain_restore_args;
258
 
        memset (&lv_remote_domain_restore_args, 0, sizeof lv_remote_domain_restore_args);
259
 
        break;
 
273
        fn = (dispatch_fn) remoteDispatchDomainRestore;
 
274
        args_filter = (xdrproc_t) xdr_remote_domain_restore_args;
 
275
        args = (char *) &lv_remote_domain_restore_args;
 
276
        memset (&lv_remote_domain_restore_args, 0, sizeof lv_remote_domain_restore_args);
 
277
        break;
260
278
case REMOTE_PROC_DOMAIN_RESUME:
261
 
        fn = (dispatch_fn) remoteDispatchDomainResume;
262
 
        args_filter = (xdrproc_t) xdr_remote_domain_resume_args;
263
 
        args = (char *) &lv_remote_domain_resume_args;
264
 
        memset (&lv_remote_domain_resume_args, 0, sizeof lv_remote_domain_resume_args);
265
 
        break;
 
279
        fn = (dispatch_fn) remoteDispatchDomainResume;
 
280
        args_filter = (xdrproc_t) xdr_remote_domain_resume_args;
 
281
        args = (char *) &lv_remote_domain_resume_args;
 
282
        memset (&lv_remote_domain_resume_args, 0, sizeof lv_remote_domain_resume_args);
 
283
        break;
266
284
case REMOTE_PROC_DOMAIN_SAVE:
267
 
        fn = (dispatch_fn) remoteDispatchDomainSave;
268
 
        args_filter = (xdrproc_t) xdr_remote_domain_save_args;
269
 
        args = (char *) &lv_remote_domain_save_args;
270
 
        memset (&lv_remote_domain_save_args, 0, sizeof lv_remote_domain_save_args);
271
 
        break;
 
285
        fn = (dispatch_fn) remoteDispatchDomainSave;
 
286
        args_filter = (xdrproc_t) xdr_remote_domain_save_args;
 
287
        args = (char *) &lv_remote_domain_save_args;
 
288
        memset (&lv_remote_domain_save_args, 0, sizeof lv_remote_domain_save_args);
 
289
        break;
272
290
case REMOTE_PROC_DOMAIN_SET_AUTOSTART:
273
 
        fn = (dispatch_fn) remoteDispatchDomainSetAutostart;
274
 
        args_filter = (xdrproc_t) xdr_remote_domain_set_autostart_args;
275
 
        args = (char *) &lv_remote_domain_set_autostart_args;
276
 
        memset (&lv_remote_domain_set_autostart_args, 0, sizeof lv_remote_domain_set_autostart_args);
277
 
        break;
 
291
        fn = (dispatch_fn) remoteDispatchDomainSetAutostart;
 
292
        args_filter = (xdrproc_t) xdr_remote_domain_set_autostart_args;
 
293
        args = (char *) &lv_remote_domain_set_autostart_args;
 
294
        memset (&lv_remote_domain_set_autostart_args, 0, sizeof lv_remote_domain_set_autostart_args);
 
295
        break;
278
296
case REMOTE_PROC_DOMAIN_SET_MAX_MEMORY:
279
 
        fn = (dispatch_fn) remoteDispatchDomainSetMaxMemory;
280
 
        args_filter = (xdrproc_t) xdr_remote_domain_set_max_memory_args;
281
 
        args = (char *) &lv_remote_domain_set_max_memory_args;
282
 
        memset (&lv_remote_domain_set_max_memory_args, 0, sizeof lv_remote_domain_set_max_memory_args);
283
 
        break;
 
297
        fn = (dispatch_fn) remoteDispatchDomainSetMaxMemory;
 
298
        args_filter = (xdrproc_t) xdr_remote_domain_set_max_memory_args;
 
299
        args = (char *) &lv_remote_domain_set_max_memory_args;
 
300
        memset (&lv_remote_domain_set_max_memory_args, 0, sizeof lv_remote_domain_set_max_memory_args);
 
301
        break;
284
302
case REMOTE_PROC_DOMAIN_SET_MEMORY:
285
 
        fn = (dispatch_fn) remoteDispatchDomainSetMemory;
286
 
        args_filter = (xdrproc_t) xdr_remote_domain_set_memory_args;
287
 
        args = (char *) &lv_remote_domain_set_memory_args;
288
 
        memset (&lv_remote_domain_set_memory_args, 0, sizeof lv_remote_domain_set_memory_args);
289
 
        break;
 
303
        fn = (dispatch_fn) remoteDispatchDomainSetMemory;
 
304
        args_filter = (xdrproc_t) xdr_remote_domain_set_memory_args;
 
305
        args = (char *) &lv_remote_domain_set_memory_args;
 
306
        memset (&lv_remote_domain_set_memory_args, 0, sizeof lv_remote_domain_set_memory_args);
 
307
        break;
290
308
case REMOTE_PROC_DOMAIN_SET_SCHEDULER_PARAMETERS:
291
 
        fn = (dispatch_fn) remoteDispatchDomainSetSchedulerParameters;
292
 
        args_filter = (xdrproc_t) xdr_remote_domain_set_scheduler_parameters_args;
293
 
        args = (char *) &lv_remote_domain_set_scheduler_parameters_args;
294
 
        memset (&lv_remote_domain_set_scheduler_parameters_args, 0, sizeof lv_remote_domain_set_scheduler_parameters_args);
295
 
        break;
 
309
        fn = (dispatch_fn) remoteDispatchDomainSetSchedulerParameters;
 
310
        args_filter = (xdrproc_t) xdr_remote_domain_set_scheduler_parameters_args;
 
311
        args = (char *) &lv_remote_domain_set_scheduler_parameters_args;
 
312
        memset (&lv_remote_domain_set_scheduler_parameters_args, 0, sizeof lv_remote_domain_set_scheduler_parameters_args);
 
313
        break;
296
314
case REMOTE_PROC_DOMAIN_SET_VCPUS:
297
 
        fn = (dispatch_fn) remoteDispatchDomainSetVcpus;
298
 
        args_filter = (xdrproc_t) xdr_remote_domain_set_vcpus_args;
299
 
        args = (char *) &lv_remote_domain_set_vcpus_args;
300
 
        memset (&lv_remote_domain_set_vcpus_args, 0, sizeof lv_remote_domain_set_vcpus_args);
301
 
        break;
 
315
        fn = (dispatch_fn) remoteDispatchDomainSetVcpus;
 
316
        args_filter = (xdrproc_t) xdr_remote_domain_set_vcpus_args;
 
317
        args = (char *) &lv_remote_domain_set_vcpus_args;
 
318
        memset (&lv_remote_domain_set_vcpus_args, 0, sizeof lv_remote_domain_set_vcpus_args);
 
319
        break;
302
320
case REMOTE_PROC_DOMAIN_SHUTDOWN:
303
 
        fn = (dispatch_fn) remoteDispatchDomainShutdown;
304
 
        args_filter = (xdrproc_t) xdr_remote_domain_shutdown_args;
305
 
        args = (char *) &lv_remote_domain_shutdown_args;
306
 
        memset (&lv_remote_domain_shutdown_args, 0, sizeof lv_remote_domain_shutdown_args);
307
 
        break;
 
321
        fn = (dispatch_fn) remoteDispatchDomainShutdown;
 
322
        args_filter = (xdrproc_t) xdr_remote_domain_shutdown_args;
 
323
        args = (char *) &lv_remote_domain_shutdown_args;
 
324
        memset (&lv_remote_domain_shutdown_args, 0, sizeof lv_remote_domain_shutdown_args);
 
325
        break;
308
326
case REMOTE_PROC_DOMAIN_SUSPEND:
309
 
        fn = (dispatch_fn) remoteDispatchDomainSuspend;
310
 
        args_filter = (xdrproc_t) xdr_remote_domain_suspend_args;
311
 
        args = (char *) &lv_remote_domain_suspend_args;
312
 
        memset (&lv_remote_domain_suspend_args, 0, sizeof lv_remote_domain_suspend_args);
313
 
        break;
 
327
        fn = (dispatch_fn) remoteDispatchDomainSuspend;
 
328
        args_filter = (xdrproc_t) xdr_remote_domain_suspend_args;
 
329
        args = (char *) &lv_remote_domain_suspend_args;
 
330
        memset (&lv_remote_domain_suspend_args, 0, sizeof lv_remote_domain_suspend_args);
 
331
        break;
314
332
case REMOTE_PROC_DOMAIN_UNDEFINE:
315
 
        fn = (dispatch_fn) remoteDispatchDomainUndefine;
316
 
        args_filter = (xdrproc_t) xdr_remote_domain_undefine_args;
317
 
        args = (char *) &lv_remote_domain_undefine_args;
318
 
        memset (&lv_remote_domain_undefine_args, 0, sizeof lv_remote_domain_undefine_args);
319
 
        break;
 
333
        fn = (dispatch_fn) remoteDispatchDomainUndefine;
 
334
        args_filter = (xdrproc_t) xdr_remote_domain_undefine_args;
 
335
        args = (char *) &lv_remote_domain_undefine_args;
 
336
        memset (&lv_remote_domain_undefine_args, 0, sizeof lv_remote_domain_undefine_args);
 
337
        break;
320
338
case REMOTE_PROC_GET_CAPABILITIES:
321
 
        fn = (dispatch_fn) remoteDispatchGetCapabilities;
322
 
        ret_filter = (xdrproc_t) xdr_remote_get_capabilities_ret;
323
 
        ret = (char *) &lv_remote_get_capabilities_ret;
324
 
        memset (&lv_remote_get_capabilities_ret, 0, sizeof lv_remote_get_capabilities_ret);
325
 
        break;
 
339
        fn = (dispatch_fn) remoteDispatchGetCapabilities;
 
340
        ret_filter = (xdrproc_t) xdr_remote_get_capabilities_ret;
 
341
        ret = (char *) &lv_remote_get_capabilities_ret;
 
342
        memset (&lv_remote_get_capabilities_ret, 0, sizeof lv_remote_get_capabilities_ret);
 
343
        break;
326
344
case REMOTE_PROC_GET_HOSTNAME:
327
 
        fn = (dispatch_fn) remoteDispatchGetHostname;
328
 
        ret_filter = (xdrproc_t) xdr_remote_get_hostname_ret;
329
 
        ret = (char *) &lv_remote_get_hostname_ret;
330
 
        memset (&lv_remote_get_hostname_ret, 0, sizeof lv_remote_get_hostname_ret);
331
 
        break;
 
345
        fn = (dispatch_fn) remoteDispatchGetHostname;
 
346
        ret_filter = (xdrproc_t) xdr_remote_get_hostname_ret;
 
347
        ret = (char *) &lv_remote_get_hostname_ret;
 
348
        memset (&lv_remote_get_hostname_ret, 0, sizeof lv_remote_get_hostname_ret);
 
349
        break;
332
350
case REMOTE_PROC_GET_MAX_VCPUS:
333
 
        fn = (dispatch_fn) remoteDispatchGetMaxVcpus;
334
 
        args_filter = (xdrproc_t) xdr_remote_get_max_vcpus_args;
335
 
        args = (char *) &lv_remote_get_max_vcpus_args;
336
 
        memset (&lv_remote_get_max_vcpus_args, 0, sizeof lv_remote_get_max_vcpus_args);
337
 
        ret_filter = (xdrproc_t) xdr_remote_get_max_vcpus_ret;
338
 
        ret = (char *) &lv_remote_get_max_vcpus_ret;
339
 
        memset (&lv_remote_get_max_vcpus_ret, 0, sizeof lv_remote_get_max_vcpus_ret);
340
 
        break;
 
351
        fn = (dispatch_fn) remoteDispatchGetMaxVcpus;
 
352
        args_filter = (xdrproc_t) xdr_remote_get_max_vcpus_args;
 
353
        args = (char *) &lv_remote_get_max_vcpus_args;
 
354
        memset (&lv_remote_get_max_vcpus_args, 0, sizeof lv_remote_get_max_vcpus_args);
 
355
        ret_filter = (xdrproc_t) xdr_remote_get_max_vcpus_ret;
 
356
        ret = (char *) &lv_remote_get_max_vcpus_ret;
 
357
        memset (&lv_remote_get_max_vcpus_ret, 0, sizeof lv_remote_get_max_vcpus_ret);
 
358
        break;
341
359
case REMOTE_PROC_GET_TYPE:
342
 
        fn = (dispatch_fn) remoteDispatchGetType;
343
 
        ret_filter = (xdrproc_t) xdr_remote_get_type_ret;
344
 
        ret = (char *) &lv_remote_get_type_ret;
345
 
        memset (&lv_remote_get_type_ret, 0, sizeof lv_remote_get_type_ret);
346
 
        break;
 
360
        fn = (dispatch_fn) remoteDispatchGetType;
 
361
        ret_filter = (xdrproc_t) xdr_remote_get_type_ret;
 
362
        ret = (char *) &lv_remote_get_type_ret;
 
363
        memset (&lv_remote_get_type_ret, 0, sizeof lv_remote_get_type_ret);
 
364
        break;
347
365
case REMOTE_PROC_GET_VERSION:
348
 
        fn = (dispatch_fn) remoteDispatchGetVersion;
349
 
        ret_filter = (xdrproc_t) xdr_remote_get_version_ret;
350
 
        ret = (char *) &lv_remote_get_version_ret;
351
 
        memset (&lv_remote_get_version_ret, 0, sizeof lv_remote_get_version_ret);
352
 
        break;
 
366
        fn = (dispatch_fn) remoteDispatchGetVersion;
 
367
        ret_filter = (xdrproc_t) xdr_remote_get_version_ret;
 
368
        ret = (char *) &lv_remote_get_version_ret;
 
369
        memset (&lv_remote_get_version_ret, 0, sizeof lv_remote_get_version_ret);
 
370
        break;
353
371
case REMOTE_PROC_LIST_DEFINED_DOMAINS:
354
 
        fn = (dispatch_fn) remoteDispatchListDefinedDomains;
355
 
        args_filter = (xdrproc_t) xdr_remote_list_defined_domains_args;
356
 
        args = (char *) &lv_remote_list_defined_domains_args;
357
 
        memset (&lv_remote_list_defined_domains_args, 0, sizeof lv_remote_list_defined_domains_args);
358
 
        ret_filter = (xdrproc_t) xdr_remote_list_defined_domains_ret;
359
 
        ret = (char *) &lv_remote_list_defined_domains_ret;
360
 
        memset (&lv_remote_list_defined_domains_ret, 0, sizeof lv_remote_list_defined_domains_ret);
361
 
        break;
 
372
        fn = (dispatch_fn) remoteDispatchListDefinedDomains;
 
373
        args_filter = (xdrproc_t) xdr_remote_list_defined_domains_args;
 
374
        args = (char *) &lv_remote_list_defined_domains_args;
 
375
        memset (&lv_remote_list_defined_domains_args, 0, sizeof lv_remote_list_defined_domains_args);
 
376
        ret_filter = (xdrproc_t) xdr_remote_list_defined_domains_ret;
 
377
        ret = (char *) &lv_remote_list_defined_domains_ret;
 
378
        memset (&lv_remote_list_defined_domains_ret, 0, sizeof lv_remote_list_defined_domains_ret);
 
379
        break;
362
380
case REMOTE_PROC_LIST_DEFINED_NETWORKS:
363
 
        fn = (dispatch_fn) remoteDispatchListDefinedNetworks;
364
 
        args_filter = (xdrproc_t) xdr_remote_list_defined_networks_args;
365
 
        args = (char *) &lv_remote_list_defined_networks_args;
366
 
        memset (&lv_remote_list_defined_networks_args, 0, sizeof lv_remote_list_defined_networks_args);
367
 
        ret_filter = (xdrproc_t) xdr_remote_list_defined_networks_ret;
368
 
        ret = (char *) &lv_remote_list_defined_networks_ret;
369
 
        memset (&lv_remote_list_defined_networks_ret, 0, sizeof lv_remote_list_defined_networks_ret);
370
 
        break;
 
381
        fn = (dispatch_fn) remoteDispatchListDefinedNetworks;
 
382
        args_filter = (xdrproc_t) xdr_remote_list_defined_networks_args;
 
383
        args = (char *) &lv_remote_list_defined_networks_args;
 
384
        memset (&lv_remote_list_defined_networks_args, 0, sizeof lv_remote_list_defined_networks_args);
 
385
        ret_filter = (xdrproc_t) xdr_remote_list_defined_networks_ret;
 
386
        ret = (char *) &lv_remote_list_defined_networks_ret;
 
387
        memset (&lv_remote_list_defined_networks_ret, 0, sizeof lv_remote_list_defined_networks_ret);
 
388
        break;
371
389
case REMOTE_PROC_LIST_DEFINED_STORAGE_POOLS:
372
 
        fn = (dispatch_fn) remoteDispatchListDefinedStoragePools;
373
 
        args_filter = (xdrproc_t) xdr_remote_list_defined_storage_pools_args;
374
 
        args = (char *) &lv_remote_list_defined_storage_pools_args;
375
 
        memset (&lv_remote_list_defined_storage_pools_args, 0, sizeof lv_remote_list_defined_storage_pools_args);
376
 
        ret_filter = (xdrproc_t) xdr_remote_list_defined_storage_pools_ret;
377
 
        ret = (char *) &lv_remote_list_defined_storage_pools_ret;
378
 
        memset (&lv_remote_list_defined_storage_pools_ret, 0, sizeof lv_remote_list_defined_storage_pools_ret);
379
 
        break;
 
390
        fn = (dispatch_fn) remoteDispatchListDefinedStoragePools;
 
391
        args_filter = (xdrproc_t) xdr_remote_list_defined_storage_pools_args;
 
392
        args = (char *) &lv_remote_list_defined_storage_pools_args;
 
393
        memset (&lv_remote_list_defined_storage_pools_args, 0, sizeof lv_remote_list_defined_storage_pools_args);
 
394
        ret_filter = (xdrproc_t) xdr_remote_list_defined_storage_pools_ret;
 
395
        ret = (char *) &lv_remote_list_defined_storage_pools_ret;
 
396
        memset (&lv_remote_list_defined_storage_pools_ret, 0, sizeof lv_remote_list_defined_storage_pools_ret);
 
397
        break;
380
398
case REMOTE_PROC_LIST_DOMAINS:
381
 
        fn = (dispatch_fn) remoteDispatchListDomains;
382
 
        args_filter = (xdrproc_t) xdr_remote_list_domains_args;
383
 
        args = (char *) &lv_remote_list_domains_args;
384
 
        memset (&lv_remote_list_domains_args, 0, sizeof lv_remote_list_domains_args);
385
 
        ret_filter = (xdrproc_t) xdr_remote_list_domains_ret;
386
 
        ret = (char *) &lv_remote_list_domains_ret;
387
 
        memset (&lv_remote_list_domains_ret, 0, sizeof lv_remote_list_domains_ret);
388
 
        break;
 
399
        fn = (dispatch_fn) remoteDispatchListDomains;
 
400
        args_filter = (xdrproc_t) xdr_remote_list_domains_args;
 
401
        args = (char *) &lv_remote_list_domains_args;
 
402
        memset (&lv_remote_list_domains_args, 0, sizeof lv_remote_list_domains_args);
 
403
        ret_filter = (xdrproc_t) xdr_remote_list_domains_ret;
 
404
        ret = (char *) &lv_remote_list_domains_ret;
 
405
        memset (&lv_remote_list_domains_ret, 0, sizeof lv_remote_list_domains_ret);
 
406
        break;
389
407
case REMOTE_PROC_LIST_NETWORKS:
390
 
        fn = (dispatch_fn) remoteDispatchListNetworks;
391
 
        args_filter = (xdrproc_t) xdr_remote_list_networks_args;
392
 
        args = (char *) &lv_remote_list_networks_args;
393
 
        memset (&lv_remote_list_networks_args, 0, sizeof lv_remote_list_networks_args);
394
 
        ret_filter = (xdrproc_t) xdr_remote_list_networks_ret;
395
 
        ret = (char *) &lv_remote_list_networks_ret;
396
 
        memset (&lv_remote_list_networks_ret, 0, sizeof lv_remote_list_networks_ret);
397
 
        break;
 
408
        fn = (dispatch_fn) remoteDispatchListNetworks;
 
409
        args_filter = (xdrproc_t) xdr_remote_list_networks_args;
 
410
        args = (char *) &lv_remote_list_networks_args;
 
411
        memset (&lv_remote_list_networks_args, 0, sizeof lv_remote_list_networks_args);
 
412
        ret_filter = (xdrproc_t) xdr_remote_list_networks_ret;
 
413
        ret = (char *) &lv_remote_list_networks_ret;
 
414
        memset (&lv_remote_list_networks_ret, 0, sizeof lv_remote_list_networks_ret);
 
415
        break;
398
416
case REMOTE_PROC_LIST_STORAGE_POOLS:
399
 
        fn = (dispatch_fn) remoteDispatchListStoragePools;
400
 
        args_filter = (xdrproc_t) xdr_remote_list_storage_pools_args;
401
 
        args = (char *) &lv_remote_list_storage_pools_args;
402
 
        memset (&lv_remote_list_storage_pools_args, 0, sizeof lv_remote_list_storage_pools_args);
403
 
        ret_filter = (xdrproc_t) xdr_remote_list_storage_pools_ret;
404
 
        ret = (char *) &lv_remote_list_storage_pools_ret;
405
 
        memset (&lv_remote_list_storage_pools_ret, 0, sizeof lv_remote_list_storage_pools_ret);
406
 
        break;
 
417
        fn = (dispatch_fn) remoteDispatchListStoragePools;
 
418
        args_filter = (xdrproc_t) xdr_remote_list_storage_pools_args;
 
419
        args = (char *) &lv_remote_list_storage_pools_args;
 
420
        memset (&lv_remote_list_storage_pools_args, 0, sizeof lv_remote_list_storage_pools_args);
 
421
        ret_filter = (xdrproc_t) xdr_remote_list_storage_pools_ret;
 
422
        ret = (char *) &lv_remote_list_storage_pools_ret;
 
423
        memset (&lv_remote_list_storage_pools_ret, 0, sizeof lv_remote_list_storage_pools_ret);
 
424
        break;
407
425
case REMOTE_PROC_NETWORK_CREATE:
408
 
        fn = (dispatch_fn) remoteDispatchNetworkCreate;
409
 
        args_filter = (xdrproc_t) xdr_remote_network_create_args;
410
 
        args = (char *) &lv_remote_network_create_args;
411
 
        memset (&lv_remote_network_create_args, 0, sizeof lv_remote_network_create_args);
412
 
        break;
 
426
        fn = (dispatch_fn) remoteDispatchNetworkCreate;
 
427
        args_filter = (xdrproc_t) xdr_remote_network_create_args;
 
428
        args = (char *) &lv_remote_network_create_args;
 
429
        memset (&lv_remote_network_create_args, 0, sizeof lv_remote_network_create_args);
 
430
        break;
413
431
case REMOTE_PROC_NETWORK_CREATE_XML:
414
 
        fn = (dispatch_fn) remoteDispatchNetworkCreateXml;
415
 
        args_filter = (xdrproc_t) xdr_remote_network_create_xml_args;
416
 
        args = (char *) &lv_remote_network_create_xml_args;
417
 
        memset (&lv_remote_network_create_xml_args, 0, sizeof lv_remote_network_create_xml_args);
418
 
        ret_filter = (xdrproc_t) xdr_remote_network_create_xml_ret;
419
 
        ret = (char *) &lv_remote_network_create_xml_ret;
420
 
        memset (&lv_remote_network_create_xml_ret, 0, sizeof lv_remote_network_create_xml_ret);
421
 
        break;
 
432
        fn = (dispatch_fn) remoteDispatchNetworkCreateXml;
 
433
        args_filter = (xdrproc_t) xdr_remote_network_create_xml_args;
 
434
        args = (char *) &lv_remote_network_create_xml_args;
 
435
        memset (&lv_remote_network_create_xml_args, 0, sizeof lv_remote_network_create_xml_args);
 
436
        ret_filter = (xdrproc_t) xdr_remote_network_create_xml_ret;
 
437
        ret = (char *) &lv_remote_network_create_xml_ret;
 
438
        memset (&lv_remote_network_create_xml_ret, 0, sizeof lv_remote_network_create_xml_ret);
 
439
        break;
422
440
case REMOTE_PROC_NETWORK_DEFINE_XML:
423
 
        fn = (dispatch_fn) remoteDispatchNetworkDefineXml;
424
 
        args_filter = (xdrproc_t) xdr_remote_network_define_xml_args;
425
 
        args = (char *) &lv_remote_network_define_xml_args;
426
 
        memset (&lv_remote_network_define_xml_args, 0, sizeof lv_remote_network_define_xml_args);
427
 
        ret_filter = (xdrproc_t) xdr_remote_network_define_xml_ret;
428
 
        ret = (char *) &lv_remote_network_define_xml_ret;
429
 
        memset (&lv_remote_network_define_xml_ret, 0, sizeof lv_remote_network_define_xml_ret);
430
 
        break;
 
441
        fn = (dispatch_fn) remoteDispatchNetworkDefineXml;
 
442
        args_filter = (xdrproc_t) xdr_remote_network_define_xml_args;
 
443
        args = (char *) &lv_remote_network_define_xml_args;
 
444
        memset (&lv_remote_network_define_xml_args, 0, sizeof lv_remote_network_define_xml_args);
 
445
        ret_filter = (xdrproc_t) xdr_remote_network_define_xml_ret;
 
446
        ret = (char *) &lv_remote_network_define_xml_ret;
 
447
        memset (&lv_remote_network_define_xml_ret, 0, sizeof lv_remote_network_define_xml_ret);
 
448
        break;
431
449
case REMOTE_PROC_NETWORK_DESTROY:
432
 
        fn = (dispatch_fn) remoteDispatchNetworkDestroy;
433
 
        args_filter = (xdrproc_t) xdr_remote_network_destroy_args;
434
 
        args = (char *) &lv_remote_network_destroy_args;
435
 
        memset (&lv_remote_network_destroy_args, 0, sizeof lv_remote_network_destroy_args);
436
 
        break;
 
450
        fn = (dispatch_fn) remoteDispatchNetworkDestroy;
 
451
        args_filter = (xdrproc_t) xdr_remote_network_destroy_args;
 
452
        args = (char *) &lv_remote_network_destroy_args;
 
453
        memset (&lv_remote_network_destroy_args, 0, sizeof lv_remote_network_destroy_args);
 
454
        break;
437
455
case REMOTE_PROC_NETWORK_DUMP_XML:
438
 
        fn = (dispatch_fn) remoteDispatchNetworkDumpXml;
439
 
        args_filter = (xdrproc_t) xdr_remote_network_dump_xml_args;
440
 
        args = (char *) &lv_remote_network_dump_xml_args;
441
 
        memset (&lv_remote_network_dump_xml_args, 0, sizeof lv_remote_network_dump_xml_args);
442
 
        ret_filter = (xdrproc_t) xdr_remote_network_dump_xml_ret;
443
 
        ret = (char *) &lv_remote_network_dump_xml_ret;
444
 
        memset (&lv_remote_network_dump_xml_ret, 0, sizeof lv_remote_network_dump_xml_ret);
445
 
        break;
 
456
        fn = (dispatch_fn) remoteDispatchNetworkDumpXml;
 
457
        args_filter = (xdrproc_t) xdr_remote_network_dump_xml_args;
 
458
        args = (char *) &lv_remote_network_dump_xml_args;
 
459
        memset (&lv_remote_network_dump_xml_args, 0, sizeof lv_remote_network_dump_xml_args);
 
460
        ret_filter = (xdrproc_t) xdr_remote_network_dump_xml_ret;
 
461
        ret = (char *) &lv_remote_network_dump_xml_ret;
 
462
        memset (&lv_remote_network_dump_xml_ret, 0, sizeof lv_remote_network_dump_xml_ret);
 
463
        break;
446
464
case REMOTE_PROC_NETWORK_GET_AUTOSTART:
447
 
        fn = (dispatch_fn) remoteDispatchNetworkGetAutostart;
448
 
        args_filter = (xdrproc_t) xdr_remote_network_get_autostart_args;
449
 
        args = (char *) &lv_remote_network_get_autostart_args;
450
 
        memset (&lv_remote_network_get_autostart_args, 0, sizeof lv_remote_network_get_autostart_args);
451
 
        ret_filter = (xdrproc_t) xdr_remote_network_get_autostart_ret;
452
 
        ret = (char *) &lv_remote_network_get_autostart_ret;
453
 
        memset (&lv_remote_network_get_autostart_ret, 0, sizeof lv_remote_network_get_autostart_ret);
454
 
        break;
 
465
        fn = (dispatch_fn) remoteDispatchNetworkGetAutostart;
 
466
        args_filter = (xdrproc_t) xdr_remote_network_get_autostart_args;
 
467
        args = (char *) &lv_remote_network_get_autostart_args;
 
468
        memset (&lv_remote_network_get_autostart_args, 0, sizeof lv_remote_network_get_autostart_args);
 
469
        ret_filter = (xdrproc_t) xdr_remote_network_get_autostart_ret;
 
470
        ret = (char *) &lv_remote_network_get_autostart_ret;
 
471
        memset (&lv_remote_network_get_autostart_ret, 0, sizeof lv_remote_network_get_autostart_ret);
 
472
        break;
455
473
case REMOTE_PROC_NETWORK_GET_BRIDGE_NAME:
456
 
        fn = (dispatch_fn) remoteDispatchNetworkGetBridgeName;
457
 
        args_filter = (xdrproc_t) xdr_remote_network_get_bridge_name_args;
458
 
        args = (char *) &lv_remote_network_get_bridge_name_args;
459
 
        memset (&lv_remote_network_get_bridge_name_args, 0, sizeof lv_remote_network_get_bridge_name_args);
460
 
        ret_filter = (xdrproc_t) xdr_remote_network_get_bridge_name_ret;
461
 
        ret = (char *) &lv_remote_network_get_bridge_name_ret;
462
 
        memset (&lv_remote_network_get_bridge_name_ret, 0, sizeof lv_remote_network_get_bridge_name_ret);
463
 
        break;
 
474
        fn = (dispatch_fn) remoteDispatchNetworkGetBridgeName;
 
475
        args_filter = (xdrproc_t) xdr_remote_network_get_bridge_name_args;
 
476
        args = (char *) &lv_remote_network_get_bridge_name_args;
 
477
        memset (&lv_remote_network_get_bridge_name_args, 0, sizeof lv_remote_network_get_bridge_name_args);
 
478
        ret_filter = (xdrproc_t) xdr_remote_network_get_bridge_name_ret;
 
479
        ret = (char *) &lv_remote_network_get_bridge_name_ret;
 
480
        memset (&lv_remote_network_get_bridge_name_ret, 0, sizeof lv_remote_network_get_bridge_name_ret);
 
481
        break;
464
482
case REMOTE_PROC_NETWORK_LOOKUP_BY_NAME:
465
 
        fn = (dispatch_fn) remoteDispatchNetworkLookupByName;
466
 
        args_filter = (xdrproc_t) xdr_remote_network_lookup_by_name_args;
467
 
        args = (char *) &lv_remote_network_lookup_by_name_args;
468
 
        memset (&lv_remote_network_lookup_by_name_args, 0, sizeof lv_remote_network_lookup_by_name_args);
469
 
        ret_filter = (xdrproc_t) xdr_remote_network_lookup_by_name_ret;
470
 
        ret = (char *) &lv_remote_network_lookup_by_name_ret;
471
 
        memset (&lv_remote_network_lookup_by_name_ret, 0, sizeof lv_remote_network_lookup_by_name_ret);
472
 
        break;
 
483
        fn = (dispatch_fn) remoteDispatchNetworkLookupByName;
 
484
        args_filter = (xdrproc_t) xdr_remote_network_lookup_by_name_args;
 
485
        args = (char *) &lv_remote_network_lookup_by_name_args;
 
486
        memset (&lv_remote_network_lookup_by_name_args, 0, sizeof lv_remote_network_lookup_by_name_args);
 
487
        ret_filter = (xdrproc_t) xdr_remote_network_lookup_by_name_ret;
 
488
        ret = (char *) &lv_remote_network_lookup_by_name_ret;
 
489
        memset (&lv_remote_network_lookup_by_name_ret, 0, sizeof lv_remote_network_lookup_by_name_ret);
 
490
        break;
473
491
case REMOTE_PROC_NETWORK_LOOKUP_BY_UUID:
474
 
        fn = (dispatch_fn) remoteDispatchNetworkLookupByUuid;
475
 
        args_filter = (xdrproc_t) xdr_remote_network_lookup_by_uuid_args;
476
 
        args = (char *) &lv_remote_network_lookup_by_uuid_args;
477
 
        memset (&lv_remote_network_lookup_by_uuid_args, 0, sizeof lv_remote_network_lookup_by_uuid_args);
478
 
        ret_filter = (xdrproc_t) xdr_remote_network_lookup_by_uuid_ret;
479
 
        ret = (char *) &lv_remote_network_lookup_by_uuid_ret;
480
 
        memset (&lv_remote_network_lookup_by_uuid_ret, 0, sizeof lv_remote_network_lookup_by_uuid_ret);
481
 
        break;
 
492
        fn = (dispatch_fn) remoteDispatchNetworkLookupByUuid;
 
493
        args_filter = (xdrproc_t) xdr_remote_network_lookup_by_uuid_args;
 
494
        args = (char *) &lv_remote_network_lookup_by_uuid_args;
 
495
        memset (&lv_remote_network_lookup_by_uuid_args, 0, sizeof lv_remote_network_lookup_by_uuid_args);
 
496
        ret_filter = (xdrproc_t) xdr_remote_network_lookup_by_uuid_ret;
 
497
        ret = (char *) &lv_remote_network_lookup_by_uuid_ret;
 
498
        memset (&lv_remote_network_lookup_by_uuid_ret, 0, sizeof lv_remote_network_lookup_by_uuid_ret);
 
499
        break;
482
500
case REMOTE_PROC_NETWORK_SET_AUTOSTART:
483
 
        fn = (dispatch_fn) remoteDispatchNetworkSetAutostart;
484
 
        args_filter = (xdrproc_t) xdr_remote_network_set_autostart_args;
485
 
        args = (char *) &lv_remote_network_set_autostart_args;
486
 
        memset (&lv_remote_network_set_autostart_args, 0, sizeof lv_remote_network_set_autostart_args);
487
 
        break;
 
501
        fn = (dispatch_fn) remoteDispatchNetworkSetAutostart;
 
502
        args_filter = (xdrproc_t) xdr_remote_network_set_autostart_args;
 
503
        args = (char *) &lv_remote_network_set_autostart_args;
 
504
        memset (&lv_remote_network_set_autostart_args, 0, sizeof lv_remote_network_set_autostart_args);
 
505
        break;
488
506
case REMOTE_PROC_NETWORK_UNDEFINE:
489
 
        fn = (dispatch_fn) remoteDispatchNetworkUndefine;
490
 
        args_filter = (xdrproc_t) xdr_remote_network_undefine_args;
491
 
        args = (char *) &lv_remote_network_undefine_args;
492
 
        memset (&lv_remote_network_undefine_args, 0, sizeof lv_remote_network_undefine_args);
493
 
        break;
 
507
        fn = (dispatch_fn) remoteDispatchNetworkUndefine;
 
508
        args_filter = (xdrproc_t) xdr_remote_network_undefine_args;
 
509
        args = (char *) &lv_remote_network_undefine_args;
 
510
        memset (&lv_remote_network_undefine_args, 0, sizeof lv_remote_network_undefine_args);
 
511
        break;
 
512
case REMOTE_PROC_NODE_GET_CELLS_FREE_MEMORY:
 
513
        fn = (dispatch_fn) remoteDispatchNodeGetCellsFreeMemory;
 
514
        args_filter = (xdrproc_t) xdr_remote_node_get_cells_free_memory_args;
 
515
        args = (char *) &lv_remote_node_get_cells_free_memory_args;
 
516
        memset (&lv_remote_node_get_cells_free_memory_args, 0, sizeof lv_remote_node_get_cells_free_memory_args);
 
517
        ret_filter = (xdrproc_t) xdr_remote_node_get_cells_free_memory_ret;
 
518
        ret = (char *) &lv_remote_node_get_cells_free_memory_ret;
 
519
        memset (&lv_remote_node_get_cells_free_memory_ret, 0, sizeof lv_remote_node_get_cells_free_memory_ret);
 
520
        break;
 
521
case REMOTE_PROC_NODE_GET_FREE_MEMORY:
 
522
        fn = (dispatch_fn) remoteDispatchNodeGetFreeMemory;
 
523
        ret_filter = (xdrproc_t) xdr_remote_node_get_free_memory_ret;
 
524
        ret = (char *) &lv_remote_node_get_free_memory_ret;
 
525
        memset (&lv_remote_node_get_free_memory_ret, 0, sizeof lv_remote_node_get_free_memory_ret);
 
526
        break;
494
527
case REMOTE_PROC_NODE_GET_INFO:
495
 
        fn = (dispatch_fn) remoteDispatchNodeGetInfo;
496
 
        ret_filter = (xdrproc_t) xdr_remote_node_get_info_ret;
497
 
        ret = (char *) &lv_remote_node_get_info_ret;
498
 
        memset (&lv_remote_node_get_info_ret, 0, sizeof lv_remote_node_get_info_ret);
499
 
        break;
 
528
        fn = (dispatch_fn) remoteDispatchNodeGetInfo;
 
529
        ret_filter = (xdrproc_t) xdr_remote_node_get_info_ret;
 
530
        ret = (char *) &lv_remote_node_get_info_ret;
 
531
        memset (&lv_remote_node_get_info_ret, 0, sizeof lv_remote_node_get_info_ret);
 
532
        break;
500
533
case REMOTE_PROC_NUM_OF_DEFINED_DOMAINS:
501
 
        fn = (dispatch_fn) remoteDispatchNumOfDefinedDomains;
502
 
        ret_filter = (xdrproc_t) xdr_remote_num_of_defined_domains_ret;
503
 
        ret = (char *) &lv_remote_num_of_defined_domains_ret;
504
 
        memset (&lv_remote_num_of_defined_domains_ret, 0, sizeof lv_remote_num_of_defined_domains_ret);
505
 
        break;
 
534
        fn = (dispatch_fn) remoteDispatchNumOfDefinedDomains;
 
535
        ret_filter = (xdrproc_t) xdr_remote_num_of_defined_domains_ret;
 
536
        ret = (char *) &lv_remote_num_of_defined_domains_ret;
 
537
        memset (&lv_remote_num_of_defined_domains_ret, 0, sizeof lv_remote_num_of_defined_domains_ret);
 
538
        break;
506
539
case REMOTE_PROC_NUM_OF_DEFINED_NETWORKS:
507
 
        fn = (dispatch_fn) remoteDispatchNumOfDefinedNetworks;
508
 
        ret_filter = (xdrproc_t) xdr_remote_num_of_defined_networks_ret;
509
 
        ret = (char *) &lv_remote_num_of_defined_networks_ret;
510
 
        memset (&lv_remote_num_of_defined_networks_ret, 0, sizeof lv_remote_num_of_defined_networks_ret);
511
 
        break;
 
540
        fn = (dispatch_fn) remoteDispatchNumOfDefinedNetworks;
 
541
        ret_filter = (xdrproc_t) xdr_remote_num_of_defined_networks_ret;
 
542
        ret = (char *) &lv_remote_num_of_defined_networks_ret;
 
543
        memset (&lv_remote_num_of_defined_networks_ret, 0, sizeof lv_remote_num_of_defined_networks_ret);
 
544
        break;
512
545
case REMOTE_PROC_NUM_OF_DEFINED_STORAGE_POOLS:
513
 
        fn = (dispatch_fn) remoteDispatchNumOfDefinedStoragePools;
514
 
        ret_filter = (xdrproc_t) xdr_remote_num_of_defined_storage_pools_ret;
515
 
        ret = (char *) &lv_remote_num_of_defined_storage_pools_ret;
516
 
        memset (&lv_remote_num_of_defined_storage_pools_ret, 0, sizeof lv_remote_num_of_defined_storage_pools_ret);
517
 
        break;
 
546
        fn = (dispatch_fn) remoteDispatchNumOfDefinedStoragePools;
 
547
        ret_filter = (xdrproc_t) xdr_remote_num_of_defined_storage_pools_ret;
 
548
        ret = (char *) &lv_remote_num_of_defined_storage_pools_ret;
 
549
        memset (&lv_remote_num_of_defined_storage_pools_ret, 0, sizeof lv_remote_num_of_defined_storage_pools_ret);
 
550
        break;
518
551
case REMOTE_PROC_NUM_OF_DOMAINS:
519
 
        fn = (dispatch_fn) remoteDispatchNumOfDomains;
520
 
        ret_filter = (xdrproc_t) xdr_remote_num_of_domains_ret;
521
 
        ret = (char *) &lv_remote_num_of_domains_ret;
522
 
        memset (&lv_remote_num_of_domains_ret, 0, sizeof lv_remote_num_of_domains_ret);
523
 
        break;
 
552
        fn = (dispatch_fn) remoteDispatchNumOfDomains;
 
553
        ret_filter = (xdrproc_t) xdr_remote_num_of_domains_ret;
 
554
        ret = (char *) &lv_remote_num_of_domains_ret;
 
555
        memset (&lv_remote_num_of_domains_ret, 0, sizeof lv_remote_num_of_domains_ret);
 
556
        break;
524
557
case REMOTE_PROC_NUM_OF_NETWORKS:
525
 
        fn = (dispatch_fn) remoteDispatchNumOfNetworks;
526
 
        ret_filter = (xdrproc_t) xdr_remote_num_of_networks_ret;
527
 
        ret = (char *) &lv_remote_num_of_networks_ret;
528
 
        memset (&lv_remote_num_of_networks_ret, 0, sizeof lv_remote_num_of_networks_ret);
529
 
        break;
 
558
        fn = (dispatch_fn) remoteDispatchNumOfNetworks;
 
559
        ret_filter = (xdrproc_t) xdr_remote_num_of_networks_ret;
 
560
        ret = (char *) &lv_remote_num_of_networks_ret;
 
561
        memset (&lv_remote_num_of_networks_ret, 0, sizeof lv_remote_num_of_networks_ret);
 
562
        break;
530
563
case REMOTE_PROC_NUM_OF_STORAGE_POOLS:
531
 
        fn = (dispatch_fn) remoteDispatchNumOfStoragePools;
532
 
        ret_filter = (xdrproc_t) xdr_remote_num_of_storage_pools_ret;
533
 
        ret = (char *) &lv_remote_num_of_storage_pools_ret;
534
 
        memset (&lv_remote_num_of_storage_pools_ret, 0, sizeof lv_remote_num_of_storage_pools_ret);
535
 
        break;
 
564
        fn = (dispatch_fn) remoteDispatchNumOfStoragePools;
 
565
        ret_filter = (xdrproc_t) xdr_remote_num_of_storage_pools_ret;
 
566
        ret = (char *) &lv_remote_num_of_storage_pools_ret;
 
567
        memset (&lv_remote_num_of_storage_pools_ret, 0, sizeof lv_remote_num_of_storage_pools_ret);
 
568
        break;
536
569
case REMOTE_PROC_OPEN:
537
 
        fn = (dispatch_fn) remoteDispatchOpen;
538
 
        args_filter = (xdrproc_t) xdr_remote_open_args;
539
 
        args = (char *) &lv_remote_open_args;
540
 
        memset (&lv_remote_open_args, 0, sizeof lv_remote_open_args);
541
 
        break;
 
570
        fn = (dispatch_fn) remoteDispatchOpen;
 
571
        args_filter = (xdrproc_t) xdr_remote_open_args;
 
572
        args = (char *) &lv_remote_open_args;
 
573
        memset (&lv_remote_open_args, 0, sizeof lv_remote_open_args);
 
574
        break;
542
575
case REMOTE_PROC_STORAGE_POOL_BUILD:
543
 
        fn = (dispatch_fn) remoteDispatchStoragePoolBuild;
544
 
        args_filter = (xdrproc_t) xdr_remote_storage_pool_build_args;
545
 
        args = (char *) &lv_remote_storage_pool_build_args;
546
 
        memset (&lv_remote_storage_pool_build_args, 0, sizeof lv_remote_storage_pool_build_args);
547
 
        break;
 
576
        fn = (dispatch_fn) remoteDispatchStoragePoolBuild;
 
577
        args_filter = (xdrproc_t) xdr_remote_storage_pool_build_args;
 
578
        args = (char *) &lv_remote_storage_pool_build_args;
 
579
        memset (&lv_remote_storage_pool_build_args, 0, sizeof lv_remote_storage_pool_build_args);
 
580
        break;
548
581
case REMOTE_PROC_STORAGE_POOL_CREATE:
549
 
        fn = (dispatch_fn) remoteDispatchStoragePoolCreate;
550
 
        args_filter = (xdrproc_t) xdr_remote_storage_pool_create_args;
551
 
        args = (char *) &lv_remote_storage_pool_create_args;
552
 
        memset (&lv_remote_storage_pool_create_args, 0, sizeof lv_remote_storage_pool_create_args);
553
 
        break;
 
582
        fn = (dispatch_fn) remoteDispatchStoragePoolCreate;
 
583
        args_filter = (xdrproc_t) xdr_remote_storage_pool_create_args;
 
584
        args = (char *) &lv_remote_storage_pool_create_args;
 
585
        memset (&lv_remote_storage_pool_create_args, 0, sizeof lv_remote_storage_pool_create_args);
 
586
        break;
554
587
case REMOTE_PROC_STORAGE_POOL_CREATE_XML:
555
 
        fn = (dispatch_fn) remoteDispatchStoragePoolCreateXml;
556
 
        args_filter = (xdrproc_t) xdr_remote_storage_pool_create_xml_args;
557
 
        args = (char *) &lv_remote_storage_pool_create_xml_args;
558
 
        memset (&lv_remote_storage_pool_create_xml_args, 0, sizeof lv_remote_storage_pool_create_xml_args);
559
 
        ret_filter = (xdrproc_t) xdr_remote_storage_pool_create_xml_ret;
560
 
        ret = (char *) &lv_remote_storage_pool_create_xml_ret;
561
 
        memset (&lv_remote_storage_pool_create_xml_ret, 0, sizeof lv_remote_storage_pool_create_xml_ret);
562
 
        break;
 
588
        fn = (dispatch_fn) remoteDispatchStoragePoolCreateXml;
 
589
        args_filter = (xdrproc_t) xdr_remote_storage_pool_create_xml_args;
 
590
        args = (char *) &lv_remote_storage_pool_create_xml_args;
 
591
        memset (&lv_remote_storage_pool_create_xml_args, 0, sizeof lv_remote_storage_pool_create_xml_args);
 
592
        ret_filter = (xdrproc_t) xdr_remote_storage_pool_create_xml_ret;
 
593
        ret = (char *) &lv_remote_storage_pool_create_xml_ret;
 
594
        memset (&lv_remote_storage_pool_create_xml_ret, 0, sizeof lv_remote_storage_pool_create_xml_ret);
 
595
        break;
563
596
case REMOTE_PROC_STORAGE_POOL_DEFINE_XML:
564
 
        fn = (dispatch_fn) remoteDispatchStoragePoolDefineXml;
565
 
        args_filter = (xdrproc_t) xdr_remote_storage_pool_define_xml_args;
566
 
        args = (char *) &lv_remote_storage_pool_define_xml_args;
567
 
        memset (&lv_remote_storage_pool_define_xml_args, 0, sizeof lv_remote_storage_pool_define_xml_args);
568
 
        ret_filter = (xdrproc_t) xdr_remote_storage_pool_define_xml_ret;
569
 
        ret = (char *) &lv_remote_storage_pool_define_xml_ret;
570
 
        memset (&lv_remote_storage_pool_define_xml_ret, 0, sizeof lv_remote_storage_pool_define_xml_ret);
571
 
        break;
 
597
        fn = (dispatch_fn) remoteDispatchStoragePoolDefineXml;
 
598
        args_filter = (xdrproc_t) xdr_remote_storage_pool_define_xml_args;
 
599
        args = (char *) &lv_remote_storage_pool_define_xml_args;
 
600
        memset (&lv_remote_storage_pool_define_xml_args, 0, sizeof lv_remote_storage_pool_define_xml_args);
 
601
        ret_filter = (xdrproc_t) xdr_remote_storage_pool_define_xml_ret;
 
602
        ret = (char *) &lv_remote_storage_pool_define_xml_ret;
 
603
        memset (&lv_remote_storage_pool_define_xml_ret, 0, sizeof lv_remote_storage_pool_define_xml_ret);
 
604
        break;
572
605
case REMOTE_PROC_STORAGE_POOL_DELETE:
573
 
        fn = (dispatch_fn) remoteDispatchStoragePoolDelete;
574
 
        args_filter = (xdrproc_t) xdr_remote_storage_pool_delete_args;
575
 
        args = (char *) &lv_remote_storage_pool_delete_args;
576
 
        memset (&lv_remote_storage_pool_delete_args, 0, sizeof lv_remote_storage_pool_delete_args);
577
 
        break;
 
606
        fn = (dispatch_fn) remoteDispatchStoragePoolDelete;
 
607
        args_filter = (xdrproc_t) xdr_remote_storage_pool_delete_args;
 
608
        args = (char *) &lv_remote_storage_pool_delete_args;
 
609
        memset (&lv_remote_storage_pool_delete_args, 0, sizeof lv_remote_storage_pool_delete_args);
 
610
        break;
578
611
case REMOTE_PROC_STORAGE_POOL_DESTROY:
579
 
        fn = (dispatch_fn) remoteDispatchStoragePoolDestroy;
580
 
        args_filter = (xdrproc_t) xdr_remote_storage_pool_destroy_args;
581
 
        args = (char *) &lv_remote_storage_pool_destroy_args;
582
 
        memset (&lv_remote_storage_pool_destroy_args, 0, sizeof lv_remote_storage_pool_destroy_args);
583
 
        break;
 
612
        fn = (dispatch_fn) remoteDispatchStoragePoolDestroy;
 
613
        args_filter = (xdrproc_t) xdr_remote_storage_pool_destroy_args;
 
614
        args = (char *) &lv_remote_storage_pool_destroy_args;
 
615
        memset (&lv_remote_storage_pool_destroy_args, 0, sizeof lv_remote_storage_pool_destroy_args);
 
616
        break;
584
617
case REMOTE_PROC_STORAGE_POOL_DUMP_XML:
585
 
        fn = (dispatch_fn) remoteDispatchStoragePoolDumpXml;
586
 
        args_filter = (xdrproc_t) xdr_remote_storage_pool_dump_xml_args;
587
 
        args = (char *) &lv_remote_storage_pool_dump_xml_args;
588
 
        memset (&lv_remote_storage_pool_dump_xml_args, 0, sizeof lv_remote_storage_pool_dump_xml_args);
589
 
        ret_filter = (xdrproc_t) xdr_remote_storage_pool_dump_xml_ret;
590
 
        ret = (char *) &lv_remote_storage_pool_dump_xml_ret;
591
 
        memset (&lv_remote_storage_pool_dump_xml_ret, 0, sizeof lv_remote_storage_pool_dump_xml_ret);
592
 
        break;
 
618
        fn = (dispatch_fn) remoteDispatchStoragePoolDumpXml;
 
619
        args_filter = (xdrproc_t) xdr_remote_storage_pool_dump_xml_args;
 
620
        args = (char *) &lv_remote_storage_pool_dump_xml_args;
 
621
        memset (&lv_remote_storage_pool_dump_xml_args, 0, sizeof lv_remote_storage_pool_dump_xml_args);
 
622
        ret_filter = (xdrproc_t) xdr_remote_storage_pool_dump_xml_ret;
 
623
        ret = (char *) &lv_remote_storage_pool_dump_xml_ret;
 
624
        memset (&lv_remote_storage_pool_dump_xml_ret, 0, sizeof lv_remote_storage_pool_dump_xml_ret);
 
625
        break;
593
626
case REMOTE_PROC_STORAGE_POOL_GET_AUTOSTART:
594
 
        fn = (dispatch_fn) remoteDispatchStoragePoolGetAutostart;
595
 
        args_filter = (xdrproc_t) xdr_remote_storage_pool_get_autostart_args;
596
 
        args = (char *) &lv_remote_storage_pool_get_autostart_args;
597
 
        memset (&lv_remote_storage_pool_get_autostart_args, 0, sizeof lv_remote_storage_pool_get_autostart_args);
598
 
        ret_filter = (xdrproc_t) xdr_remote_storage_pool_get_autostart_ret;
599
 
        ret = (char *) &lv_remote_storage_pool_get_autostart_ret;
600
 
        memset (&lv_remote_storage_pool_get_autostart_ret, 0, sizeof lv_remote_storage_pool_get_autostart_ret);
601
 
        break;
 
627
        fn = (dispatch_fn) remoteDispatchStoragePoolGetAutostart;
 
628
        args_filter = (xdrproc_t) xdr_remote_storage_pool_get_autostart_args;
 
629
        args = (char *) &lv_remote_storage_pool_get_autostart_args;
 
630
        memset (&lv_remote_storage_pool_get_autostart_args, 0, sizeof lv_remote_storage_pool_get_autostart_args);
 
631
        ret_filter = (xdrproc_t) xdr_remote_storage_pool_get_autostart_ret;
 
632
        ret = (char *) &lv_remote_storage_pool_get_autostart_ret;
 
633
        memset (&lv_remote_storage_pool_get_autostart_ret, 0, sizeof lv_remote_storage_pool_get_autostart_ret);
 
634
        break;
602
635
case REMOTE_PROC_STORAGE_POOL_GET_INFO:
603
 
        fn = (dispatch_fn) remoteDispatchStoragePoolGetInfo;
604
 
        args_filter = (xdrproc_t) xdr_remote_storage_pool_get_info_args;
605
 
        args = (char *) &lv_remote_storage_pool_get_info_args;
606
 
        memset (&lv_remote_storage_pool_get_info_args, 0, sizeof lv_remote_storage_pool_get_info_args);
607
 
        ret_filter = (xdrproc_t) xdr_remote_storage_pool_get_info_ret;
608
 
        ret = (char *) &lv_remote_storage_pool_get_info_ret;
609
 
        memset (&lv_remote_storage_pool_get_info_ret, 0, sizeof lv_remote_storage_pool_get_info_ret);
610
 
        break;
 
636
        fn = (dispatch_fn) remoteDispatchStoragePoolGetInfo;
 
637
        args_filter = (xdrproc_t) xdr_remote_storage_pool_get_info_args;
 
638
        args = (char *) &lv_remote_storage_pool_get_info_args;
 
639
        memset (&lv_remote_storage_pool_get_info_args, 0, sizeof lv_remote_storage_pool_get_info_args);
 
640
        ret_filter = (xdrproc_t) xdr_remote_storage_pool_get_info_ret;
 
641
        ret = (char *) &lv_remote_storage_pool_get_info_ret;
 
642
        memset (&lv_remote_storage_pool_get_info_ret, 0, sizeof lv_remote_storage_pool_get_info_ret);
 
643
        break;
611
644
case REMOTE_PROC_STORAGE_POOL_LIST_VOLUMES:
612
 
        fn = (dispatch_fn) remoteDispatchStoragePoolListVolumes;
613
 
        args_filter = (xdrproc_t) xdr_remote_storage_pool_list_volumes_args;
614
 
        args = (char *) &lv_remote_storage_pool_list_volumes_args;
615
 
        memset (&lv_remote_storage_pool_list_volumes_args, 0, sizeof lv_remote_storage_pool_list_volumes_args);
616
 
        ret_filter = (xdrproc_t) xdr_remote_storage_pool_list_volumes_ret;
617
 
        ret = (char *) &lv_remote_storage_pool_list_volumes_ret;
618
 
        memset (&lv_remote_storage_pool_list_volumes_ret, 0, sizeof lv_remote_storage_pool_list_volumes_ret);
619
 
        break;
 
645
        fn = (dispatch_fn) remoteDispatchStoragePoolListVolumes;
 
646
        args_filter = (xdrproc_t) xdr_remote_storage_pool_list_volumes_args;
 
647
        args = (char *) &lv_remote_storage_pool_list_volumes_args;
 
648
        memset (&lv_remote_storage_pool_list_volumes_args, 0, sizeof lv_remote_storage_pool_list_volumes_args);
 
649
        ret_filter = (xdrproc_t) xdr_remote_storage_pool_list_volumes_ret;
 
650
        ret = (char *) &lv_remote_storage_pool_list_volumes_ret;
 
651
        memset (&lv_remote_storage_pool_list_volumes_ret, 0, sizeof lv_remote_storage_pool_list_volumes_ret);
 
652
        break;
620
653
case REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_NAME:
621
 
        fn = (dispatch_fn) remoteDispatchStoragePoolLookupByName;
622
 
        args_filter = (xdrproc_t) xdr_remote_storage_pool_lookup_by_name_args;
623
 
        args = (char *) &lv_remote_storage_pool_lookup_by_name_args;
624
 
        memset (&lv_remote_storage_pool_lookup_by_name_args, 0, sizeof lv_remote_storage_pool_lookup_by_name_args);
625
 
        ret_filter = (xdrproc_t) xdr_remote_storage_pool_lookup_by_name_ret;
626
 
        ret = (char *) &lv_remote_storage_pool_lookup_by_name_ret;
627
 
        memset (&lv_remote_storage_pool_lookup_by_name_ret, 0, sizeof lv_remote_storage_pool_lookup_by_name_ret);
628
 
        break;
 
654
        fn = (dispatch_fn) remoteDispatchStoragePoolLookupByName;
 
655
        args_filter = (xdrproc_t) xdr_remote_storage_pool_lookup_by_name_args;
 
656
        args = (char *) &lv_remote_storage_pool_lookup_by_name_args;
 
657
        memset (&lv_remote_storage_pool_lookup_by_name_args, 0, sizeof lv_remote_storage_pool_lookup_by_name_args);
 
658
        ret_filter = (xdrproc_t) xdr_remote_storage_pool_lookup_by_name_ret;
 
659
        ret = (char *) &lv_remote_storage_pool_lookup_by_name_ret;
 
660
        memset (&lv_remote_storage_pool_lookup_by_name_ret, 0, sizeof lv_remote_storage_pool_lookup_by_name_ret);
 
661
        break;
629
662
case REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_UUID:
630
 
        fn = (dispatch_fn) remoteDispatchStoragePoolLookupByUuid;
631
 
        args_filter = (xdrproc_t) xdr_remote_storage_pool_lookup_by_uuid_args;
632
 
        args = (char *) &lv_remote_storage_pool_lookup_by_uuid_args;
633
 
        memset (&lv_remote_storage_pool_lookup_by_uuid_args, 0, sizeof lv_remote_storage_pool_lookup_by_uuid_args);
634
 
        ret_filter = (xdrproc_t) xdr_remote_storage_pool_lookup_by_uuid_ret;
635
 
        ret = (char *) &lv_remote_storage_pool_lookup_by_uuid_ret;
636
 
        memset (&lv_remote_storage_pool_lookup_by_uuid_ret, 0, sizeof lv_remote_storage_pool_lookup_by_uuid_ret);
637
 
        break;
 
663
        fn = (dispatch_fn) remoteDispatchStoragePoolLookupByUuid;
 
664
        args_filter = (xdrproc_t) xdr_remote_storage_pool_lookup_by_uuid_args;
 
665
        args = (char *) &lv_remote_storage_pool_lookup_by_uuid_args;
 
666
        memset (&lv_remote_storage_pool_lookup_by_uuid_args, 0, sizeof lv_remote_storage_pool_lookup_by_uuid_args);
 
667
        ret_filter = (xdrproc_t) xdr_remote_storage_pool_lookup_by_uuid_ret;
 
668
        ret = (char *) &lv_remote_storage_pool_lookup_by_uuid_ret;
 
669
        memset (&lv_remote_storage_pool_lookup_by_uuid_ret, 0, sizeof lv_remote_storage_pool_lookup_by_uuid_ret);
 
670
        break;
638
671
case REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_VOLUME:
639
 
        fn = (dispatch_fn) remoteDispatchStoragePoolLookupByVolume;
640
 
        args_filter = (xdrproc_t) xdr_remote_storage_pool_lookup_by_volume_args;
641
 
        args = (char *) &lv_remote_storage_pool_lookup_by_volume_args;
642
 
        memset (&lv_remote_storage_pool_lookup_by_volume_args, 0, sizeof lv_remote_storage_pool_lookup_by_volume_args);
643
 
        ret_filter = (xdrproc_t) xdr_remote_storage_pool_lookup_by_volume_ret;
644
 
        ret = (char *) &lv_remote_storage_pool_lookup_by_volume_ret;
645
 
        memset (&lv_remote_storage_pool_lookup_by_volume_ret, 0, sizeof lv_remote_storage_pool_lookup_by_volume_ret);
646
 
        break;
 
672
        fn = (dispatch_fn) remoteDispatchStoragePoolLookupByVolume;
 
673
        args_filter = (xdrproc_t) xdr_remote_storage_pool_lookup_by_volume_args;
 
674
        args = (char *) &lv_remote_storage_pool_lookup_by_volume_args;
 
675
        memset (&lv_remote_storage_pool_lookup_by_volume_args, 0, sizeof lv_remote_storage_pool_lookup_by_volume_args);
 
676
        ret_filter = (xdrproc_t) xdr_remote_storage_pool_lookup_by_volume_ret;
 
677
        ret = (char *) &lv_remote_storage_pool_lookup_by_volume_ret;
 
678
        memset (&lv_remote_storage_pool_lookup_by_volume_ret, 0, sizeof lv_remote_storage_pool_lookup_by_volume_ret);
 
679
        break;
647
680
case REMOTE_PROC_STORAGE_POOL_NUM_OF_VOLUMES:
648
 
        fn = (dispatch_fn) remoteDispatchStoragePoolNumOfVolumes;
649
 
        args_filter = (xdrproc_t) xdr_remote_storage_pool_num_of_volumes_args;
650
 
        args = (char *) &lv_remote_storage_pool_num_of_volumes_args;
651
 
        memset (&lv_remote_storage_pool_num_of_volumes_args, 0, sizeof lv_remote_storage_pool_num_of_volumes_args);
652
 
        ret_filter = (xdrproc_t) xdr_remote_storage_pool_num_of_volumes_ret;
653
 
        ret = (char *) &lv_remote_storage_pool_num_of_volumes_ret;
654
 
        memset (&lv_remote_storage_pool_num_of_volumes_ret, 0, sizeof lv_remote_storage_pool_num_of_volumes_ret);
655
 
        break;
 
681
        fn = (dispatch_fn) remoteDispatchStoragePoolNumOfVolumes;
 
682
        args_filter = (xdrproc_t) xdr_remote_storage_pool_num_of_volumes_args;
 
683
        args = (char *) &lv_remote_storage_pool_num_of_volumes_args;
 
684
        memset (&lv_remote_storage_pool_num_of_volumes_args, 0, sizeof lv_remote_storage_pool_num_of_volumes_args);
 
685
        ret_filter = (xdrproc_t) xdr_remote_storage_pool_num_of_volumes_ret;
 
686
        ret = (char *) &lv_remote_storage_pool_num_of_volumes_ret;
 
687
        memset (&lv_remote_storage_pool_num_of_volumes_ret, 0, sizeof lv_remote_storage_pool_num_of_volumes_ret);
 
688
        break;
656
689
case REMOTE_PROC_STORAGE_POOL_REFRESH:
657
 
        fn = (dispatch_fn) remoteDispatchStoragePoolRefresh;
658
 
        args_filter = (xdrproc_t) xdr_remote_storage_pool_refresh_args;
659
 
        args = (char *) &lv_remote_storage_pool_refresh_args;
660
 
        memset (&lv_remote_storage_pool_refresh_args, 0, sizeof lv_remote_storage_pool_refresh_args);
661
 
        break;
 
690
        fn = (dispatch_fn) remoteDispatchStoragePoolRefresh;
 
691
        args_filter = (xdrproc_t) xdr_remote_storage_pool_refresh_args;
 
692
        args = (char *) &lv_remote_storage_pool_refresh_args;
 
693
        memset (&lv_remote_storage_pool_refresh_args, 0, sizeof lv_remote_storage_pool_refresh_args);
 
694
        break;
662
695
case REMOTE_PROC_STORAGE_POOL_SET_AUTOSTART:
663
 
        fn = (dispatch_fn) remoteDispatchStoragePoolSetAutostart;
664
 
        args_filter = (xdrproc_t) xdr_remote_storage_pool_set_autostart_args;
665
 
        args = (char *) &lv_remote_storage_pool_set_autostart_args;
666
 
        memset (&lv_remote_storage_pool_set_autostart_args, 0, sizeof lv_remote_storage_pool_set_autostart_args);
667
 
        break;
 
696
        fn = (dispatch_fn) remoteDispatchStoragePoolSetAutostart;
 
697
        args_filter = (xdrproc_t) xdr_remote_storage_pool_set_autostart_args;
 
698
        args = (char *) &lv_remote_storage_pool_set_autostart_args;
 
699
        memset (&lv_remote_storage_pool_set_autostart_args, 0, sizeof lv_remote_storage_pool_set_autostart_args);
 
700
        break;
668
701
case REMOTE_PROC_STORAGE_POOL_UNDEFINE:
669
 
        fn = (dispatch_fn) remoteDispatchStoragePoolUndefine;
670
 
        args_filter = (xdrproc_t) xdr_remote_storage_pool_undefine_args;
671
 
        args = (char *) &lv_remote_storage_pool_undefine_args;
672
 
        memset (&lv_remote_storage_pool_undefine_args, 0, sizeof lv_remote_storage_pool_undefine_args);
673
 
        break;
 
702
        fn = (dispatch_fn) remoteDispatchStoragePoolUndefine;
 
703
        args_filter = (xdrproc_t) xdr_remote_storage_pool_undefine_args;
 
704
        args = (char *) &lv_remote_storage_pool_undefine_args;
 
705
        memset (&lv_remote_storage_pool_undefine_args, 0, sizeof lv_remote_storage_pool_undefine_args);
 
706
        break;
674
707
case REMOTE_PROC_STORAGE_VOL_CREATE_XML:
675
 
        fn = (dispatch_fn) remoteDispatchStorageVolCreateXml;
676
 
        args_filter = (xdrproc_t) xdr_remote_storage_vol_create_xml_args;
677
 
        args = (char *) &lv_remote_storage_vol_create_xml_args;
678
 
        memset (&lv_remote_storage_vol_create_xml_args, 0, sizeof lv_remote_storage_vol_create_xml_args);
679
 
        ret_filter = (xdrproc_t) xdr_remote_storage_vol_create_xml_ret;
680
 
        ret = (char *) &lv_remote_storage_vol_create_xml_ret;
681
 
        memset (&lv_remote_storage_vol_create_xml_ret, 0, sizeof lv_remote_storage_vol_create_xml_ret);
682
 
        break;
 
708
        fn = (dispatch_fn) remoteDispatchStorageVolCreateXml;
 
709
        args_filter = (xdrproc_t) xdr_remote_storage_vol_create_xml_args;
 
710
        args = (char *) &lv_remote_storage_vol_create_xml_args;
 
711
        memset (&lv_remote_storage_vol_create_xml_args, 0, sizeof lv_remote_storage_vol_create_xml_args);
 
712
        ret_filter = (xdrproc_t) xdr_remote_storage_vol_create_xml_ret;
 
713
        ret = (char *) &lv_remote_storage_vol_create_xml_ret;
 
714
        memset (&lv_remote_storage_vol_create_xml_ret, 0, sizeof lv_remote_storage_vol_create_xml_ret);
 
715
        break;
683
716
case REMOTE_PROC_STORAGE_VOL_DELETE:
684
 
        fn = (dispatch_fn) remoteDispatchStorageVolDelete;
685
 
        args_filter = (xdrproc_t) xdr_remote_storage_vol_delete_args;
686
 
        args = (char *) &lv_remote_storage_vol_delete_args;
687
 
        memset (&lv_remote_storage_vol_delete_args, 0, sizeof lv_remote_storage_vol_delete_args);
688
 
        break;
 
717
        fn = (dispatch_fn) remoteDispatchStorageVolDelete;
 
718
        args_filter = (xdrproc_t) xdr_remote_storage_vol_delete_args;
 
719
        args = (char *) &lv_remote_storage_vol_delete_args;
 
720
        memset (&lv_remote_storage_vol_delete_args, 0, sizeof lv_remote_storage_vol_delete_args);
 
721
        break;
689
722
case REMOTE_PROC_STORAGE_VOL_DUMP_XML:
690
 
        fn = (dispatch_fn) remoteDispatchStorageVolDumpXml;
691
 
        args_filter = (xdrproc_t) xdr_remote_storage_vol_dump_xml_args;
692
 
        args = (char *) &lv_remote_storage_vol_dump_xml_args;
693
 
        memset (&lv_remote_storage_vol_dump_xml_args, 0, sizeof lv_remote_storage_vol_dump_xml_args);
694
 
        ret_filter = (xdrproc_t) xdr_remote_storage_vol_dump_xml_ret;
695
 
        ret = (char *) &lv_remote_storage_vol_dump_xml_ret;
696
 
        memset (&lv_remote_storage_vol_dump_xml_ret, 0, sizeof lv_remote_storage_vol_dump_xml_ret);
697
 
        break;
 
723
        fn = (dispatch_fn) remoteDispatchStorageVolDumpXml;
 
724
        args_filter = (xdrproc_t) xdr_remote_storage_vol_dump_xml_args;
 
725
        args = (char *) &lv_remote_storage_vol_dump_xml_args;
 
726
        memset (&lv_remote_storage_vol_dump_xml_args, 0, sizeof lv_remote_storage_vol_dump_xml_args);
 
727
        ret_filter = (xdrproc_t) xdr_remote_storage_vol_dump_xml_ret;
 
728
        ret = (char *) &lv_remote_storage_vol_dump_xml_ret;
 
729
        memset (&lv_remote_storage_vol_dump_xml_ret, 0, sizeof lv_remote_storage_vol_dump_xml_ret);
 
730
        break;
698
731
case REMOTE_PROC_STORAGE_VOL_GET_INFO:
699
 
        fn = (dispatch_fn) remoteDispatchStorageVolGetInfo;
700
 
        args_filter = (xdrproc_t) xdr_remote_storage_vol_get_info_args;
701
 
        args = (char *) &lv_remote_storage_vol_get_info_args;
702
 
        memset (&lv_remote_storage_vol_get_info_args, 0, sizeof lv_remote_storage_vol_get_info_args);
703
 
        ret_filter = (xdrproc_t) xdr_remote_storage_vol_get_info_ret;
704
 
        ret = (char *) &lv_remote_storage_vol_get_info_ret;
705
 
        memset (&lv_remote_storage_vol_get_info_ret, 0, sizeof lv_remote_storage_vol_get_info_ret);
706
 
        break;
 
732
        fn = (dispatch_fn) remoteDispatchStorageVolGetInfo;
 
733
        args_filter = (xdrproc_t) xdr_remote_storage_vol_get_info_args;
 
734
        args = (char *) &lv_remote_storage_vol_get_info_args;
 
735
        memset (&lv_remote_storage_vol_get_info_args, 0, sizeof lv_remote_storage_vol_get_info_args);
 
736
        ret_filter = (xdrproc_t) xdr_remote_storage_vol_get_info_ret;
 
737
        ret = (char *) &lv_remote_storage_vol_get_info_ret;
 
738
        memset (&lv_remote_storage_vol_get_info_ret, 0, sizeof lv_remote_storage_vol_get_info_ret);
 
739
        break;
707
740
case REMOTE_PROC_STORAGE_VOL_GET_PATH:
708
 
        fn = (dispatch_fn) remoteDispatchStorageVolGetPath;
709
 
        args_filter = (xdrproc_t) xdr_remote_storage_vol_get_path_args;
710
 
        args = (char *) &lv_remote_storage_vol_get_path_args;
711
 
        memset (&lv_remote_storage_vol_get_path_args, 0, sizeof lv_remote_storage_vol_get_path_args);
712
 
        ret_filter = (xdrproc_t) xdr_remote_storage_vol_get_path_ret;
713
 
        ret = (char *) &lv_remote_storage_vol_get_path_ret;
714
 
        memset (&lv_remote_storage_vol_get_path_ret, 0, sizeof lv_remote_storage_vol_get_path_ret);
715
 
        break;
 
741
        fn = (dispatch_fn) remoteDispatchStorageVolGetPath;
 
742
        args_filter = (xdrproc_t) xdr_remote_storage_vol_get_path_args;
 
743
        args = (char *) &lv_remote_storage_vol_get_path_args;
 
744
        memset (&lv_remote_storage_vol_get_path_args, 0, sizeof lv_remote_storage_vol_get_path_args);
 
745
        ret_filter = (xdrproc_t) xdr_remote_storage_vol_get_path_ret;
 
746
        ret = (char *) &lv_remote_storage_vol_get_path_ret;
 
747
        memset (&lv_remote_storage_vol_get_path_ret, 0, sizeof lv_remote_storage_vol_get_path_ret);
 
748
        break;
716
749
case REMOTE_PROC_STORAGE_VOL_LOOKUP_BY_KEY:
717
 
        fn = (dispatch_fn) remoteDispatchStorageVolLookupByKey;
718
 
        args_filter = (xdrproc_t) xdr_remote_storage_vol_lookup_by_key_args;
719
 
        args = (char *) &lv_remote_storage_vol_lookup_by_key_args;
720
 
        memset (&lv_remote_storage_vol_lookup_by_key_args, 0, sizeof lv_remote_storage_vol_lookup_by_key_args);
721
 
        ret_filter = (xdrproc_t) xdr_remote_storage_vol_lookup_by_key_ret;
722
 
        ret = (char *) &lv_remote_storage_vol_lookup_by_key_ret;
723
 
        memset (&lv_remote_storage_vol_lookup_by_key_ret, 0, sizeof lv_remote_storage_vol_lookup_by_key_ret);
724
 
        break;
 
750
        fn = (dispatch_fn) remoteDispatchStorageVolLookupByKey;
 
751
        args_filter = (xdrproc_t) xdr_remote_storage_vol_lookup_by_key_args;
 
752
        args = (char *) &lv_remote_storage_vol_lookup_by_key_args;
 
753
        memset (&lv_remote_storage_vol_lookup_by_key_args, 0, sizeof lv_remote_storage_vol_lookup_by_key_args);
 
754
        ret_filter = (xdrproc_t) xdr_remote_storage_vol_lookup_by_key_ret;
 
755
        ret = (char *) &lv_remote_storage_vol_lookup_by_key_ret;
 
756
        memset (&lv_remote_storage_vol_lookup_by_key_ret, 0, sizeof lv_remote_storage_vol_lookup_by_key_ret);
 
757
        break;
725
758
case REMOTE_PROC_STORAGE_VOL_LOOKUP_BY_NAME:
726
 
        fn = (dispatch_fn) remoteDispatchStorageVolLookupByName;
727
 
        args_filter = (xdrproc_t) xdr_remote_storage_vol_lookup_by_name_args;
728
 
        args = (char *) &lv_remote_storage_vol_lookup_by_name_args;
729
 
        memset (&lv_remote_storage_vol_lookup_by_name_args, 0, sizeof lv_remote_storage_vol_lookup_by_name_args);
730
 
        ret_filter = (xdrproc_t) xdr_remote_storage_vol_lookup_by_name_ret;
731
 
        ret = (char *) &lv_remote_storage_vol_lookup_by_name_ret;
732
 
        memset (&lv_remote_storage_vol_lookup_by_name_ret, 0, sizeof lv_remote_storage_vol_lookup_by_name_ret);
733
 
        break;
 
759
        fn = (dispatch_fn) remoteDispatchStorageVolLookupByName;
 
760
        args_filter = (xdrproc_t) xdr_remote_storage_vol_lookup_by_name_args;
 
761
        args = (char *) &lv_remote_storage_vol_lookup_by_name_args;
 
762
        memset (&lv_remote_storage_vol_lookup_by_name_args, 0, sizeof lv_remote_storage_vol_lookup_by_name_args);
 
763
        ret_filter = (xdrproc_t) xdr_remote_storage_vol_lookup_by_name_ret;
 
764
        ret = (char *) &lv_remote_storage_vol_lookup_by_name_ret;
 
765
        memset (&lv_remote_storage_vol_lookup_by_name_ret, 0, sizeof lv_remote_storage_vol_lookup_by_name_ret);
 
766
        break;
734
767
case REMOTE_PROC_STORAGE_VOL_LOOKUP_BY_PATH:
735
 
        fn = (dispatch_fn) remoteDispatchStorageVolLookupByPath;
736
 
        args_filter = (xdrproc_t) xdr_remote_storage_vol_lookup_by_path_args;
737
 
        args = (char *) &lv_remote_storage_vol_lookup_by_path_args;
738
 
        memset (&lv_remote_storage_vol_lookup_by_path_args, 0, sizeof lv_remote_storage_vol_lookup_by_path_args);
739
 
        ret_filter = (xdrproc_t) xdr_remote_storage_vol_lookup_by_path_ret;
740
 
        ret = (char *) &lv_remote_storage_vol_lookup_by_path_ret;
741
 
        memset (&lv_remote_storage_vol_lookup_by_path_ret, 0, sizeof lv_remote_storage_vol_lookup_by_path_ret);
742
 
        break;
 
768
        fn = (dispatch_fn) remoteDispatchStorageVolLookupByPath;
 
769
        args_filter = (xdrproc_t) xdr_remote_storage_vol_lookup_by_path_args;
 
770
        args = (char *) &lv_remote_storage_vol_lookup_by_path_args;
 
771
        memset (&lv_remote_storage_vol_lookup_by_path_args, 0, sizeof lv_remote_storage_vol_lookup_by_path_args);
 
772
        ret_filter = (xdrproc_t) xdr_remote_storage_vol_lookup_by_path_ret;
 
773
        ret = (char *) &lv_remote_storage_vol_lookup_by_path_ret;
 
774
        memset (&lv_remote_storage_vol_lookup_by_path_ret, 0, sizeof lv_remote_storage_vol_lookup_by_path_ret);
 
775
        break;
743
776
case REMOTE_PROC_SUPPORTS_FEATURE:
744
 
        fn = (dispatch_fn) remoteDispatchSupportsFeature;
745
 
        args_filter = (xdrproc_t) xdr_remote_supports_feature_args;
746
 
        args = (char *) &lv_remote_supports_feature_args;
747
 
        memset (&lv_remote_supports_feature_args, 0, sizeof lv_remote_supports_feature_args);
748
 
        ret_filter = (xdrproc_t) xdr_remote_supports_feature_ret;
749
 
        ret = (char *) &lv_remote_supports_feature_ret;
750
 
        memset (&lv_remote_supports_feature_ret, 0, sizeof lv_remote_supports_feature_ret);
751
 
        break;
 
777
        fn = (dispatch_fn) remoteDispatchSupportsFeature;
 
778
        args_filter = (xdrproc_t) xdr_remote_supports_feature_args;
 
779
        args = (char *) &lv_remote_supports_feature_args;
 
780
        memset (&lv_remote_supports_feature_args, 0, sizeof lv_remote_supports_feature_args);
 
781
        ret_filter = (xdrproc_t) xdr_remote_supports_feature_ret;
 
782
        ret = (char *) &lv_remote_supports_feature_ret;
 
783
        memset (&lv_remote_supports_feature_ret, 0, sizeof lv_remote_supports_feature_ret);
 
784
        break;