1 /*
2 * deprecated.c: holding file for all deprecated APIs.
3 * "we can't lose 'em, but we can shun 'em!"
4 *
5 * ====================================================================
6 * Licensed to the Apache Software Foundation (ASF) under one
7 * or more contributor license agreements. See the NOTICE file
8 * distributed with this work for additional information
9 * regarding copyright ownership. The ASF licenses this file
10 * to you under the Apache License, Version 2.0 (the
11 * "License"); you may not use this file except in compliance
12 * with the License. You may obtain a copy of the License at
13 *
14 * http://www.apache.org/licenses/LICENSE-2.0
15 *
16 * Unless required by applicable law or agreed to in writing,
17 * software distributed under the License is distributed on an
18 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
19 * KIND, either express or implied. See the License for the
20 * specific language governing permissions and limitations
21 * under the License.
22 * ====================================================================
23 */
24
25 /* We define this here to remove any further warnings about the usage of
26 deprecated functions in this file. */
27 #define SVN_DEPRECATED
28
29 #include "svn_hash.h"
30 #include "svn_ra.h"
31 #include "svn_path.h"
32 #include "svn_compat.h"
33 #include "svn_props.h"
34 #include "svn_pools.h"
35
36 #include "ra_loader.h"
37 #include "deprecated.h"
38
39 #include "svn_private_config.h"
40
41
42
43
44 /*** From ra_loader.c ***/
45 /*** Compatibility Wrappers ***/
46
47 /* Wrap @c svn_ra_reporter3_t in an interface that looks like
48 @c svn_ra_reporter2_t, for compatibility with functions that take
49 the latter. This shields the ra-specific implementations from
50 worrying about what kind of reporter they're dealing with.
51
52 This code does not live in wrapper_template.h because that file is
53 about the big changeover from a vtable-style to function-style
54 interface, and does not contain the post-changeover interfaces
55 that we are compatiblizing here.
56
57 This code looks like it duplicates code in libsvn_wc/adm_crawler.c,
58 but in fact it does not. That code makes old things look like new
59 things; this code makes a new thing look like an old thing. */
60
61 /* Baton for abovementioned wrapping. */
62 struct reporter_3in2_baton {
63 const svn_ra_reporter3_t *reporter3;
64 void *reporter3_baton;
65 };
66
67 /* Wrap the corresponding svn_ra_reporter3_t field in an
68 svn_ra_reporter2_t interface. @a report_baton is a
69 @c reporter_3in2_baton_t *. */
70 static svn_error_t *
set_path(void * report_baton,const char * path,svn_revnum_t revision,svn_boolean_t start_empty,const char * lock_token,apr_pool_t * pool)71 set_path(void *report_baton,
72 const char *path,
73 svn_revnum_t revision,
74 svn_boolean_t start_empty,
75 const char *lock_token,
76 apr_pool_t *pool)
77 {
78 struct reporter_3in2_baton *b = report_baton;
79 return b->reporter3->set_path(b->reporter3_baton,
80 path, revision, svn_depth_infinity,
81 start_empty, lock_token, pool);
82 }
83
84 /* Wrap the corresponding svn_ra_reporter3_t field in an
85 svn_ra_reporter2_t interface. @a report_baton is a
86 @c reporter_3in2_baton_t *. */
87 static svn_error_t *
delete_path(void * report_baton,const char * path,apr_pool_t * pool)88 delete_path(void *report_baton,
89 const char *path,
90 apr_pool_t *pool)
91 {
92 struct reporter_3in2_baton *b = report_baton;
93 return b->reporter3->delete_path(b->reporter3_baton, path, pool);
94 }
95
96 /* Wrap the corresponding svn_ra_reporter3_t field in an
97 svn_ra_reporter2_t interface. @a report_baton is a
98 @c reporter_3in2_baton_t *. */
99 static svn_error_t *
link_path(void * report_baton,const char * path,const char * url,svn_revnum_t revision,svn_boolean_t start_empty,const char * lock_token,apr_pool_t * pool)100 link_path(void *report_baton,
101 const char *path,
102 const char *url,
103 svn_revnum_t revision,
104 svn_boolean_t start_empty,
105 const char *lock_token,
106 apr_pool_t *pool)
107 {
108 struct reporter_3in2_baton *b = report_baton;
109 return b->reporter3->link_path(b->reporter3_baton,
110 path, url, revision, svn_depth_infinity,
111 start_empty, lock_token, pool);
112
113 }
114
115 /* Wrap the corresponding svn_ra_reporter3_t field in an
116 svn_ra_reporter2_t interface. @a report_baton is a
117 @c reporter_3in2_baton_t *. */
118 static svn_error_t *
finish_report(void * report_baton,apr_pool_t * pool)119 finish_report(void *report_baton,
120 apr_pool_t *pool)
121 {
122 struct reporter_3in2_baton *b = report_baton;
123 return b->reporter3->finish_report(b->reporter3_baton, pool);
124 }
125
126 /* Wrap the corresponding svn_ra_reporter3_t field in an
127 svn_ra_reporter2_t interface. @a report_baton is a
128 @c reporter_3in2_baton_t *. */
129 static svn_error_t *
abort_report(void * report_baton,apr_pool_t * pool)130 abort_report(void *report_baton,
131 apr_pool_t *pool)
132 {
133 struct reporter_3in2_baton *b = report_baton;
134 return b->reporter3->abort_report(b->reporter3_baton, pool);
135 }
136
137 /* Wrap svn_ra_reporter3_t calls in an svn_ra_reporter2_t interface.
138
139 Note: For calls where the prototypes are exactly the same, we could
140 avoid the pass-through overhead by using the function in the
141 reporter returned from session->vtable->do_foo. But the code would
142 get a lot less readable, and the only benefit would be to shave a
143 few instructions in a network-bound operation anyway. So in
144 delete_path(), finish_report(), and abort_report(), we cheerfully
145 pass through to identical functions. */
146 static svn_ra_reporter2_t reporter_3in2_wrapper = {
147 set_path,
148 delete_path,
149 link_path,
150 finish_report,
151 abort_report
152 };
153
svn_ra_open4(svn_ra_session_t ** session_p,const char ** corrected_url_p,const char * repos_URL,const char * uuid,const svn_ra_callbacks2_t * callbacks,void * callback_baton,apr_hash_t * config,apr_pool_t * pool)154 svn_error_t *svn_ra_open4(svn_ra_session_t **session_p,
155 const char **corrected_url_p,
156 const char *repos_URL,
157 const char *uuid,
158 const svn_ra_callbacks2_t *callbacks,
159 void *callback_baton,
160 apr_hash_t *config,
161 apr_pool_t *pool)
162 {
163 return svn_ra_open5(session_p, corrected_url_p, NULL, repos_URL, uuid,
164 callbacks, callback_baton, config, pool);
165 }
166
svn_ra_open3(svn_ra_session_t ** session_p,const char * repos_URL,const char * uuid,const svn_ra_callbacks2_t * callbacks,void * callback_baton,apr_hash_t * config,apr_pool_t * pool)167 svn_error_t *svn_ra_open3(svn_ra_session_t **session_p,
168 const char *repos_URL,
169 const char *uuid,
170 const svn_ra_callbacks2_t *callbacks,
171 void *callback_baton,
172 apr_hash_t *config,
173 apr_pool_t *pool)
174 {
175 return svn_ra_open4(session_p, NULL, repos_URL, uuid,
176 callbacks, callback_baton, config, pool);
177 }
178
svn_ra_open2(svn_ra_session_t ** session_p,const char * repos_URL,const svn_ra_callbacks2_t * callbacks,void * callback_baton,apr_hash_t * config,apr_pool_t * pool)179 svn_error_t *svn_ra_open2(svn_ra_session_t **session_p,
180 const char *repos_URL,
181 const svn_ra_callbacks2_t *callbacks,
182 void *callback_baton,
183 apr_hash_t *config,
184 apr_pool_t *pool)
185 {
186 return svn_ra_open3(session_p, repos_URL, NULL,
187 callbacks, callback_baton, config, pool);
188 }
189
svn_ra_open(svn_ra_session_t ** session_p,const char * repos_URL,const svn_ra_callbacks_t * callbacks,void * callback_baton,apr_hash_t * config,apr_pool_t * pool)190 svn_error_t *svn_ra_open(svn_ra_session_t **session_p,
191 const char *repos_URL,
192 const svn_ra_callbacks_t *callbacks,
193 void *callback_baton,
194 apr_hash_t *config,
195 apr_pool_t *pool)
196 {
197 /* Deprecated function. Copy the contents of the svn_ra_callbacks_t
198 to a new svn_ra_callbacks2_t and call svn_ra_open2(). */
199 svn_ra_callbacks2_t *callbacks2;
200 SVN_ERR(svn_ra_create_callbacks(&callbacks2, pool));
201 callbacks2->open_tmp_file = callbacks->open_tmp_file;
202 callbacks2->auth_baton = callbacks->auth_baton;
203 callbacks2->get_wc_prop = callbacks->get_wc_prop;
204 callbacks2->set_wc_prop = callbacks->set_wc_prop;
205 callbacks2->push_wc_prop = callbacks->push_wc_prop;
206 callbacks2->invalidate_wc_props = callbacks->invalidate_wc_props;
207 callbacks2->progress_func = NULL;
208 callbacks2->progress_baton = NULL;
209 return svn_ra_open2(session_p, repos_URL,
210 callbacks2, callback_baton,
211 config, pool);
212 }
213
svn_ra_change_rev_prop(svn_ra_session_t * session,svn_revnum_t rev,const char * name,const svn_string_t * value,apr_pool_t * pool)214 svn_error_t *svn_ra_change_rev_prop(svn_ra_session_t *session,
215 svn_revnum_t rev,
216 const char *name,
217 const svn_string_t *value,
218 apr_pool_t *pool)
219 {
220 return svn_ra_change_rev_prop2(session, rev, name, NULL, value, pool);
221 }
222
svn_ra_get_commit_editor2(svn_ra_session_t * session,const svn_delta_editor_t ** editor,void ** edit_baton,const char * log_msg,svn_commit_callback2_t commit_callback,void * commit_baton,apr_hash_t * lock_tokens,svn_boolean_t keep_locks,apr_pool_t * pool)223 svn_error_t *svn_ra_get_commit_editor2(svn_ra_session_t *session,
224 const svn_delta_editor_t **editor,
225 void **edit_baton,
226 const char *log_msg,
227 svn_commit_callback2_t commit_callback,
228 void *commit_baton,
229 apr_hash_t *lock_tokens,
230 svn_boolean_t keep_locks,
231 apr_pool_t *pool)
232 {
233 apr_hash_t *revprop_table = apr_hash_make(pool);
234 if (log_msg)
235 svn_hash_sets(revprop_table, SVN_PROP_REVISION_LOG,
236 svn_string_create(log_msg, pool));
237 return svn_ra_get_commit_editor3(session, editor, edit_baton, revprop_table,
238 commit_callback, commit_baton,
239 lock_tokens, keep_locks, pool);
240 }
241
svn_ra_get_commit_editor(svn_ra_session_t * session,const svn_delta_editor_t ** editor,void ** edit_baton,const char * log_msg,svn_commit_callback_t callback,void * callback_baton,apr_hash_t * lock_tokens,svn_boolean_t keep_locks,apr_pool_t * pool)242 svn_error_t *svn_ra_get_commit_editor(svn_ra_session_t *session,
243 const svn_delta_editor_t **editor,
244 void **edit_baton,
245 const char *log_msg,
246 svn_commit_callback_t callback,
247 void *callback_baton,
248 apr_hash_t *lock_tokens,
249 svn_boolean_t keep_locks,
250 apr_pool_t *pool)
251 {
252 svn_commit_callback2_t callback2;
253 void *callback2_baton;
254
255 svn_compat_wrap_commit_callback(&callback2, &callback2_baton,
256 callback, callback_baton,
257 pool);
258
259 return svn_ra_get_commit_editor2(session, editor, edit_baton,
260 log_msg, callback2,
261 callback2_baton, lock_tokens,
262 keep_locks, pool);
263 }
264
svn_ra_do_diff2(svn_ra_session_t * session,const svn_ra_reporter2_t ** reporter,void ** report_baton,svn_revnum_t revision,const char * diff_target,svn_boolean_t recurse,svn_boolean_t ignore_ancestry,svn_boolean_t text_deltas,const char * versus_url,const svn_delta_editor_t * diff_editor,void * diff_baton,apr_pool_t * pool)265 svn_error_t *svn_ra_do_diff2(svn_ra_session_t *session,
266 const svn_ra_reporter2_t **reporter,
267 void **report_baton,
268 svn_revnum_t revision,
269 const char *diff_target,
270 svn_boolean_t recurse,
271 svn_boolean_t ignore_ancestry,
272 svn_boolean_t text_deltas,
273 const char *versus_url,
274 const svn_delta_editor_t *diff_editor,
275 void *diff_baton,
276 apr_pool_t *pool)
277 {
278 struct reporter_3in2_baton *b = apr_palloc(pool, sizeof(*b));
279 SVN_ERR_ASSERT(svn_path_is_empty(diff_target)
280 || svn_path_is_single_path_component(diff_target));
281 *reporter = &reporter_3in2_wrapper;
282 *report_baton = b;
283 return session->vtable->do_diff(session,
284 &(b->reporter3), &(b->reporter3_baton),
285 revision, diff_target,
286 SVN_DEPTH_INFINITY_OR_FILES(recurse),
287 ignore_ancestry, text_deltas, versus_url,
288 diff_editor, diff_baton, pool);
289 }
290
svn_ra_do_diff(svn_ra_session_t * session,const svn_ra_reporter2_t ** reporter,void ** report_baton,svn_revnum_t revision,const char * diff_target,svn_boolean_t recurse,svn_boolean_t ignore_ancestry,const char * versus_url,const svn_delta_editor_t * diff_editor,void * diff_baton,apr_pool_t * pool)291 svn_error_t *svn_ra_do_diff(svn_ra_session_t *session,
292 const svn_ra_reporter2_t **reporter,
293 void **report_baton,
294 svn_revnum_t revision,
295 const char *diff_target,
296 svn_boolean_t recurse,
297 svn_boolean_t ignore_ancestry,
298 const char *versus_url,
299 const svn_delta_editor_t *diff_editor,
300 void *diff_baton,
301 apr_pool_t *pool)
302 {
303 SVN_ERR_ASSERT(svn_path_is_empty(diff_target)
304 || svn_path_is_single_path_component(diff_target));
305 return svn_ra_do_diff2(session, reporter, report_baton, revision,
306 diff_target, recurse, ignore_ancestry, TRUE,
307 versus_url, diff_editor, diff_baton, pool);
308 }
309
svn_ra_get_log(svn_ra_session_t * session,const apr_array_header_t * paths,svn_revnum_t start,svn_revnum_t end,int limit,svn_boolean_t discover_changed_paths,svn_boolean_t strict_node_history,svn_log_message_receiver_t receiver,void * receiver_baton,apr_pool_t * pool)310 svn_error_t *svn_ra_get_log(svn_ra_session_t *session,
311 const apr_array_header_t *paths,
312 svn_revnum_t start,
313 svn_revnum_t end,
314 int limit,
315 svn_boolean_t discover_changed_paths,
316 svn_boolean_t strict_node_history,
317 svn_log_message_receiver_t receiver,
318 void *receiver_baton,
319 apr_pool_t *pool)
320 {
321 svn_log_entry_receiver_t receiver2;
322 void *receiver2_baton;
323
324 if (paths)
325 {
326 int i;
327 for (i = 0; i < paths->nelts; i++)
328 {
329 const char *path = APR_ARRAY_IDX(paths, i, const char *);
330 SVN_ERR_ASSERT(*path != '/');
331 }
332 }
333
334 svn_compat_wrap_log_receiver(&receiver2, &receiver2_baton,
335 receiver, receiver_baton,
336 pool);
337
338 return svn_ra_get_log2(session, paths, start, end, limit,
339 discover_changed_paths, strict_node_history,
340 FALSE, svn_compat_log_revprops_in(pool),
341 receiver2, receiver2_baton, pool);
342 }
343
svn_ra_get_file_revs(svn_ra_session_t * session,const char * path,svn_revnum_t start,svn_revnum_t end,svn_ra_file_rev_handler_t handler,void * handler_baton,apr_pool_t * pool)344 svn_error_t *svn_ra_get_file_revs(svn_ra_session_t *session,
345 const char *path,
346 svn_revnum_t start,
347 svn_revnum_t end,
348 svn_ra_file_rev_handler_t handler,
349 void *handler_baton,
350 apr_pool_t *pool)
351 {
352 svn_file_rev_handler_t handler2;
353 void *handler2_baton;
354
355 SVN_ERR_ASSERT(*path != '/');
356
357 svn_compat_wrap_file_rev_handler(&handler2, &handler2_baton,
358 handler, handler_baton,
359 pool);
360
361 return svn_ra_get_file_revs2(session, path, start, end, FALSE, handler2,
362 handler2_baton, pool);
363 }
364
365 svn_error_t *
svn_ra_do_update2(svn_ra_session_t * session,const svn_ra_reporter3_t ** reporter,void ** report_baton,svn_revnum_t revision_to_update_to,const char * update_target,svn_depth_t depth,svn_boolean_t send_copyfrom_args,const svn_delta_editor_t * update_editor,void * update_baton,apr_pool_t * pool)366 svn_ra_do_update2(svn_ra_session_t *session,
367 const svn_ra_reporter3_t **reporter,
368 void **report_baton,
369 svn_revnum_t revision_to_update_to,
370 const char *update_target,
371 svn_depth_t depth,
372 svn_boolean_t send_copyfrom_args,
373 const svn_delta_editor_t *update_editor,
374 void *update_baton,
375 apr_pool_t *pool)
376 {
377 return svn_error_trace(
378 svn_ra_do_update3(session,
379 reporter, report_baton,
380 revision_to_update_to, update_target,
381 depth,
382 send_copyfrom_args,
383 FALSE /* ignore_ancestry */,
384 update_editor, update_baton,
385 pool, pool));
386 }
387
svn_ra_do_update(svn_ra_session_t * session,const svn_ra_reporter2_t ** reporter,void ** report_baton,svn_revnum_t revision_to_update_to,const char * update_target,svn_boolean_t recurse,const svn_delta_editor_t * update_editor,void * update_baton,apr_pool_t * pool)388 svn_error_t *svn_ra_do_update(svn_ra_session_t *session,
389 const svn_ra_reporter2_t **reporter,
390 void **report_baton,
391 svn_revnum_t revision_to_update_to,
392 const char *update_target,
393 svn_boolean_t recurse,
394 const svn_delta_editor_t *update_editor,
395 void *update_baton,
396 apr_pool_t *pool)
397 {
398 struct reporter_3in2_baton *b = apr_palloc(pool, sizeof(*b));
399 SVN_ERR_ASSERT(svn_path_is_empty(update_target)
400 || svn_path_is_single_path_component(update_target));
401 *reporter = &reporter_3in2_wrapper;
402 *report_baton = b;
403 return session->vtable->do_update(session,
404 &(b->reporter3), &(b->reporter3_baton),
405 revision_to_update_to, update_target,
406 SVN_DEPTH_INFINITY_OR_FILES(recurse),
407 FALSE, /* no copyfrom args */
408 FALSE /* ignore_ancestry */,
409 update_editor, update_baton,
410 pool, pool);
411 }
412
413
414 svn_error_t *
svn_ra_do_switch2(svn_ra_session_t * session,const svn_ra_reporter3_t ** reporter,void ** report_baton,svn_revnum_t revision_to_switch_to,const char * switch_target,svn_depth_t depth,const char * switch_url,const svn_delta_editor_t * switch_editor,void * switch_baton,apr_pool_t * pool)415 svn_ra_do_switch2(svn_ra_session_t *session,
416 const svn_ra_reporter3_t **reporter,
417 void **report_baton,
418 svn_revnum_t revision_to_switch_to,
419 const char *switch_target,
420 svn_depth_t depth,
421 const char *switch_url,
422 const svn_delta_editor_t *switch_editor,
423 void *switch_baton,
424 apr_pool_t *pool)
425 {
426 return svn_error_trace(
427 svn_ra_do_switch3(session,
428 reporter, report_baton,
429 revision_to_switch_to, switch_target,
430 depth,
431 switch_url,
432 FALSE /* send_copyfrom_args */,
433 TRUE /* ignore_ancestry */,
434 switch_editor, switch_baton,
435 pool, pool));
436 }
437
svn_ra_do_switch(svn_ra_session_t * session,const svn_ra_reporter2_t ** reporter,void ** report_baton,svn_revnum_t revision_to_switch_to,const char * switch_target,svn_boolean_t recurse,const char * switch_url,const svn_delta_editor_t * switch_editor,void * switch_baton,apr_pool_t * pool)438 svn_error_t *svn_ra_do_switch(svn_ra_session_t *session,
439 const svn_ra_reporter2_t **reporter,
440 void **report_baton,
441 svn_revnum_t revision_to_switch_to,
442 const char *switch_target,
443 svn_boolean_t recurse,
444 const char *switch_url,
445 const svn_delta_editor_t *switch_editor,
446 void *switch_baton,
447 apr_pool_t *pool)
448 {
449 struct reporter_3in2_baton *b = apr_palloc(pool, sizeof(*b));
450 SVN_ERR_ASSERT(svn_path_is_empty(switch_target)
451 || svn_path_is_single_path_component(switch_target));
452 *reporter = &reporter_3in2_wrapper;
453 *report_baton = b;
454 return session->vtable->do_switch(session,
455 &(b->reporter3), &(b->reporter3_baton),
456 revision_to_switch_to, switch_target,
457 SVN_DEPTH_INFINITY_OR_FILES(recurse),
458 switch_url,
459 FALSE /* send_copyfrom_args */,
460 TRUE /* ignore_ancestry */,
461 switch_editor, switch_baton,
462 pool, pool);
463 }
464
svn_ra_do_status(svn_ra_session_t * session,const svn_ra_reporter2_t ** reporter,void ** report_baton,const char * status_target,svn_revnum_t revision,svn_boolean_t recurse,const svn_delta_editor_t * status_editor,void * status_baton,apr_pool_t * pool)465 svn_error_t *svn_ra_do_status(svn_ra_session_t *session,
466 const svn_ra_reporter2_t **reporter,
467 void **report_baton,
468 const char *status_target,
469 svn_revnum_t revision,
470 svn_boolean_t recurse,
471 const svn_delta_editor_t *status_editor,
472 void *status_baton,
473 apr_pool_t *pool)
474 {
475 struct reporter_3in2_baton *b = apr_palloc(pool, sizeof(*b));
476 SVN_ERR_ASSERT(svn_path_is_empty(status_target)
477 || svn_path_is_single_path_component(status_target));
478 *reporter = &reporter_3in2_wrapper;
479 *report_baton = b;
480 return session->vtable->do_status(session,
481 &(b->reporter3), &(b->reporter3_baton),
482 status_target, revision,
483 SVN_DEPTH_INFINITY_OR_IMMEDIATES(recurse),
484 status_editor, status_baton, pool);
485 }
486
svn_ra_get_dir(svn_ra_session_t * session,const char * path,svn_revnum_t revision,apr_hash_t ** dirents,svn_revnum_t * fetched_rev,apr_hash_t ** props,apr_pool_t * pool)487 svn_error_t *svn_ra_get_dir(svn_ra_session_t *session,
488 const char *path,
489 svn_revnum_t revision,
490 apr_hash_t **dirents,
491 svn_revnum_t *fetched_rev,
492 apr_hash_t **props,
493 apr_pool_t *pool)
494 {
495 SVN_ERR_ASSERT(*path != '/');
496 return session->vtable->get_dir(session, dirents, fetched_rev, props,
497 path, revision, SVN_DIRENT_ALL, pool);
498 }
499
500 svn_error_t *
svn_ra_local__deprecated_init(int abi_version,apr_pool_t * pool,apr_hash_t * hash)501 svn_ra_local__deprecated_init(int abi_version,
502 apr_pool_t *pool,
503 apr_hash_t *hash)
504 {
505 return svn_error_trace(svn_ra_local_init(abi_version, pool, hash));
506 }
507
508 svn_error_t *
svn_ra_svn__deprecated_init(int abi_version,apr_pool_t * pool,apr_hash_t * hash)509 svn_ra_svn__deprecated_init(int abi_version,
510 apr_pool_t *pool,
511 apr_hash_t *hash)
512 {
513 return svn_error_trace(svn_ra_svn_init(abi_version, pool, hash));
514 }
515
516 svn_error_t *
svn_ra_serf__deprecated_init(int abi_version,apr_pool_t * pool,apr_hash_t * hash)517 svn_ra_serf__deprecated_init(int abi_version,
518 apr_pool_t *pool,
519 apr_hash_t *hash)
520 {
521 return svn_error_trace(svn_ra_serf_init(abi_version, pool, hash));
522 }
523