Line data Source code
1 : #include "fd_instr_harness.h"
2 : #include "fd_solfuzz_private.h"
3 : #include "../fd_executor.h"
4 : #include "../fd_runtime.h"
5 : #include "../fd_system_ids.h"
6 : #include "../../log_collector/fd_log_collector.h"
7 : #include "../program/fd_bpf_loader_serialization.h"
8 : #include "../../../ballet/sbpf/fd_sbpf_loader.h"
9 : #include "../../vm/fd_vm.h"
10 : #include "../../vm/fd_vm_private.h"
11 : #include "generated/vm.pb.h"
12 : #include "generated/vm_serialization.pb.h"
13 : #include "../fd_bank.h"
14 :
15 : static fd_sbpf_syscalls_t *
16 : fd_solfuzz_vm_syscall_lookup_func( fd_sbpf_syscalls_t * syscalls,
17 : const char * syscall_name,
18 0 : size_t len) {
19 0 : ulong i;
20 :
21 0 : if (!syscall_name) return NULL;
22 :
23 0 : for (i = 0; i < fd_sbpf_syscalls_slot_cnt(); ++i) {
24 0 : if (!fd_sbpf_syscalls_key_inval(syscalls[i].key) && syscalls[i].name && strlen(syscalls[i].name) == len) {
25 0 : if (!memcmp(syscalls[i].name, syscall_name, len)) {
26 0 : return syscalls + i;
27 0 : }
28 0 : }
29 0 : }
30 :
31 0 : return NULL;
32 0 : }
33 :
34 : static ulong
35 : fd_solfuzz_vm_load_from_input_regions( fd_vm_input_region_t const * input,
36 : uint input_count,
37 : fd_exec_test_input_data_region_t ** output,
38 : pb_size_t * output_count,
39 : void * output_buf,
40 0 : ulong output_bufsz ) {
41 : /* Each region emits a fixed-size record holding a hash of its contents,
42 : so the output size depends on the region count, not their contents. */
43 0 : ulong output_sz = input_count * sizeof(fd_exec_test_input_data_region_t)
44 0 : + alignof(fd_exec_test_input_data_region_t);
45 :
46 0 : if( FD_UNLIKELY( !input_count || output_bufsz < output_sz ) ) {
47 0 : *output = NULL;
48 0 : *output_count = 0;
49 0 : return 0;
50 0 : }
51 :
52 0 : FD_SCRATCH_ALLOC_INIT( l, output_buf );
53 0 : *output = FD_SCRATCH_ALLOC_APPEND( l, alignof(fd_exec_test_input_data_region_t),
54 0 : input_count * sizeof (fd_exec_test_input_data_region_t) );
55 0 : FD_TEST( *output );
56 0 : *output_count = input_count;
57 :
58 0 : for( ulong i=0; i<input_count; i++ ) {
59 0 : fd_vm_input_region_t const * vm_region = &input[i];
60 0 : fd_exec_test_input_data_region_t * out_region = &(*output)[i];
61 0 : out_region->is_writable = vm_region->is_writable;
62 0 : out_region->offset = vm_region->vaddr_offset;
63 :
64 0 : out_region->content_hash = fd_solfuzz_hash( (void *)vm_region->haddr, vm_region->region_sz );
65 0 : }
66 :
67 0 : ulong end = FD_SCRATCH_ALLOC_FINI( l, 1UL );
68 0 : return end - (ulong)output_buf; /* return the number of bytes written */
69 0 : }
70 :
71 :
72 : ulong
73 : fd_solfuzz_pb_syscall_run( fd_solfuzz_runner_t * runner,
74 : void const * input_,
75 : void ** output_,
76 : void * output_buf,
77 0 : ulong output_bufsz ) {
78 0 : fd_exec_test_syscall_context_t const * input = fd_type_pun_const( input_ );
79 0 : fd_exec_test_syscall_effects_t ** output = fd_type_pun( output_ );
80 :
81 : /* Create execution context */
82 0 : const fd_exec_test_instr_context_t * input_instr_ctx = &input->instr_ctx;
83 0 : fd_exec_instr_ctx_t ctx[1];
84 0 : fd_solfuzz_pb_instr_ctx_create( runner, ctx, input_instr_ctx );
85 :
86 0 : ctx->txn_out->err.exec_err = 0;
87 0 : ctx->txn_out->err.exec_err_kind = FD_EXECUTOR_ERR_KIND_NONE;
88 0 : ctx->bank = runner->bank;
89 :
90 : /* Capture outputs */
91 0 : ulong output_end = (ulong)output_buf + output_bufsz;
92 0 : FD_SCRATCH_ALLOC_INIT( l, output_buf );
93 0 : fd_exec_test_syscall_effects_t * effects =
94 0 : FD_SCRATCH_ALLOC_APPEND( l, alignof(fd_exec_test_syscall_effects_t),
95 0 : sizeof (fd_exec_test_syscall_effects_t) );
96 0 : if( FD_UNLIKELY( _l > output_end ) ) {
97 0 : goto error;
98 0 : }
99 :
100 0 : if( input->vm_ctx.return_data.program_id && input->vm_ctx.return_data.program_id->size == sizeof(fd_pubkey_t) ) {
101 0 : fd_memcpy( ctx->txn_out->details.return_data.program_id.uc, input->vm_ctx.return_data.program_id->bytes, sizeof(fd_pubkey_t) );
102 0 : }
103 :
104 0 : if( input->vm_ctx.return_data.data && input->vm_ctx.return_data.data->size>0U ) {
105 0 : if( FD_UNLIKELY( input->vm_ctx.return_data.data->size>sizeof(ctx->txn_out->details.return_data.data) ) ) goto error;
106 0 : ctx->txn_out->details.return_data.len = input->vm_ctx.return_data.data->size;
107 0 : fd_memcpy( ctx->txn_out->details.return_data.data, input->vm_ctx.return_data.data->bytes, ctx->txn_out->details.return_data.len );
108 0 : }
109 :
110 0 : *effects = (fd_exec_test_syscall_effects_t) FD_EXEC_TEST_SYSCALL_EFFECTS_INIT_ZERO;
111 :
112 : /* Set up the VM instance */
113 0 : fd_spad_t * spad = runner->spad;
114 0 : fd_sha256_t _sha[1];
115 0 : fd_sha256_t * sha = fd_sha256_join( fd_sha256_new( _sha ) );
116 0 : fd_sbpf_syscalls_t * syscalls = fd_sbpf_syscalls_new( fd_spad_alloc_check( spad, fd_sbpf_syscalls_align(), fd_sbpf_syscalls_footprint() ) );
117 0 : fd_vm_syscall_register_all( syscalls, 0 );
118 :
119 : /* Pull out the memory regions */
120 0 : if( !input->has_vm_ctx ) {
121 0 : goto error;
122 0 : }
123 :
124 0 : ulong rodata_sz = input->vm_ctx.rodata ? input->vm_ctx.rodata->size : 0UL;
125 0 : uchar * rodata = fd_spad_alloc_check( spad, 8UL, rodata_sz );
126 0 : if ( input->vm_ctx.rodata != NULL ) {
127 0 : fd_memcpy( rodata, input->vm_ctx.rodata->bytes, rodata_sz );
128 0 : }
129 :
130 0 : if( input->vm_ctx.heap_max > FD_VM_HEAP_MAX ) {
131 0 : goto error;
132 0 : }
133 :
134 0 : FD_TEST( input->vm_ctx.sbpf_version<=FD_SBPF_V3 );
135 :
136 0 : fd_vm_t * vm = fd_vm_join( fd_vm_new( fd_spad_alloc_check( spad, fd_vm_align(), fd_vm_footprint() ) ) );
137 0 : if ( !vm ) {
138 0 : goto error;
139 0 : }
140 :
141 : /* If the program ID account owner is the v1 BPF loader, then alignment is disabled (controlled by
142 : the `is_deprecated` flag) */
143 :
144 0 : ulong input_sz = 0UL;
145 0 : ulong pre_lens[256] = {0};
146 0 : fd_vm_input_region_t input_mem_regions[1000] = {0}; /* We can have a max of (3 * num accounts + 1) regions */
147 0 : fd_vm_acc_region_meta_t acc_region_metas[256] = {0}; /* instr acc idx to idx */
148 0 : uint input_mem_regions_cnt = 0U;
149 0 : int direct_mapping = FD_FEATURE_ACTIVE_BANK( ctx->bank, account_data_direct_mapping );
150 0 : int syscall_parameter_address_restrictions = FD_FEATURE_ACTIVE_BANK( ctx->bank, syscall_parameter_address_restrictions );
151 0 : int virtual_address_space_adjustments = FD_FEATURE_ACTIVE_BANK( ctx->bank, virtual_address_space_adjustments );
152 0 : int direct_account_pointers_in_program_input = FD_FEATURE_ACTIVE_BANK( ctx->bank, direct_account_pointers_in_program_input );
153 :
154 0 : uchar program_id_idx = ctx->instr->program_id;
155 0 : fd_acc_t * program_acc = ctx->txn_out->accounts.account[program_id_idx];
156 0 : uchar is_deprecated = ( program_id_idx < ctx->txn_out->accounts.cnt ) &&
157 0 : ( !memcmp( program_acc->owner, fd_solana_bpf_loader_deprecated_program_id.key, sizeof(fd_pubkey_t) ) );
158 :
159 : /* Push the instruction onto the stack. This may also modify the sysvar instructions account, if its present. */
160 0 : int stack_push_err = fd_instr_stack_push( ctx->runtime, ctx->txn_in, ctx->txn_out, (fd_instr_info_t *)ctx->instr );
161 0 : if( FD_UNLIKELY( stack_push_err ) ) {
162 0 : FD_LOG_WARNING(( "instr stack push err" ));
163 0 : goto error;
164 0 : }
165 :
166 0 : ulong instr_data_offset = 0UL;
167 0 : int err = fd_bpf_loader_input_serialize_parameters( ctx,
168 0 : pre_lens,
169 0 : input_mem_regions,
170 0 : &input_mem_regions_cnt,
171 0 : acc_region_metas,
172 0 : virtual_address_space_adjustments,
173 0 : direct_mapping,
174 0 : direct_account_pointers_in_program_input,
175 0 : is_deprecated,
176 0 : &instr_data_offset,
177 0 : &input_sz );
178 0 : if( FD_UNLIKELY( err ) ) {
179 0 : FD_LOG_WARNING(( "bpf loader input serialize parameters err" ));
180 0 : goto error;
181 0 : }
182 :
183 0 : fd_vm_init( vm,
184 0 : ctx,
185 0 : input->vm_ctx.heap_max,
186 0 : ctx->txn_out->details.compute_budget.compute_meter,
187 0 : rodata,
188 0 : rodata_sz,
189 0 : NULL, // TODO
190 0 : 0, // TODO
191 0 : 0, // TODO
192 0 : 0, // TODO, text_sz
193 0 : 0, // TODO
194 0 : NULL, // TODO
195 0 : input->vm_ctx.sbpf_version,
196 0 : syscalls,
197 0 : NULL, // TODO
198 0 : sha,
199 0 : input_mem_regions,
200 0 : input_mem_regions_cnt,
201 0 : acc_region_metas,
202 0 : is_deprecated,
203 0 : direct_mapping,
204 0 : syscall_parameter_address_restrictions,
205 0 : virtual_address_space_adjustments,
206 0 : 0 /* dump_syscall_to_pb */,
207 0 : 0UL /* r2 is set by the fuzzer below */ );
208 :
209 : // Override some execution state values from the syscall fuzzer input
210 : // This is so we can test if the syscall mutates any of these erroneously
211 0 : vm->reg[0] = input->vm_ctx.r0;
212 0 : vm->reg[1] = input->vm_ctx.r1;
213 0 : vm->reg[2] = input->vm_ctx.r2;
214 0 : vm->reg[3] = input->vm_ctx.r3;
215 0 : vm->reg[4] = input->vm_ctx.r4;
216 0 : vm->reg[5] = input->vm_ctx.r5;
217 0 : vm->reg[6] = input->vm_ctx.r6;
218 0 : vm->reg[7] = input->vm_ctx.r7;
219 0 : vm->reg[8] = input->vm_ctx.r8;
220 0 : vm->reg[9] = input->vm_ctx.r9;
221 0 : vm->reg[10] = input->vm_ctx.r10;
222 0 : vm->reg[11] = input->vm_ctx.r11;
223 :
224 0 : fd_vm_mem_init_full( vm );
225 :
226 : // Override initial part of the heap, if specified the syscall fuzzer input
227 0 : if( input->syscall_invocation.heap_prefix ) {
228 0 : fd_memcpy( vm->heap, input->syscall_invocation.heap_prefix->bytes,
229 0 : fd_ulong_min( input->syscall_invocation.heap_prefix->size, vm->heap_max ) );
230 0 : }
231 :
232 : // Override initial part of the stack, if specified the syscall fuzzer input
233 0 : if( input->syscall_invocation.stack_prefix ) {
234 0 : fd_memcpy( vm->stack, input->syscall_invocation.stack_prefix->bytes,
235 0 : fd_ulong_min( input->syscall_invocation.stack_prefix->size, FD_VM_STACK_MAX ) );
236 0 : }
237 :
238 : // Look up the syscall to execute
239 0 : char * syscall_name = (char *)input->syscall_invocation.function_name.bytes;
240 0 : fd_sbpf_syscalls_t const * syscall = fd_solfuzz_vm_syscall_lookup_func(syscalls, syscall_name, input->syscall_invocation.function_name.size);
241 0 : if( !syscall ) {
242 0 : goto error;
243 0 : }
244 :
245 : /* There's an instr ctx struct embedded in the txn ctx instr stack. */
246 0 : fd_exec_instr_ctx_t * instr_ctx = &ctx->runtime->instr.stack[ ctx->runtime->instr.stack_sz - 1 ];
247 0 : *instr_ctx = (fd_exec_instr_ctx_t) {
248 0 : .instr = ctx->instr,
249 0 : .txn_out = ctx->txn_out,
250 0 : .runtime = ctx->runtime,
251 0 : };
252 :
253 : /* Actually invoke the syscall */
254 0 : int syscall_err = syscall->func( vm, vm->reg[1], vm->reg[2], vm->reg[3], vm->reg[4], vm->reg[5] );
255 0 : int instr_end_err = fd_execute_instr_end( vm->instr_ctx, ctx->instr, syscall_err );
256 0 : if( instr_end_err ) {
257 0 : fd_log_collector_program_failure( vm->instr_ctx );
258 0 : }
259 :
260 : /* Capture the effects */
261 0 : int exec_err = vm->instr_ctx->txn_out->err.exec_err;
262 0 : effects->error = 0;
263 0 : if( instr_end_err ) {
264 0 : if( exec_err==0 ) {
265 0 : FD_LOG_WARNING(( "TODO: syscall returns error, but exec_err not set. this is probably missing a log." ));
266 0 : effects->error = -1;
267 0 : } else {
268 0 : effects->error = (exec_err <= 0) ? -exec_err : -1;
269 :
270 : /* Map error kind, equivalent to:
271 : effects->error_kind = (fd_exec_test_err_kind_t)(vm->instr_ctx->txn_ctx->err.exec_err_kind); */
272 0 : switch (vm->instr_ctx->txn_out->err.exec_err_kind) {
273 0 : case FD_EXECUTOR_ERR_KIND_EBPF:
274 0 : effects->error_kind = FD_EXEC_TEST_ERR_KIND_EBPF;
275 0 : break;
276 0 : case FD_EXECUTOR_ERR_KIND_SYSCALL:
277 0 : effects->error_kind = FD_EXEC_TEST_ERR_KIND_SYSCALL;
278 0 : break;
279 0 : case FD_EXECUTOR_ERR_KIND_INSTR:
280 0 : effects->error_kind = FD_EXEC_TEST_ERR_KIND_INSTRUCTION;
281 0 : break;
282 0 : default:
283 0 : effects->error_kind = FD_EXEC_TEST_ERR_KIND_UNSPECIFIED;
284 0 : break;
285 0 : }
286 0 : }
287 0 : }
288 0 : effects->r0 = instr_end_err ? 0 : vm->reg[0]; // Save only on success
289 0 : effects->cu_avail = (ulong)vm->cu;
290 :
291 0 : effects->heap_hash = fd_solfuzz_hash( vm->heap, vm->heap_max );
292 0 : effects->stack_hash = fd_solfuzz_hash( vm->stack, FD_VM_STACK_MAX );
293 0 : effects->rodata_hash = fd_solfuzz_hash( vm->rodata, vm->rodata_sz ? rodata_sz : 0UL );
294 :
295 0 : effects->frame_count = vm->frame_cnt;
296 :
297 : /* Capture input regions */
298 0 : ulong tmp_end = FD_SCRATCH_ALLOC_FINI( l, 1UL );
299 :
300 : /* Don't compare input data regions if execution failed and
301 : virtual_address_space_adjustments is enabled, because
302 : Agave leaks data into the input regions under these circumstances. */
303 0 : ulong input_regions_size = 0UL;
304 0 : if( syscall_err && virtual_address_space_adjustments ) {
305 0 : effects->input_data_regions = NULL;
306 0 : effects->input_data_regions_count = 0UL;
307 0 : } else {
308 0 : input_regions_size = fd_solfuzz_vm_load_from_input_regions(
309 0 : vm->input_mem_regions,
310 0 : vm->input_mem_regions_cnt,
311 0 : &effects->input_data_regions,
312 0 : &effects->input_data_regions_count,
313 0 : (void *)tmp_end,
314 0 : fd_ulong_sat_sub( output_end, tmp_end )
315 0 : );
316 :
317 0 : if( !!vm->input_mem_regions_cnt && !effects->input_data_regions ) {
318 0 : goto error;
319 0 : }
320 0 : }
321 :
322 : /* Return the effects */
323 0 : ulong actual_end = tmp_end + input_regions_size;
324 0 : fd_solfuzz_pb_instr_ctx_destroy( runner, ctx );
325 :
326 0 : *output = effects;
327 0 : return actual_end - (ulong)output_buf;
328 :
329 0 : error:
330 0 : fd_solfuzz_pb_instr_ctx_destroy( runner, ctx );
331 0 : return 0;
332 0 : }
333 :
334 : ulong
335 : fd_solfuzz_pb_vm_serialize_run( fd_solfuzz_runner_t * runner,
336 : void const * input_,
337 : void ** output_,
338 : void * output_buf,
339 0 : ulong output_bufsz ) {
340 0 : fd_exec_test_instr_context_t const * input = fd_type_pun_const( input_ );
341 0 : fd_exec_test_vm_serialization_effects_t ** output = fd_type_pun( output_ );
342 :
343 : /* Create execution context */
344 0 : fd_exec_instr_ctx_t ctx[1];
345 0 : fd_solfuzz_pb_instr_ctx_create( runner, ctx, input );
346 :
347 0 : ctx->txn_out->err.exec_err = 0;
348 0 : ctx->txn_out->err.exec_err_kind = FD_EXECUTOR_ERR_KIND_NONE;
349 0 : ctx->bank = runner->bank;
350 :
351 : /* Capture outputs */
352 0 : ulong output_end = (ulong)output_buf + output_bufsz;
353 0 : FD_SCRATCH_ALLOC_INIT( l, output_buf );
354 0 : fd_exec_test_vm_serialization_effects_t * effects =
355 0 : FD_SCRATCH_ALLOC_APPEND( l, alignof(fd_exec_test_vm_serialization_effects_t),
356 0 : sizeof (fd_exec_test_vm_serialization_effects_t) );
357 0 : FD_TEST( _l <= output_end );
358 0 : *effects = (fd_exec_test_vm_serialization_effects_t) FD_EXEC_TEST_VM_SERIALIZATION_EFFECTS_INIT_ZERO;
359 :
360 : /* Determine feature flags and is_deprecated */
361 0 : int direct_mapping = FD_FEATURE_ACTIVE_BANK( ctx->bank, account_data_direct_mapping );
362 0 : int virtual_address_space_adjustments = FD_FEATURE_ACTIVE_BANK( ctx->bank, virtual_address_space_adjustments );
363 0 : int direct_account_pointers_in_program_input = FD_FEATURE_ACTIVE_BANK( ctx->bank, direct_account_pointers_in_program_input );
364 :
365 0 : uchar program_id_idx = ctx->instr->program_id;
366 0 : fd_acc_t * program_acc = ctx->txn_out->accounts.account[program_id_idx];
367 0 : uchar is_deprecated = ( program_id_idx < ctx->txn_out->accounts.cnt ) &&
368 0 : ( !memcmp( program_acc->owner, fd_solana_bpf_loader_deprecated_program_id.key, sizeof(fd_pubkey_t) ) );
369 :
370 : /* Push the instruction onto the stack */
371 0 : FD_TEST( !fd_instr_stack_push( ctx->runtime, ctx->txn_in, ctx->txn_out, (fd_instr_info_t *)ctx->instr ) );
372 :
373 : /* Call serialize_parameters */
374 0 : ulong input_sz = 0UL;
375 0 : ulong pre_lens[256] = {0};
376 0 : fd_vm_input_region_t input_mem_regions[1000] = {0};
377 0 : fd_vm_acc_region_meta_t acc_region_metas[256] = {0};
378 0 : uint input_mem_regions_cnt = 0U;
379 0 : ulong instr_data_offset = 0UL;
380 :
381 0 : int err = fd_bpf_loader_input_serialize_parameters(
382 0 : ctx,
383 0 : pre_lens,
384 0 : input_mem_regions,
385 0 : &input_mem_regions_cnt,
386 0 : acc_region_metas,
387 0 : virtual_address_space_adjustments,
388 0 : direct_mapping,
389 0 : direct_account_pointers_in_program_input,
390 0 : is_deprecated,
391 0 : &instr_data_offset,
392 0 : &input_sz
393 0 : );
394 :
395 0 : if( FD_UNLIKELY( err ) ) {
396 0 : effects->has_error = true;
397 0 : ulong actual_end = FD_SCRATCH_ALLOC_FINI( l, 1UL );
398 0 : fd_solfuzz_pb_instr_ctx_destroy( runner, ctx );
399 0 : *output = effects;
400 0 : return actual_end - (ulong)output_buf;
401 0 : }
402 :
403 : /* Hash the serialized memory buffer. */
404 0 : uchar * serialized_buf = ctx->runtime->bpf_loader_serialization.serialization_mem[ ctx->runtime->instr.stack_sz-1UL ];
405 0 : effects->serialized_memory_hash = fd_hash( 0UL, serialized_buf, input_sz );
406 :
407 : /* Populate vm_input_memory_regions */
408 0 : effects->vm_input_memory_regions_count = (pb_size_t)input_mem_regions_cnt;
409 0 : effects->vm_input_memory_regions =
410 0 : FD_SCRATCH_ALLOC_APPEND( l, alignof(fd_exec_test_vm_input_memory_region_t),
411 0 : input_mem_regions_cnt * sizeof(fd_exec_test_vm_input_memory_region_t) );
412 0 : FD_TEST( _l <= output_end );
413 :
414 0 : for( uint i=0; i<input_mem_regions_cnt; i++ ) {
415 0 : fd_vm_input_region_t const * region = &input_mem_regions[i];
416 0 : fd_exec_test_vm_input_memory_region_t * out = &effects->vm_input_memory_regions[i];
417 0 : out->vm_address = FD_VM_MEM_MAP_INPUT_REGION_START + region->vaddr_offset;
418 0 : out->region_size = region->region_sz;
419 0 : out->is_writable = region->is_writable;
420 0 : }
421 :
422 : /* Populate serialized_account_metadata */
423 0 : ulong num_ix_accounts = ctx->instr->acct_cnt;
424 0 : effects->serialized_account_metadata_count = (pb_size_t)num_ix_accounts;
425 0 : effects->serialized_account_metadata =
426 0 : FD_SCRATCH_ALLOC_APPEND( l, alignof(fd_exec_test_vm_serialized_account_metadata_t),
427 0 : num_ix_accounts * sizeof(fd_exec_test_vm_serialized_account_metadata_t) );
428 0 : FD_TEST( _l <= output_end );
429 :
430 0 : for( ulong i=0; i<num_ix_accounts; i++ ) {
431 0 : fd_vm_acc_region_meta_t const * meta = &acc_region_metas[i];
432 0 : fd_exec_test_vm_serialized_account_metadata_t * out = &effects->serialized_account_metadata[i];
433 0 : out->original_data_len = meta->original_data_len;
434 0 : out->vm_data_addr = meta->vm_data_addr;
435 0 : out->vm_key_addr = meta->vm_key_addr;
436 0 : out->vm_lamports_addr = meta->vm_lamports_addr;
437 0 : out->vm_owner_addr = meta->vm_owner_addr;
438 0 : }
439 :
440 0 : ulong actual_end = FD_SCRATCH_ALLOC_FINI( l, 1UL );
441 0 : fd_solfuzz_pb_instr_ctx_destroy( runner, ctx );
442 :
443 0 : *output = effects;
444 0 : return actual_end - (ulong)output_buf;
445 0 : }
|
