slyphon-zookeeper 0.9.1-java → 0.9.2-java

Sign up to get free protection for your applications and to get access to all the features.
data/ext/zkrb_wrapper.c CHANGED
@@ -21,20 +21,14 @@ static VALUE zkrb_gvl_zoo_recv_timeout(void *data) {
21
21
 
22
22
  // wrapper that calls zoo_recv_timeout via zkrb_gvl_zoo_recv_timeout inside rb_thread_blocking_region
23
23
  int zkrb_call_zoo_recv_timeout(zhandle_t *zh) {
24
- int rc = ZKRB_FAIL;
25
- zkrb_zoo_recv_timeout_args_t *ptr = malloc(sizeof(zkrb_zoo_recv_timeout_args_t));
26
- check_mem(ptr);
24
+ zkrb_zoo_recv_timeout_args_t args = {
25
+ .rc = ZKRB_FAIL,
26
+ .zh = zh
27
+ };
27
28
 
28
- ptr->rc = rc;
29
- ptr->zh = zh;
29
+ zkrb_thread_blocking_region(zkrb_gvl_zoo_recv_timeout, (void *)&args);
30
30
 
31
- zkrb_thread_blocking_region(zkrb_gvl_zoo_recv_timeout, (void *)ptr);
32
-
33
- rc = ptr->rc;
34
-
35
- error:
36
- free(ptr);
37
- return rc;
31
+ return args.rc;
38
32
  }
39
33
 
40
34
 
@@ -46,20 +40,14 @@ static VALUE zkrb_gvl_zoo_state(void *data) {
46
40
 
47
41
  // wrapper that calls zoo_state via zkrb_gvl_zoo_state inside rb_thread_blocking_region
48
42
  int zkrb_call_zoo_state(zhandle_t *zh) {
49
- int rc = ZKRB_FAIL;
50
- zkrb_zoo_state_args_t *ptr = malloc(sizeof(zkrb_zoo_state_args_t));
51
- check_mem(ptr);
52
-
53
- ptr->rc = rc;
54
- ptr->zh = zh;
55
-
56
- zkrb_thread_blocking_region(zkrb_gvl_zoo_state, (void *)ptr);
43
+ zkrb_zoo_state_args_t args = {
44
+ .rc = ZKRB_FAIL,
45
+ .zh = zh
46
+ };
57
47
 
58
- rc = ptr->rc;
48
+ zkrb_thread_blocking_region(zkrb_gvl_zoo_state, (void *)&args);
59
49
 
60
- error:
61
- free(ptr);
62
- return rc;
50
+ return args.rc;
63
51
  }
64
52
 
65
53
 
@@ -71,27 +59,21 @@ static VALUE zkrb_gvl_zoo_acreate(void *data) {
71
59
 
72
60
  // wrapper that calls zoo_acreate via zkrb_gvl_zoo_acreate inside rb_thread_blocking_region
73
61
  int zkrb_call_zoo_acreate(zhandle_t *zh, const char *path, const char *value, int valuelen, const struct ACL_vector *acl, int flags, string_completion_t completion, const void *data) {
74
- int rc = ZKRB_FAIL;
75
- zkrb_zoo_acreate_args_t *ptr = malloc(sizeof(zkrb_zoo_acreate_args_t));
76
- check_mem(ptr);
62
+ zkrb_zoo_acreate_args_t args = {
63
+ .rc = ZKRB_FAIL,
64
+ .zh = zh,
65
+ .path = path,
66
+ .value = value,
67
+ .valuelen = valuelen,
68
+ .acl = acl,
69
+ .flags = flags,
70
+ .completion = completion,
71
+ .data = data
72
+ };
77
73
 
78
- ptr->rc = rc;
79
- ptr->zh = zh;
80
- ptr->path = path;
81
- ptr->value = value;
82
- ptr->valuelen = valuelen;
83
- ptr->acl = acl;
84
- ptr->flags = flags;
85
- ptr->completion = completion;
86
- ptr->data = data;
74
+ zkrb_thread_blocking_region(zkrb_gvl_zoo_acreate, (void *)&args);
87
75
 
88
- zkrb_thread_blocking_region(zkrb_gvl_zoo_acreate, (void *)ptr);
89
-
90
- rc = ptr->rc;
91
-
92
- error:
93
- free(ptr);
94
- return rc;
76
+ return args.rc;
95
77
  }
96
78
 
97
79
 
@@ -103,24 +85,18 @@ static VALUE zkrb_gvl_zoo_adelete(void *data) {
103
85
 
104
86
  // wrapper that calls zoo_adelete via zkrb_gvl_zoo_adelete inside rb_thread_blocking_region
105
87
  int zkrb_call_zoo_adelete(zhandle_t *zh, const char *path, int version, void_completion_t completion, const void *data) {
106
- int rc = ZKRB_FAIL;
107
- zkrb_zoo_adelete_args_t *ptr = malloc(sizeof(zkrb_zoo_adelete_args_t));
108
- check_mem(ptr);
109
-
110
- ptr->rc = rc;
111
- ptr->zh = zh;
112
- ptr->path = path;
113
- ptr->version = version;
114
- ptr->completion = completion;
115
- ptr->data = data;
116
-
117
- zkrb_thread_blocking_region(zkrb_gvl_zoo_adelete, (void *)ptr);
88
+ zkrb_zoo_adelete_args_t args = {
89
+ .rc = ZKRB_FAIL,
90
+ .zh = zh,
91
+ .path = path,
92
+ .version = version,
93
+ .completion = completion,
94
+ .data = data
95
+ };
118
96
 
119
- rc = ptr->rc;
97
+ zkrb_thread_blocking_region(zkrb_gvl_zoo_adelete, (void *)&args);
120
98
 
121
- error:
122
- free(ptr);
123
- return rc;
99
+ return args.rc;
124
100
  }
125
101
 
126
102
 
@@ -132,24 +108,18 @@ static VALUE zkrb_gvl_zoo_aexists(void *data) {
132
108
 
133
109
  // wrapper that calls zoo_aexists via zkrb_gvl_zoo_aexists inside rb_thread_blocking_region
134
110
  int zkrb_call_zoo_aexists(zhandle_t *zh, const char *path, int watch, stat_completion_t completion, const void *data) {
135
- int rc = ZKRB_FAIL;
136
- zkrb_zoo_aexists_args_t *ptr = malloc(sizeof(zkrb_zoo_aexists_args_t));
137
- check_mem(ptr);
111
+ zkrb_zoo_aexists_args_t args = {
112
+ .rc = ZKRB_FAIL,
113
+ .zh = zh,
114
+ .path = path,
115
+ .watch = watch,
116
+ .completion = completion,
117
+ .data = data
118
+ };
138
119
 
139
- ptr->rc = rc;
140
- ptr->zh = zh;
141
- ptr->path = path;
142
- ptr->watch = watch;
143
- ptr->completion = completion;
144
- ptr->data = data;
120
+ zkrb_thread_blocking_region(zkrb_gvl_zoo_aexists, (void *)&args);
145
121
 
146
- zkrb_thread_blocking_region(zkrb_gvl_zoo_aexists, (void *)ptr);
147
-
148
- rc = ptr->rc;
149
-
150
- error:
151
- free(ptr);
152
- return rc;
122
+ return args.rc;
153
123
  }
154
124
 
155
125
 
@@ -161,25 +131,19 @@ static VALUE zkrb_gvl_zoo_awexists(void *data) {
161
131
 
162
132
  // wrapper that calls zoo_awexists via zkrb_gvl_zoo_awexists inside rb_thread_blocking_region
163
133
  int zkrb_call_zoo_awexists(zhandle_t *zh, const char *path, watcher_fn watcher, void* watcherCtx, stat_completion_t completion, const void *data) {
164
- int rc = ZKRB_FAIL;
165
- zkrb_zoo_awexists_args_t *ptr = malloc(sizeof(zkrb_zoo_awexists_args_t));
166
- check_mem(ptr);
167
-
168
- ptr->rc = rc;
169
- ptr->zh = zh;
170
- ptr->path = path;
171
- ptr->watcher = watcher;
172
- ptr->watcherCtx = watcherCtx;
173
- ptr->completion = completion;
174
- ptr->data = data;
175
-
176
- zkrb_thread_blocking_region(zkrb_gvl_zoo_awexists, (void *)ptr);
134
+ zkrb_zoo_awexists_args_t args = {
135
+ .rc = ZKRB_FAIL,
136
+ .zh = zh,
137
+ .path = path,
138
+ .watcher = watcher,
139
+ .watcherCtx = watcherCtx,
140
+ .completion = completion,
141
+ .data = data
142
+ };
177
143
 
178
- rc = ptr->rc;
144
+ zkrb_thread_blocking_region(zkrb_gvl_zoo_awexists, (void *)&args);
179
145
 
180
- error:
181
- free(ptr);
182
- return rc;
146
+ return args.rc;
183
147
  }
184
148
 
185
149
 
@@ -191,24 +155,18 @@ static VALUE zkrb_gvl_zoo_aget(void *data) {
191
155
 
192
156
  // wrapper that calls zoo_aget via zkrb_gvl_zoo_aget inside rb_thread_blocking_region
193
157
  int zkrb_call_zoo_aget(zhandle_t *zh, const char *path, int watch, data_completion_t completion, const void *data) {
194
- int rc = ZKRB_FAIL;
195
- zkrb_zoo_aget_args_t *ptr = malloc(sizeof(zkrb_zoo_aget_args_t));
196
- check_mem(ptr);
158
+ zkrb_zoo_aget_args_t args = {
159
+ .rc = ZKRB_FAIL,
160
+ .zh = zh,
161
+ .path = path,
162
+ .watch = watch,
163
+ .completion = completion,
164
+ .data = data
165
+ };
197
166
 
198
- ptr->rc = rc;
199
- ptr->zh = zh;
200
- ptr->path = path;
201
- ptr->watch = watch;
202
- ptr->completion = completion;
203
- ptr->data = data;
167
+ zkrb_thread_blocking_region(zkrb_gvl_zoo_aget, (void *)&args);
204
168
 
205
- zkrb_thread_blocking_region(zkrb_gvl_zoo_aget, (void *)ptr);
206
-
207
- rc = ptr->rc;
208
-
209
- error:
210
- free(ptr);
211
- return rc;
169
+ return args.rc;
212
170
  }
213
171
 
214
172
 
@@ -220,25 +178,19 @@ static VALUE zkrb_gvl_zoo_awget(void *data) {
220
178
 
221
179
  // wrapper that calls zoo_awget via zkrb_gvl_zoo_awget inside rb_thread_blocking_region
222
180
  int zkrb_call_zoo_awget(zhandle_t *zh, const char *path, watcher_fn watcher, void* watcherCtx, data_completion_t completion, const void *data) {
223
- int rc = ZKRB_FAIL;
224
- zkrb_zoo_awget_args_t *ptr = malloc(sizeof(zkrb_zoo_awget_args_t));
225
- check_mem(ptr);
226
-
227
- ptr->rc = rc;
228
- ptr->zh = zh;
229
- ptr->path = path;
230
- ptr->watcher = watcher;
231
- ptr->watcherCtx = watcherCtx;
232
- ptr->completion = completion;
233
- ptr->data = data;
234
-
235
- zkrb_thread_blocking_region(zkrb_gvl_zoo_awget, (void *)ptr);
181
+ zkrb_zoo_awget_args_t args = {
182
+ .rc = ZKRB_FAIL,
183
+ .zh = zh,
184
+ .path = path,
185
+ .watcher = watcher,
186
+ .watcherCtx = watcherCtx,
187
+ .completion = completion,
188
+ .data = data
189
+ };
236
190
 
237
- rc = ptr->rc;
191
+ zkrb_thread_blocking_region(zkrb_gvl_zoo_awget, (void *)&args);
238
192
 
239
- error:
240
- free(ptr);
241
- return rc;
193
+ return args.rc;
242
194
  }
243
195
 
244
196
 
@@ -250,26 +202,20 @@ static VALUE zkrb_gvl_zoo_aset(void *data) {
250
202
 
251
203
  // wrapper that calls zoo_aset via zkrb_gvl_zoo_aset inside rb_thread_blocking_region
252
204
  int zkrb_call_zoo_aset(zhandle_t *zh, const char *path, const char *buffer, int buflen, int version, stat_completion_t completion, const void *data) {
253
- int rc = ZKRB_FAIL;
254
- zkrb_zoo_aset_args_t *ptr = malloc(sizeof(zkrb_zoo_aset_args_t));
255
- check_mem(ptr);
205
+ zkrb_zoo_aset_args_t args = {
206
+ .rc = ZKRB_FAIL,
207
+ .zh = zh,
208
+ .path = path,
209
+ .buffer = buffer,
210
+ .buflen = buflen,
211
+ .version = version,
212
+ .completion = completion,
213
+ .data = data
214
+ };
256
215
 
257
- ptr->rc = rc;
258
- ptr->zh = zh;
259
- ptr->path = path;
260
- ptr->buffer = buffer;
261
- ptr->buflen = buflen;
262
- ptr->version = version;
263
- ptr->completion = completion;
264
- ptr->data = data;
216
+ zkrb_thread_blocking_region(zkrb_gvl_zoo_aset, (void *)&args);
265
217
 
266
- zkrb_thread_blocking_region(zkrb_gvl_zoo_aset, (void *)ptr);
267
-
268
- rc = ptr->rc;
269
-
270
- error:
271
- free(ptr);
272
- return rc;
218
+ return args.rc;
273
219
  }
274
220
 
275
221
 
@@ -281,24 +227,18 @@ static VALUE zkrb_gvl_zoo_aget_children(void *data) {
281
227
 
282
228
  // wrapper that calls zoo_aget_children via zkrb_gvl_zoo_aget_children inside rb_thread_blocking_region
283
229
  int zkrb_call_zoo_aget_children(zhandle_t *zh, const char *path, int watch, strings_completion_t completion, const void *data) {
284
- int rc = ZKRB_FAIL;
285
- zkrb_zoo_aget_children_args_t *ptr = malloc(sizeof(zkrb_zoo_aget_children_args_t));
286
- check_mem(ptr);
287
-
288
- ptr->rc = rc;
289
- ptr->zh = zh;
290
- ptr->path = path;
291
- ptr->watch = watch;
292
- ptr->completion = completion;
293
- ptr->data = data;
294
-
295
- zkrb_thread_blocking_region(zkrb_gvl_zoo_aget_children, (void *)ptr);
230
+ zkrb_zoo_aget_children_args_t args = {
231
+ .rc = ZKRB_FAIL,
232
+ .zh = zh,
233
+ .path = path,
234
+ .watch = watch,
235
+ .completion = completion,
236
+ .data = data
237
+ };
296
238
 
297
- rc = ptr->rc;
239
+ zkrb_thread_blocking_region(zkrb_gvl_zoo_aget_children, (void *)&args);
298
240
 
299
- error:
300
- free(ptr);
301
- return rc;
241
+ return args.rc;
302
242
  }
303
243
 
304
244
 
@@ -310,25 +250,19 @@ static VALUE zkrb_gvl_zoo_awget_children(void *data) {
310
250
 
311
251
  // wrapper that calls zoo_awget_children via zkrb_gvl_zoo_awget_children inside rb_thread_blocking_region
312
252
  int zkrb_call_zoo_awget_children(zhandle_t *zh, const char *path, watcher_fn watcher, void* watcherCtx, strings_completion_t completion, const void *data) {
313
- int rc = ZKRB_FAIL;
314
- zkrb_zoo_awget_children_args_t *ptr = malloc(sizeof(zkrb_zoo_awget_children_args_t));
315
- check_mem(ptr);
253
+ zkrb_zoo_awget_children_args_t args = {
254
+ .rc = ZKRB_FAIL,
255
+ .zh = zh,
256
+ .path = path,
257
+ .watcher = watcher,
258
+ .watcherCtx = watcherCtx,
259
+ .completion = completion,
260
+ .data = data
261
+ };
316
262
 
317
- ptr->rc = rc;
318
- ptr->zh = zh;
319
- ptr->path = path;
320
- ptr->watcher = watcher;
321
- ptr->watcherCtx = watcherCtx;
322
- ptr->completion = completion;
323
- ptr->data = data;
263
+ zkrb_thread_blocking_region(zkrb_gvl_zoo_awget_children, (void *)&args);
324
264
 
325
- zkrb_thread_blocking_region(zkrb_gvl_zoo_awget_children, (void *)ptr);
326
-
327
- rc = ptr->rc;
328
-
329
- error:
330
- free(ptr);
331
- return rc;
265
+ return args.rc;
332
266
  }
333
267
 
334
268
 
@@ -340,24 +274,18 @@ static VALUE zkrb_gvl_zoo_aget_children2(void *data) {
340
274
 
341
275
  // wrapper that calls zoo_aget_children2 via zkrb_gvl_zoo_aget_children2 inside rb_thread_blocking_region
342
276
  int zkrb_call_zoo_aget_children2(zhandle_t *zh, const char *path, int watch, strings_stat_completion_t completion, const void *data) {
343
- int rc = ZKRB_FAIL;
344
- zkrb_zoo_aget_children2_args_t *ptr = malloc(sizeof(zkrb_zoo_aget_children2_args_t));
345
- check_mem(ptr);
346
-
347
- ptr->rc = rc;
348
- ptr->zh = zh;
349
- ptr->path = path;
350
- ptr->watch = watch;
351
- ptr->completion = completion;
352
- ptr->data = data;
353
-
354
- zkrb_thread_blocking_region(zkrb_gvl_zoo_aget_children2, (void *)ptr);
277
+ zkrb_zoo_aget_children2_args_t args = {
278
+ .rc = ZKRB_FAIL,
279
+ .zh = zh,
280
+ .path = path,
281
+ .watch = watch,
282
+ .completion = completion,
283
+ .data = data
284
+ };
355
285
 
356
- rc = ptr->rc;
286
+ zkrb_thread_blocking_region(zkrb_gvl_zoo_aget_children2, (void *)&args);
357
287
 
358
- error:
359
- free(ptr);
360
- return rc;
288
+ return args.rc;
361
289
  }
362
290
 
363
291
 
@@ -369,25 +297,19 @@ static VALUE zkrb_gvl_zoo_awget_children2(void *data) {
369
297
 
370
298
  // wrapper that calls zoo_awget_children2 via zkrb_gvl_zoo_awget_children2 inside rb_thread_blocking_region
371
299
  int zkrb_call_zoo_awget_children2(zhandle_t *zh, const char *path, watcher_fn watcher, void* watcherCtx, strings_stat_completion_t completion, const void *data) {
372
- int rc = ZKRB_FAIL;
373
- zkrb_zoo_awget_children2_args_t *ptr = malloc(sizeof(zkrb_zoo_awget_children2_args_t));
374
- check_mem(ptr);
300
+ zkrb_zoo_awget_children2_args_t args = {
301
+ .rc = ZKRB_FAIL,
302
+ .zh = zh,
303
+ .path = path,
304
+ .watcher = watcher,
305
+ .watcherCtx = watcherCtx,
306
+ .completion = completion,
307
+ .data = data
308
+ };
375
309
 
376
- ptr->rc = rc;
377
- ptr->zh = zh;
378
- ptr->path = path;
379
- ptr->watcher = watcher;
380
- ptr->watcherCtx = watcherCtx;
381
- ptr->completion = completion;
382
- ptr->data = data;
310
+ zkrb_thread_blocking_region(zkrb_gvl_zoo_awget_children2, (void *)&args);
383
311
 
384
- zkrb_thread_blocking_region(zkrb_gvl_zoo_awget_children2, (void *)ptr);
385
-
386
- rc = ptr->rc;
387
-
388
- error:
389
- free(ptr);
390
- return rc;
312
+ return args.rc;
391
313
  }
392
314
 
393
315
 
@@ -399,23 +321,17 @@ static VALUE zkrb_gvl_zoo_async(void *data) {
399
321
 
400
322
  // wrapper that calls zoo_async via zkrb_gvl_zoo_async inside rb_thread_blocking_region
401
323
  int zkrb_call_zoo_async(zhandle_t *zh, const char *path, string_completion_t completion, const void *data) {
402
- int rc = ZKRB_FAIL;
403
- zkrb_zoo_async_args_t *ptr = malloc(sizeof(zkrb_zoo_async_args_t));
404
- check_mem(ptr);
405
-
406
- ptr->rc = rc;
407
- ptr->zh = zh;
408
- ptr->path = path;
409
- ptr->completion = completion;
410
- ptr->data = data;
411
-
412
- zkrb_thread_blocking_region(zkrb_gvl_zoo_async, (void *)ptr);
324
+ zkrb_zoo_async_args_t args = {
325
+ .rc = ZKRB_FAIL,
326
+ .zh = zh,
327
+ .path = path,
328
+ .completion = completion,
329
+ .data = data
330
+ };
413
331
 
414
- rc = ptr->rc;
332
+ zkrb_thread_blocking_region(zkrb_gvl_zoo_async, (void *)&args);
415
333
 
416
- error:
417
- free(ptr);
418
- return rc;
334
+ return args.rc;
419
335
  }
420
336
 
421
337
 
@@ -427,23 +343,17 @@ static VALUE zkrb_gvl_zoo_aget_acl(void *data) {
427
343
 
428
344
  // wrapper that calls zoo_aget_acl via zkrb_gvl_zoo_aget_acl inside rb_thread_blocking_region
429
345
  int zkrb_call_zoo_aget_acl(zhandle_t *zh, const char *path, acl_completion_t completion, const void *data) {
430
- int rc = ZKRB_FAIL;
431
- zkrb_zoo_aget_acl_args_t *ptr = malloc(sizeof(zkrb_zoo_aget_acl_args_t));
432
- check_mem(ptr);
346
+ zkrb_zoo_aget_acl_args_t args = {
347
+ .rc = ZKRB_FAIL,
348
+ .zh = zh,
349
+ .path = path,
350
+ .completion = completion,
351
+ .data = data
352
+ };
433
353
 
434
- ptr->rc = rc;
435
- ptr->zh = zh;
436
- ptr->path = path;
437
- ptr->completion = completion;
438
- ptr->data = data;
354
+ zkrb_thread_blocking_region(zkrb_gvl_zoo_aget_acl, (void *)&args);
439
355
 
440
- zkrb_thread_blocking_region(zkrb_gvl_zoo_aget_acl, (void *)ptr);
441
-
442
- rc = ptr->rc;
443
-
444
- error:
445
- free(ptr);
446
- return rc;
356
+ return args.rc;
447
357
  }
448
358
 
449
359
 
@@ -455,25 +365,19 @@ static VALUE zkrb_gvl_zoo_aset_acl(void *data) {
455
365
 
456
366
  // wrapper that calls zoo_aset_acl via zkrb_gvl_zoo_aset_acl inside rb_thread_blocking_region
457
367
  int zkrb_call_zoo_aset_acl(zhandle_t *zh, const char *path, int version, struct ACL_vector *acl, void_completion_t completion, const void *data) {
458
- int rc = ZKRB_FAIL;
459
- zkrb_zoo_aset_acl_args_t *ptr = malloc(sizeof(zkrb_zoo_aset_acl_args_t));
460
- check_mem(ptr);
461
-
462
- ptr->rc = rc;
463
- ptr->zh = zh;
464
- ptr->path = path;
465
- ptr->version = version;
466
- ptr->acl = acl;
467
- ptr->completion = completion;
468
- ptr->data = data;
368
+ zkrb_zoo_aset_acl_args_t args = {
369
+ .rc = ZKRB_FAIL,
370
+ .zh = zh,
371
+ .path = path,
372
+ .version = version,
373
+ .acl = acl,
374
+ .completion = completion,
375
+ .data = data
376
+ };
469
377
 
470
- zkrb_thread_blocking_region(zkrb_gvl_zoo_aset_acl, (void *)ptr);
378
+ zkrb_thread_blocking_region(zkrb_gvl_zoo_aset_acl, (void *)&args);
471
379
 
472
- rc = ptr->rc;
473
-
474
- error:
475
- free(ptr);
476
- return rc;
380
+ return args.rc;
477
381
  }
478
382
 
479
383
 
@@ -485,25 +389,19 @@ static VALUE zkrb_gvl_zoo_add_auth(void *data) {
485
389
 
486
390
  // wrapper that calls zoo_add_auth via zkrb_gvl_zoo_add_auth inside rb_thread_blocking_region
487
391
  int zkrb_call_zoo_add_auth(zhandle_t *zh, const char* scheme, const char* cert, int certLen, void_completion_t completion, const void *data) {
488
- int rc = ZKRB_FAIL;
489
- zkrb_zoo_add_auth_args_t *ptr = malloc(sizeof(zkrb_zoo_add_auth_args_t));
490
- check_mem(ptr);
491
-
492
- ptr->rc = rc;
493
- ptr->zh = zh;
494
- ptr->scheme = scheme;
495
- ptr->cert = cert;
496
- ptr->certLen = certLen;
497
- ptr->completion = completion;
498
- ptr->data = data;
392
+ zkrb_zoo_add_auth_args_t args = {
393
+ .rc = ZKRB_FAIL,
394
+ .zh = zh,
395
+ .scheme = scheme,
396
+ .cert = cert,
397
+ .certLen = certLen,
398
+ .completion = completion,
399
+ .data = data
400
+ };
499
401
 
500
- zkrb_thread_blocking_region(zkrb_gvl_zoo_add_auth, (void *)ptr);
402
+ zkrb_thread_blocking_region(zkrb_gvl_zoo_add_auth, (void *)&args);
501
403
 
502
- rc = ptr->rc;
503
-
504
- error:
505
- free(ptr);
506
- return rc;
404
+ return args.rc;
507
405
  }
508
406
 
509
407
 
@@ -515,27 +413,21 @@ static VALUE zkrb_gvl_zoo_create(void *data) {
515
413
 
516
414
  // wrapper that calls zoo_create via zkrb_gvl_zoo_create inside rb_thread_blocking_region
517
415
  int zkrb_call_zoo_create(zhandle_t *zh, const char *path, const char *value, int valuelen, const struct ACL_vector *acl, int flags, char *path_buffer, int path_buffer_len) {
518
- int rc = ZKRB_FAIL;
519
- zkrb_zoo_create_args_t *ptr = malloc(sizeof(zkrb_zoo_create_args_t));
520
- check_mem(ptr);
521
-
522
- ptr->rc = rc;
523
- ptr->zh = zh;
524
- ptr->path = path;
525
- ptr->value = value;
526
- ptr->valuelen = valuelen;
527
- ptr->acl = acl;
528
- ptr->flags = flags;
529
- ptr->path_buffer = path_buffer;
530
- ptr->path_buffer_len = path_buffer_len;
416
+ zkrb_zoo_create_args_t args = {
417
+ .rc = ZKRB_FAIL,
418
+ .zh = zh,
419
+ .path = path,
420
+ .value = value,
421
+ .valuelen = valuelen,
422
+ .acl = acl,
423
+ .flags = flags,
424
+ .path_buffer = path_buffer,
425
+ .path_buffer_len = path_buffer_len
426
+ };
531
427
 
532
- zkrb_thread_blocking_region(zkrb_gvl_zoo_create, (void *)ptr);
428
+ zkrb_thread_blocking_region(zkrb_gvl_zoo_create, (void *)&args);
533
429
 
534
- rc = ptr->rc;
535
-
536
- error:
537
- free(ptr);
538
- return rc;
430
+ return args.rc;
539
431
  }
540
432
 
541
433
 
@@ -547,22 +439,16 @@ static VALUE zkrb_gvl_zoo_delete(void *data) {
547
439
 
548
440
  // wrapper that calls zoo_delete via zkrb_gvl_zoo_delete inside rb_thread_blocking_region
549
441
  int zkrb_call_zoo_delete(zhandle_t *zh, const char *path, int version) {
550
- int rc = ZKRB_FAIL;
551
- zkrb_zoo_delete_args_t *ptr = malloc(sizeof(zkrb_zoo_delete_args_t));
552
- check_mem(ptr);
553
-
554
- ptr->rc = rc;
555
- ptr->zh = zh;
556
- ptr->path = path;
557
- ptr->version = version;
442
+ zkrb_zoo_delete_args_t args = {
443
+ .rc = ZKRB_FAIL,
444
+ .zh = zh,
445
+ .path = path,
446
+ .version = version
447
+ };
558
448
 
559
- zkrb_thread_blocking_region(zkrb_gvl_zoo_delete, (void *)ptr);
449
+ zkrb_thread_blocking_region(zkrb_gvl_zoo_delete, (void *)&args);
560
450
 
561
- rc = ptr->rc;
562
-
563
- error:
564
- free(ptr);
565
- return rc;
451
+ return args.rc;
566
452
  }
567
453
 
568
454
 
@@ -574,23 +460,17 @@ static VALUE zkrb_gvl_zoo_exists(void *data) {
574
460
 
575
461
  // wrapper that calls zoo_exists via zkrb_gvl_zoo_exists inside rb_thread_blocking_region
576
462
  int zkrb_call_zoo_exists(zhandle_t *zh, const char *path, int watch, struct Stat *stat) {
577
- int rc = ZKRB_FAIL;
578
- zkrb_zoo_exists_args_t *ptr = malloc(sizeof(zkrb_zoo_exists_args_t));
579
- check_mem(ptr);
580
-
581
- ptr->rc = rc;
582
- ptr->zh = zh;
583
- ptr->path = path;
584
- ptr->watch = watch;
585
- ptr->stat = stat;
463
+ zkrb_zoo_exists_args_t args = {
464
+ .rc = ZKRB_FAIL,
465
+ .zh = zh,
466
+ .path = path,
467
+ .watch = watch,
468
+ .stat = stat
469
+ };
586
470
 
587
- zkrb_thread_blocking_region(zkrb_gvl_zoo_exists, (void *)ptr);
471
+ zkrb_thread_blocking_region(zkrb_gvl_zoo_exists, (void *)&args);
588
472
 
589
- rc = ptr->rc;
590
-
591
- error:
592
- free(ptr);
593
- return rc;
473
+ return args.rc;
594
474
  }
595
475
 
596
476
 
@@ -602,24 +482,18 @@ static VALUE zkrb_gvl_zoo_wexists(void *data) {
602
482
 
603
483
  // wrapper that calls zoo_wexists via zkrb_gvl_zoo_wexists inside rb_thread_blocking_region
604
484
  int zkrb_call_zoo_wexists(zhandle_t *zh, const char *path, watcher_fn watcher, void* watcherCtx, struct Stat *stat) {
605
- int rc = ZKRB_FAIL;
606
- zkrb_zoo_wexists_args_t *ptr = malloc(sizeof(zkrb_zoo_wexists_args_t));
607
- check_mem(ptr);
608
-
609
- ptr->rc = rc;
610
- ptr->zh = zh;
611
- ptr->path = path;
612
- ptr->watcher = watcher;
613
- ptr->watcherCtx = watcherCtx;
614
- ptr->stat = stat;
485
+ zkrb_zoo_wexists_args_t args = {
486
+ .rc = ZKRB_FAIL,
487
+ .zh = zh,
488
+ .path = path,
489
+ .watcher = watcher,
490
+ .watcherCtx = watcherCtx,
491
+ .stat = stat
492
+ };
615
493
 
616
- zkrb_thread_blocking_region(zkrb_gvl_zoo_wexists, (void *)ptr);
494
+ zkrb_thread_blocking_region(zkrb_gvl_zoo_wexists, (void *)&args);
617
495
 
618
- rc = ptr->rc;
619
-
620
- error:
621
- free(ptr);
622
- return rc;
496
+ return args.rc;
623
497
  }
624
498
 
625
499
 
@@ -631,25 +505,19 @@ static VALUE zkrb_gvl_zoo_get(void *data) {
631
505
 
632
506
  // wrapper that calls zoo_get via zkrb_gvl_zoo_get inside rb_thread_blocking_region
633
507
  int zkrb_call_zoo_get(zhandle_t *zh, const char *path, int watch, char *buffer, int* buffer_len, struct Stat *stat) {
634
- int rc = ZKRB_FAIL;
635
- zkrb_zoo_get_args_t *ptr = malloc(sizeof(zkrb_zoo_get_args_t));
636
- check_mem(ptr);
637
-
638
- ptr->rc = rc;
639
- ptr->zh = zh;
640
- ptr->path = path;
641
- ptr->watch = watch;
642
- ptr->buffer = buffer;
643
- ptr->buffer_len = buffer_len;
644
- ptr->stat = stat;
508
+ zkrb_zoo_get_args_t args = {
509
+ .rc = ZKRB_FAIL,
510
+ .zh = zh,
511
+ .path = path,
512
+ .watch = watch,
513
+ .buffer = buffer,
514
+ .buffer_len = buffer_len,
515
+ .stat = stat
516
+ };
645
517
 
646
- zkrb_thread_blocking_region(zkrb_gvl_zoo_get, (void *)ptr);
518
+ zkrb_thread_blocking_region(zkrb_gvl_zoo_get, (void *)&args);
647
519
 
648
- rc = ptr->rc;
649
-
650
- error:
651
- free(ptr);
652
- return rc;
520
+ return args.rc;
653
521
  }
654
522
 
655
523
 
@@ -661,26 +529,20 @@ static VALUE zkrb_gvl_zoo_wget(void *data) {
661
529
 
662
530
  // wrapper that calls zoo_wget via zkrb_gvl_zoo_wget inside rb_thread_blocking_region
663
531
  int zkrb_call_zoo_wget(zhandle_t *zh, const char *path, watcher_fn watcher, void* watcherCtx, char *buffer, int* buffer_len, struct Stat *stat) {
664
- int rc = ZKRB_FAIL;
665
- zkrb_zoo_wget_args_t *ptr = malloc(sizeof(zkrb_zoo_wget_args_t));
666
- check_mem(ptr);
667
-
668
- ptr->rc = rc;
669
- ptr->zh = zh;
670
- ptr->path = path;
671
- ptr->watcher = watcher;
672
- ptr->watcherCtx = watcherCtx;
673
- ptr->buffer = buffer;
674
- ptr->buffer_len = buffer_len;
675
- ptr->stat = stat;
532
+ zkrb_zoo_wget_args_t args = {
533
+ .rc = ZKRB_FAIL,
534
+ .zh = zh,
535
+ .path = path,
536
+ .watcher = watcher,
537
+ .watcherCtx = watcherCtx,
538
+ .buffer = buffer,
539
+ .buffer_len = buffer_len,
540
+ .stat = stat
541
+ };
676
542
 
677
- zkrb_thread_blocking_region(zkrb_gvl_zoo_wget, (void *)ptr);
543
+ zkrb_thread_blocking_region(zkrb_gvl_zoo_wget, (void *)&args);
678
544
 
679
- rc = ptr->rc;
680
-
681
- error:
682
- free(ptr);
683
- return rc;
545
+ return args.rc;
684
546
  }
685
547
 
686
548
 
@@ -692,24 +554,18 @@ static VALUE zkrb_gvl_zoo_set(void *data) {
692
554
 
693
555
  // wrapper that calls zoo_set via zkrb_gvl_zoo_set inside rb_thread_blocking_region
694
556
  int zkrb_call_zoo_set(zhandle_t *zh, const char *path, const char *buffer, int buflen, int version) {
695
- int rc = ZKRB_FAIL;
696
- zkrb_zoo_set_args_t *ptr = malloc(sizeof(zkrb_zoo_set_args_t));
697
- check_mem(ptr);
698
-
699
- ptr->rc = rc;
700
- ptr->zh = zh;
701
- ptr->path = path;
702
- ptr->buffer = buffer;
703
- ptr->buflen = buflen;
704
- ptr->version = version;
557
+ zkrb_zoo_set_args_t args = {
558
+ .rc = ZKRB_FAIL,
559
+ .zh = zh,
560
+ .path = path,
561
+ .buffer = buffer,
562
+ .buflen = buflen,
563
+ .version = version
564
+ };
705
565
 
706
- zkrb_thread_blocking_region(zkrb_gvl_zoo_set, (void *)ptr);
566
+ zkrb_thread_blocking_region(zkrb_gvl_zoo_set, (void *)&args);
707
567
 
708
- rc = ptr->rc;
709
-
710
- error:
711
- free(ptr);
712
- return rc;
568
+ return args.rc;
713
569
  }
714
570
 
715
571
 
@@ -721,25 +577,19 @@ static VALUE zkrb_gvl_zoo_set2(void *data) {
721
577
 
722
578
  // wrapper that calls zoo_set2 via zkrb_gvl_zoo_set2 inside rb_thread_blocking_region
723
579
  int zkrb_call_zoo_set2(zhandle_t *zh, const char *path, const char *buffer, int buflen, int version, struct Stat *stat) {
724
- int rc = ZKRB_FAIL;
725
- zkrb_zoo_set2_args_t *ptr = malloc(sizeof(zkrb_zoo_set2_args_t));
726
- check_mem(ptr);
727
-
728
- ptr->rc = rc;
729
- ptr->zh = zh;
730
- ptr->path = path;
731
- ptr->buffer = buffer;
732
- ptr->buflen = buflen;
733
- ptr->version = version;
734
- ptr->stat = stat;
580
+ zkrb_zoo_set2_args_t args = {
581
+ .rc = ZKRB_FAIL,
582
+ .zh = zh,
583
+ .path = path,
584
+ .buffer = buffer,
585
+ .buflen = buflen,
586
+ .version = version,
587
+ .stat = stat
588
+ };
735
589
 
736
- zkrb_thread_blocking_region(zkrb_gvl_zoo_set2, (void *)ptr);
590
+ zkrb_thread_blocking_region(zkrb_gvl_zoo_set2, (void *)&args);
737
591
 
738
- rc = ptr->rc;
739
-
740
- error:
741
- free(ptr);
742
- return rc;
592
+ return args.rc;
743
593
  }
744
594
 
745
595
 
@@ -751,23 +601,17 @@ static VALUE zkrb_gvl_zoo_get_children(void *data) {
751
601
 
752
602
  // wrapper that calls zoo_get_children via zkrb_gvl_zoo_get_children inside rb_thread_blocking_region
753
603
  int zkrb_call_zoo_get_children(zhandle_t *zh, const char *path, int watch, struct String_vector *strings) {
754
- int rc = ZKRB_FAIL;
755
- zkrb_zoo_get_children_args_t *ptr = malloc(sizeof(zkrb_zoo_get_children_args_t));
756
- check_mem(ptr);
757
-
758
- ptr->rc = rc;
759
- ptr->zh = zh;
760
- ptr->path = path;
761
- ptr->watch = watch;
762
- ptr->strings = strings;
604
+ zkrb_zoo_get_children_args_t args = {
605
+ .rc = ZKRB_FAIL,
606
+ .zh = zh,
607
+ .path = path,
608
+ .watch = watch,
609
+ .strings = strings
610
+ };
763
611
 
764
- zkrb_thread_blocking_region(zkrb_gvl_zoo_get_children, (void *)ptr);
612
+ zkrb_thread_blocking_region(zkrb_gvl_zoo_get_children, (void *)&args);
765
613
 
766
- rc = ptr->rc;
767
-
768
- error:
769
- free(ptr);
770
- return rc;
614
+ return args.rc;
771
615
  }
772
616
 
773
617
 
@@ -779,24 +623,18 @@ static VALUE zkrb_gvl_zoo_wget_children(void *data) {
779
623
 
780
624
  // wrapper that calls zoo_wget_children via zkrb_gvl_zoo_wget_children inside rb_thread_blocking_region
781
625
  int zkrb_call_zoo_wget_children(zhandle_t *zh, const char *path, watcher_fn watcher, void* watcherCtx, struct String_vector *strings) {
782
- int rc = ZKRB_FAIL;
783
- zkrb_zoo_wget_children_args_t *ptr = malloc(sizeof(zkrb_zoo_wget_children_args_t));
784
- check_mem(ptr);
785
-
786
- ptr->rc = rc;
787
- ptr->zh = zh;
788
- ptr->path = path;
789
- ptr->watcher = watcher;
790
- ptr->watcherCtx = watcherCtx;
791
- ptr->strings = strings;
626
+ zkrb_zoo_wget_children_args_t args = {
627
+ .rc = ZKRB_FAIL,
628
+ .zh = zh,
629
+ .path = path,
630
+ .watcher = watcher,
631
+ .watcherCtx = watcherCtx,
632
+ .strings = strings
633
+ };
792
634
 
793
- zkrb_thread_blocking_region(zkrb_gvl_zoo_wget_children, (void *)ptr);
635
+ zkrb_thread_blocking_region(zkrb_gvl_zoo_wget_children, (void *)&args);
794
636
 
795
- rc = ptr->rc;
796
-
797
- error:
798
- free(ptr);
799
- return rc;
637
+ return args.rc;
800
638
  }
801
639
 
802
640
 
@@ -808,24 +646,18 @@ static VALUE zkrb_gvl_zoo_get_children2(void *data) {
808
646
 
809
647
  // wrapper that calls zoo_get_children2 via zkrb_gvl_zoo_get_children2 inside rb_thread_blocking_region
810
648
  int zkrb_call_zoo_get_children2(zhandle_t *zh, const char *path, int watch, struct String_vector *strings, struct Stat *stat) {
811
- int rc = ZKRB_FAIL;
812
- zkrb_zoo_get_children2_args_t *ptr = malloc(sizeof(zkrb_zoo_get_children2_args_t));
813
- check_mem(ptr);
814
-
815
- ptr->rc = rc;
816
- ptr->zh = zh;
817
- ptr->path = path;
818
- ptr->watch = watch;
819
- ptr->strings = strings;
820
- ptr->stat = stat;
649
+ zkrb_zoo_get_children2_args_t args = {
650
+ .rc = ZKRB_FAIL,
651
+ .zh = zh,
652
+ .path = path,
653
+ .watch = watch,
654
+ .strings = strings,
655
+ .stat = stat
656
+ };
821
657
 
822
- zkrb_thread_blocking_region(zkrb_gvl_zoo_get_children2, (void *)ptr);
658
+ zkrb_thread_blocking_region(zkrb_gvl_zoo_get_children2, (void *)&args);
823
659
 
824
- rc = ptr->rc;
825
-
826
- error:
827
- free(ptr);
828
- return rc;
660
+ return args.rc;
829
661
  }
830
662
 
831
663
 
@@ -837,25 +669,19 @@ static VALUE zkrb_gvl_zoo_wget_children2(void *data) {
837
669
 
838
670
  // wrapper that calls zoo_wget_children2 via zkrb_gvl_zoo_wget_children2 inside rb_thread_blocking_region
839
671
  int zkrb_call_zoo_wget_children2(zhandle_t *zh, const char *path, watcher_fn watcher, void* watcherCtx, struct String_vector *strings, struct Stat *stat) {
840
- int rc = ZKRB_FAIL;
841
- zkrb_zoo_wget_children2_args_t *ptr = malloc(sizeof(zkrb_zoo_wget_children2_args_t));
842
- check_mem(ptr);
843
-
844
- ptr->rc = rc;
845
- ptr->zh = zh;
846
- ptr->path = path;
847
- ptr->watcher = watcher;
848
- ptr->watcherCtx = watcherCtx;
849
- ptr->strings = strings;
850
- ptr->stat = stat;
672
+ zkrb_zoo_wget_children2_args_t args = {
673
+ .rc = ZKRB_FAIL,
674
+ .zh = zh,
675
+ .path = path,
676
+ .watcher = watcher,
677
+ .watcherCtx = watcherCtx,
678
+ .strings = strings,
679
+ .stat = stat
680
+ };
851
681
 
852
- zkrb_thread_blocking_region(zkrb_gvl_zoo_wget_children2, (void *)ptr);
682
+ zkrb_thread_blocking_region(zkrb_gvl_zoo_wget_children2, (void *)&args);
853
683
 
854
- rc = ptr->rc;
855
-
856
- error:
857
- free(ptr);
858
- return rc;
684
+ return args.rc;
859
685
  }
860
686
 
861
687
 
@@ -867,23 +693,17 @@ static VALUE zkrb_gvl_zoo_get_acl(void *data) {
867
693
 
868
694
  // wrapper that calls zoo_get_acl via zkrb_gvl_zoo_get_acl inside rb_thread_blocking_region
869
695
  int zkrb_call_zoo_get_acl(zhandle_t *zh, const char *path, struct ACL_vector *acl, struct Stat *stat) {
870
- int rc = ZKRB_FAIL;
871
- zkrb_zoo_get_acl_args_t *ptr = malloc(sizeof(zkrb_zoo_get_acl_args_t));
872
- check_mem(ptr);
873
-
874
- ptr->rc = rc;
875
- ptr->zh = zh;
876
- ptr->path = path;
877
- ptr->acl = acl;
878
- ptr->stat = stat;
696
+ zkrb_zoo_get_acl_args_t args = {
697
+ .rc = ZKRB_FAIL,
698
+ .zh = zh,
699
+ .path = path,
700
+ .acl = acl,
701
+ .stat = stat
702
+ };
879
703
 
880
- zkrb_thread_blocking_region(zkrb_gvl_zoo_get_acl, (void *)ptr);
704
+ zkrb_thread_blocking_region(zkrb_gvl_zoo_get_acl, (void *)&args);
881
705
 
882
- rc = ptr->rc;
883
-
884
- error:
885
- free(ptr);
886
- return rc;
706
+ return args.rc;
887
707
  }
888
708
 
889
709
 
@@ -895,23 +715,17 @@ static VALUE zkrb_gvl_zoo_set_acl(void *data) {
895
715
 
896
716
  // wrapper that calls zoo_set_acl via zkrb_gvl_zoo_set_acl inside rb_thread_blocking_region
897
717
  int zkrb_call_zoo_set_acl(zhandle_t *zh, const char *path, int version, const struct ACL_vector *acl) {
898
- int rc = ZKRB_FAIL;
899
- zkrb_zoo_set_acl_args_t *ptr = malloc(sizeof(zkrb_zoo_set_acl_args_t));
900
- check_mem(ptr);
901
-
902
- ptr->rc = rc;
903
- ptr->zh = zh;
904
- ptr->path = path;
905
- ptr->version = version;
906
- ptr->acl = acl;
907
-
908
- zkrb_thread_blocking_region(zkrb_gvl_zoo_set_acl, (void *)ptr);
718
+ zkrb_zoo_set_acl_args_t args = {
719
+ .rc = ZKRB_FAIL,
720
+ .zh = zh,
721
+ .path = path,
722
+ .version = version,
723
+ .acl = acl
724
+ };
909
725
 
910
- rc = ptr->rc;
726
+ zkrb_thread_blocking_region(zkrb_gvl_zoo_set_acl, (void *)&args);
911
727
 
912
- error:
913
- free(ptr);
914
- return rc;
728
+ return args.rc;
915
729
  }
916
730
 
917
731