1 /*-------------------------------------------------------------------------
2 *
3 * heapfuncs.c
4 * Functions to investigate heap pages
5 *
6 * We check the input to these functions for corrupt pointers etc. that
7 * might cause crashes, but at the same time we try to print out as much
8 * information as possible, even if it's nonsense. That's because if a
9 * page is corrupt, we don't know why and how exactly it is corrupt, so we
10 * let the user judge it.
11 *
12 * These functions are restricted to superusers for the fear of introducing
13 * security holes if the input checking isn't as water-tight as it should be.
14 * You'd need to be superuser to obtain a raw page image anyway, so
15 * there's hardly any use case for using these without superuser-rights
16 * anyway.
17 *
18 * Copyright (c) 2007-2021, PostgreSQL Global Development Group
19 *
20 * IDENTIFICATION
21 * contrib/pageinspect/heapfuncs.c
22 *
23 *-------------------------------------------------------------------------
24 */
25
26 #include "postgres.h"
27
28 #include "access/htup_details.h"
29 #include "access/relation.h"
30 #include "catalog/pg_am_d.h"
31 #include "catalog/pg_type.h"
32 #include "funcapi.h"
33 #include "mb/pg_wchar.h"
34 #include "miscadmin.h"
35 #include "pageinspect.h"
36 #include "port/pg_bitutils.h"
37 #include "utils/array.h"
38 #include "utils/builtins.h"
39 #include "utils/rel.h"
40
41 /*
42 * It's not supported to create tuples with oids anymore, but when pg_upgrade
43 * was used to upgrade from an older version, tuples might still have an
44 * oid. Seems worthwhile to display that.
45 */
46 #define HeapTupleHeaderGetOidOld(tup) \
47 ( \
48 ((tup)->t_infomask & HEAP_HASOID_OLD) ? \
49 *((Oid *) ((char *)(tup) + (tup)->t_hoff - sizeof(Oid))) \
50 : \
51 InvalidOid \
52 )
53
54
55 /*
56 * bits_to_text
57 *
58 * Converts a bits8-array of 'len' bits to a human-readable
59 * c-string representation.
60 */
61 static char *
bits_to_text(bits8 * bits,int len)62 bits_to_text(bits8 *bits, int len)
63 {
64 int i;
65 char *str;
66
67 str = palloc(len + 1);
68
69 for (i = 0; i < len; i++)
70 str[i] = (bits[(i / 8)] & (1 << (i % 8))) ? '1' : '0';
71
72 str[i] = '\0';
73
74 return str;
75 }
76
77
78 /*
79 * text_to_bits
80 *
81 * Converts a c-string representation of bits into a bits8-array. This is
82 * the reverse operation of previous routine.
83 */
84 static bits8 *
text_to_bits(char * str,int len)85 text_to_bits(char *str, int len)
86 {
87 bits8 *bits;
88 int off = 0;
89 char byte = 0;
90
91 bits = palloc(len + 1);
92
93 while (off < len)
94 {
95 if (off % 8 == 0)
96 byte = 0;
97
98 if ((str[off] == '0') || (str[off] == '1'))
99 byte = byte | ((str[off] - '0') << off % 8);
100 else
101 ereport(ERROR,
102 (errcode(ERRCODE_DATA_CORRUPTED),
103 errmsg("invalid character \"%.*s\" in t_bits string",
104 pg_mblen(str + off), str + off)));
105
106 if (off % 8 == 7)
107 bits[off / 8] = byte;
108
109 off++;
110 }
111
112 return bits;
113 }
114
115 /*
116 * heap_page_items
117 *
118 * Allows inspection of line pointers and tuple headers of a heap page.
119 */
120 PG_FUNCTION_INFO_V1(heap_page_items);
121
122 typedef struct heap_page_items_state
123 {
124 TupleDesc tupd;
125 Page page;
126 uint16 offset;
127 } heap_page_items_state;
128
129 Datum
heap_page_items(PG_FUNCTION_ARGS)130 heap_page_items(PG_FUNCTION_ARGS)
131 {
132 bytea *raw_page = PG_GETARG_BYTEA_P(0);
133 heap_page_items_state *inter_call_data = NULL;
134 FuncCallContext *fctx;
135 int raw_page_size;
136
137 if (!superuser())
138 ereport(ERROR,
139 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
140 errmsg("must be superuser to use raw page functions")));
141
142 raw_page_size = VARSIZE(raw_page) - VARHDRSZ;
143
144 if (SRF_IS_FIRSTCALL())
145 {
146 TupleDesc tupdesc;
147 MemoryContext mctx;
148
149 if (raw_page_size < SizeOfPageHeaderData)
150 ereport(ERROR,
151 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
152 errmsg("input page too small (%d bytes)", raw_page_size)));
153
154 fctx = SRF_FIRSTCALL_INIT();
155 mctx = MemoryContextSwitchTo(fctx->multi_call_memory_ctx);
156
157 inter_call_data = palloc(sizeof(heap_page_items_state));
158
159 /* Build a tuple descriptor for our result type */
160 if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
161 elog(ERROR, "return type must be a row type");
162
163 inter_call_data->tupd = tupdesc;
164
165 inter_call_data->offset = FirstOffsetNumber;
166 inter_call_data->page = VARDATA(raw_page);
167
168 fctx->max_calls = PageGetMaxOffsetNumber(inter_call_data->page);
169 fctx->user_fctx = inter_call_data;
170
171 MemoryContextSwitchTo(mctx);
172 }
173
174 fctx = SRF_PERCALL_SETUP();
175 inter_call_data = fctx->user_fctx;
176
177 if (fctx->call_cntr < fctx->max_calls)
178 {
179 Page page = inter_call_data->page;
180 HeapTuple resultTuple;
181 Datum result;
182 ItemId id;
183 Datum values[14];
184 bool nulls[14];
185 uint16 lp_offset;
186 uint16 lp_flags;
187 uint16 lp_len;
188
189 memset(nulls, 0, sizeof(nulls));
190
191 /* Extract information from the line pointer */
192
193 id = PageGetItemId(page, inter_call_data->offset);
194
195 lp_offset = ItemIdGetOffset(id);
196 lp_flags = ItemIdGetFlags(id);
197 lp_len = ItemIdGetLength(id);
198
199 values[0] = UInt16GetDatum(inter_call_data->offset);
200 values[1] = UInt16GetDatum(lp_offset);
201 values[2] = UInt16GetDatum(lp_flags);
202 values[3] = UInt16GetDatum(lp_len);
203
204 /*
205 * We do just enough validity checking to make sure we don't reference
206 * data outside the page passed to us. The page could be corrupt in
207 * many other ways, but at least we won't crash.
208 */
209 if (ItemIdHasStorage(id) &&
210 lp_len >= MinHeapTupleSize &&
211 lp_offset == MAXALIGN(lp_offset) &&
212 lp_offset + lp_len <= raw_page_size)
213 {
214 HeapTupleHeader tuphdr;
215 bytea *tuple_data_bytea;
216 int tuple_data_len;
217
218 /* Extract information from the tuple header */
219
220 tuphdr = (HeapTupleHeader) PageGetItem(page, id);
221
222 values[4] = UInt32GetDatum(HeapTupleHeaderGetRawXmin(tuphdr));
223 values[5] = UInt32GetDatum(HeapTupleHeaderGetRawXmax(tuphdr));
224 /* shared with xvac */
225 values[6] = UInt32GetDatum(HeapTupleHeaderGetRawCommandId(tuphdr));
226 values[7] = PointerGetDatum(&tuphdr->t_ctid);
227 values[8] = UInt32GetDatum(tuphdr->t_infomask2);
228 values[9] = UInt32GetDatum(tuphdr->t_infomask);
229 values[10] = UInt8GetDatum(tuphdr->t_hoff);
230
231 /* Copy raw tuple data into bytea attribute */
232 tuple_data_len = lp_len - tuphdr->t_hoff;
233 tuple_data_bytea = (bytea *) palloc(tuple_data_len + VARHDRSZ);
234 SET_VARSIZE(tuple_data_bytea, tuple_data_len + VARHDRSZ);
235 memcpy(VARDATA(tuple_data_bytea), (char *) tuphdr + tuphdr->t_hoff,
236 tuple_data_len);
237 values[13] = PointerGetDatum(tuple_data_bytea);
238
239 /*
240 * We already checked that the item is completely within the raw
241 * page passed to us, with the length given in the line pointer.
242 * Let's check that t_hoff doesn't point over lp_len, before using
243 * it to access t_bits and oid.
244 */
245 if (tuphdr->t_hoff >= SizeofHeapTupleHeader &&
246 tuphdr->t_hoff <= lp_len &&
247 tuphdr->t_hoff == MAXALIGN(tuphdr->t_hoff))
248 {
249 if (tuphdr->t_infomask & HEAP_HASNULL)
250 {
251 int bits_len;
252
253 bits_len =
254 BITMAPLEN(HeapTupleHeaderGetNatts(tuphdr)) * BITS_PER_BYTE;
255 values[11] = CStringGetTextDatum(bits_to_text(tuphdr->t_bits, bits_len));
256 }
257 else
258 nulls[11] = true;
259
260 if (tuphdr->t_infomask & HEAP_HASOID_OLD)
261 values[12] = HeapTupleHeaderGetOidOld(tuphdr);
262 else
263 nulls[12] = true;
264 }
265 else
266 {
267 nulls[11] = true;
268 nulls[12] = true;
269 }
270 }
271 else
272 {
273 /*
274 * The line pointer is not used, or it's invalid. Set the rest of
275 * the fields to NULL
276 */
277 int i;
278
279 for (i = 4; i <= 13; i++)
280 nulls[i] = true;
281 }
282
283 /* Build and return the result tuple. */
284 resultTuple = heap_form_tuple(inter_call_data->tupd, values, nulls);
285 result = HeapTupleGetDatum(resultTuple);
286
287 inter_call_data->offset++;
288
289 SRF_RETURN_NEXT(fctx, result);
290 }
291 else
292 SRF_RETURN_DONE(fctx);
293 }
294
295 /*
296 * tuple_data_split_internal
297 *
298 * Split raw tuple data taken directly from a page into an array of bytea
299 * elements. This routine does a lookup on NULL values and creates array
300 * elements accordingly. This is a reimplementation of nocachegetattr()
301 * in heaptuple.c simplified for educational purposes.
302 */
303 static Datum
tuple_data_split_internal(Oid relid,char * tupdata,uint16 tupdata_len,uint16 t_infomask,uint16 t_infomask2,bits8 * t_bits,bool do_detoast)304 tuple_data_split_internal(Oid relid, char *tupdata,
305 uint16 tupdata_len, uint16 t_infomask,
306 uint16 t_infomask2, bits8 *t_bits,
307 bool do_detoast)
308 {
309 ArrayBuildState *raw_attrs;
310 int nattrs;
311 int i;
312 int off = 0;
313 Relation rel;
314 TupleDesc tupdesc;
315
316 /* Get tuple descriptor from relation OID */
317 rel = relation_open(relid, AccessShareLock);
318 tupdesc = RelationGetDescr(rel);
319
320 raw_attrs = initArrayResult(BYTEAOID, CurrentMemoryContext, false);
321 nattrs = tupdesc->natts;
322
323 if (rel->rd_rel->relam != HEAP_TABLE_AM_OID)
324 ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
325 errmsg("only heap AM is supported")));
326
327 if (nattrs < (t_infomask2 & HEAP_NATTS_MASK))
328 ereport(ERROR,
329 (errcode(ERRCODE_DATA_CORRUPTED),
330 errmsg("number of attributes in tuple header is greater than number of attributes in tuple descriptor")));
331
332 for (i = 0; i < nattrs; i++)
333 {
334 Form_pg_attribute attr;
335 bool is_null;
336 bytea *attr_data = NULL;
337
338 attr = TupleDescAttr(tupdesc, i);
339
340 /*
341 * Tuple header can specify fewer attributes than tuple descriptor as
342 * ALTER TABLE ADD COLUMN without DEFAULT keyword does not actually
343 * change tuples in pages, so attributes with numbers greater than
344 * (t_infomask2 & HEAP_NATTS_MASK) should be treated as NULL.
345 */
346 if (i >= (t_infomask2 & HEAP_NATTS_MASK))
347 is_null = true;
348 else
349 is_null = (t_infomask & HEAP_HASNULL) && att_isnull(i, t_bits);
350
351 if (!is_null)
352 {
353 int len;
354
355 if (attr->attlen == -1)
356 {
357 off = att_align_pointer(off, attr->attalign, -1,
358 tupdata + off);
359
360 /*
361 * As VARSIZE_ANY throws an exception if it can't properly
362 * detect the type of external storage in macros VARTAG_SIZE,
363 * this check is repeated to have a nicer error handling.
364 */
365 if (VARATT_IS_EXTERNAL(tupdata + off) &&
366 !VARATT_IS_EXTERNAL_ONDISK(tupdata + off) &&
367 !VARATT_IS_EXTERNAL_INDIRECT(tupdata + off))
368 ereport(ERROR,
369 (errcode(ERRCODE_DATA_CORRUPTED),
370 errmsg("first byte of varlena attribute is incorrect for attribute %d", i)));
371
372 len = VARSIZE_ANY(tupdata + off);
373 }
374 else
375 {
376 off = att_align_nominal(off, attr->attalign);
377 len = attr->attlen;
378 }
379
380 if (tupdata_len < off + len)
381 ereport(ERROR,
382 (errcode(ERRCODE_DATA_CORRUPTED),
383 errmsg("unexpected end of tuple data")));
384
385 if (attr->attlen == -1 && do_detoast)
386 attr_data = DatumGetByteaPCopy(tupdata + off);
387 else
388 {
389 attr_data = (bytea *) palloc(len + VARHDRSZ);
390 SET_VARSIZE(attr_data, len + VARHDRSZ);
391 memcpy(VARDATA(attr_data), tupdata + off, len);
392 }
393
394 off = att_addlength_pointer(off, attr->attlen,
395 tupdata + off);
396 }
397
398 raw_attrs = accumArrayResult(raw_attrs, PointerGetDatum(attr_data),
399 is_null, BYTEAOID, CurrentMemoryContext);
400 if (attr_data)
401 pfree(attr_data);
402 }
403
404 if (tupdata_len != off)
405 ereport(ERROR,
406 (errcode(ERRCODE_DATA_CORRUPTED),
407 errmsg("end of tuple reached without looking at all its data")));
408
409 relation_close(rel, AccessShareLock);
410
411 return makeArrayResult(raw_attrs, CurrentMemoryContext);
412 }
413
414 /*
415 * tuple_data_split
416 *
417 * Split raw tuple data taken directly from page into distinct elements
418 * taking into account null values.
419 */
420 PG_FUNCTION_INFO_V1(tuple_data_split);
421
422 Datum
tuple_data_split(PG_FUNCTION_ARGS)423 tuple_data_split(PG_FUNCTION_ARGS)
424 {
425 Oid relid;
426 bytea *raw_data;
427 uint16 t_infomask;
428 uint16 t_infomask2;
429 char *t_bits_str;
430 bool do_detoast = false;
431 bits8 *t_bits = NULL;
432 Datum res;
433
434 relid = PG_GETARG_OID(0);
435 raw_data = PG_ARGISNULL(1) ? NULL : PG_GETARG_BYTEA_P(1);
436 t_infomask = PG_GETARG_INT16(2);
437 t_infomask2 = PG_GETARG_INT16(3);
438 t_bits_str = PG_ARGISNULL(4) ? NULL :
439 text_to_cstring(PG_GETARG_TEXT_PP(4));
440
441 if (PG_NARGS() >= 6)
442 do_detoast = PG_GETARG_BOOL(5);
443
444 if (!superuser())
445 ereport(ERROR,
446 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
447 errmsg("must be superuser to use raw page functions")));
448
449 if (!raw_data)
450 PG_RETURN_NULL();
451
452 /*
453 * Convert t_bits string back to the bits8 array as represented in the
454 * tuple header.
455 */
456 if (t_infomask & HEAP_HASNULL)
457 {
458 int bits_str_len;
459 int bits_len;
460
461 bits_len = BITMAPLEN(t_infomask2 & HEAP_NATTS_MASK) * BITS_PER_BYTE;
462 if (!t_bits_str)
463 ereport(ERROR,
464 (errcode(ERRCODE_DATA_CORRUPTED),
465 errmsg("t_bits string must not be NULL")));
466
467 bits_str_len = strlen(t_bits_str);
468 if (bits_len != bits_str_len)
469 ereport(ERROR,
470 (errcode(ERRCODE_DATA_CORRUPTED),
471 errmsg("unexpected length of t_bits string: %u, expected %u",
472 bits_str_len, bits_len)));
473
474 /* do the conversion */
475 t_bits = text_to_bits(t_bits_str, bits_str_len);
476 }
477 else
478 {
479 if (t_bits_str)
480 ereport(ERROR,
481 (errcode(ERRCODE_DATA_CORRUPTED),
482 errmsg("t_bits string is expected to be NULL, but instead it is %zu bytes long",
483 strlen(t_bits_str))));
484 }
485
486 /* Split tuple data */
487 res = tuple_data_split_internal(relid, (char *) raw_data + VARHDRSZ,
488 VARSIZE(raw_data) - VARHDRSZ,
489 t_infomask, t_infomask2, t_bits,
490 do_detoast);
491
492 if (t_bits)
493 pfree(t_bits);
494
495 PG_RETURN_ARRAYTYPE_P(res);
496 }
497
498 /*
499 * heap_tuple_infomask_flags
500 *
501 * Decode into a human-readable format t_infomask and t_infomask2 associated
502 * to a tuple. All the flags are described in access/htup_details.h.
503 */
504 PG_FUNCTION_INFO_V1(heap_tuple_infomask_flags);
505
506 Datum
heap_tuple_infomask_flags(PG_FUNCTION_ARGS)507 heap_tuple_infomask_flags(PG_FUNCTION_ARGS)
508 {
509 #define HEAP_TUPLE_INFOMASK_COLS 2
510 Datum values[HEAP_TUPLE_INFOMASK_COLS];
511 bool nulls[HEAP_TUPLE_INFOMASK_COLS];
512 uint16 t_infomask = PG_GETARG_INT16(0);
513 uint16 t_infomask2 = PG_GETARG_INT16(1);
514 int cnt = 0;
515 ArrayType *a;
516 int bitcnt;
517 Datum *flags;
518 TupleDesc tupdesc;
519 HeapTuple tuple;
520
521 if (!superuser())
522 ereport(ERROR,
523 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
524 errmsg("must be superuser to use raw page functions")));
525
526 /* Build a tuple descriptor for our result type */
527 if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
528 elog(ERROR, "return type must be a row type");
529
530 bitcnt = pg_popcount((const char *) &t_infomask, sizeof(uint16)) +
531 pg_popcount((const char *) &t_infomask2, sizeof(uint16));
532
533 /* Initialize values and NULL flags arrays */
534 MemSet(values, 0, sizeof(values));
535 MemSet(nulls, 0, sizeof(nulls));
536
537 /* If no flags, return a set of empty arrays */
538 if (bitcnt <= 0)
539 {
540 values[0] = PointerGetDatum(construct_empty_array(TEXTOID));
541 values[1] = PointerGetDatum(construct_empty_array(TEXTOID));
542 tuple = heap_form_tuple(tupdesc, values, nulls);
543 PG_RETURN_DATUM(HeapTupleGetDatum(tuple));
544 }
545
546 /* build set of raw flags */
547 flags = (Datum *) palloc0(sizeof(Datum) * bitcnt);
548
549 /* decode t_infomask */
550 if ((t_infomask & HEAP_HASNULL) != 0)
551 flags[cnt++] = CStringGetTextDatum("HEAP_HASNULL");
552 if ((t_infomask & HEAP_HASVARWIDTH) != 0)
553 flags[cnt++] = CStringGetTextDatum("HEAP_HASVARWIDTH");
554 if ((t_infomask & HEAP_HASEXTERNAL) != 0)
555 flags[cnt++] = CStringGetTextDatum("HEAP_HASEXTERNAL");
556 if ((t_infomask & HEAP_HASOID_OLD) != 0)
557 flags[cnt++] = CStringGetTextDatum("HEAP_HASOID_OLD");
558 if ((t_infomask & HEAP_XMAX_KEYSHR_LOCK) != 0)
559 flags[cnt++] = CStringGetTextDatum("HEAP_XMAX_KEYSHR_LOCK");
560 if ((t_infomask & HEAP_COMBOCID) != 0)
561 flags[cnt++] = CStringGetTextDatum("HEAP_COMBOCID");
562 if ((t_infomask & HEAP_XMAX_EXCL_LOCK) != 0)
563 flags[cnt++] = CStringGetTextDatum("HEAP_XMAX_EXCL_LOCK");
564 if ((t_infomask & HEAP_XMAX_LOCK_ONLY) != 0)
565 flags[cnt++] = CStringGetTextDatum("HEAP_XMAX_LOCK_ONLY");
566 if ((t_infomask & HEAP_XMIN_COMMITTED) != 0)
567 flags[cnt++] = CStringGetTextDatum("HEAP_XMIN_COMMITTED");
568 if ((t_infomask & HEAP_XMIN_INVALID) != 0)
569 flags[cnt++] = CStringGetTextDatum("HEAP_XMIN_INVALID");
570 if ((t_infomask & HEAP_XMAX_COMMITTED) != 0)
571 flags[cnt++] = CStringGetTextDatum("HEAP_XMAX_COMMITTED");
572 if ((t_infomask & HEAP_XMAX_INVALID) != 0)
573 flags[cnt++] = CStringGetTextDatum("HEAP_XMAX_INVALID");
574 if ((t_infomask & HEAP_XMAX_IS_MULTI) != 0)
575 flags[cnt++] = CStringGetTextDatum("HEAP_XMAX_IS_MULTI");
576 if ((t_infomask & HEAP_UPDATED) != 0)
577 flags[cnt++] = CStringGetTextDatum("HEAP_UPDATED");
578 if ((t_infomask & HEAP_MOVED_OFF) != 0)
579 flags[cnt++] = CStringGetTextDatum("HEAP_MOVED_OFF");
580 if ((t_infomask & HEAP_MOVED_IN) != 0)
581 flags[cnt++] = CStringGetTextDatum("HEAP_MOVED_IN");
582
583 /* decode t_infomask2 */
584 if ((t_infomask2 & HEAP_KEYS_UPDATED) != 0)
585 flags[cnt++] = CStringGetTextDatum("HEAP_KEYS_UPDATED");
586 if ((t_infomask2 & HEAP_HOT_UPDATED) != 0)
587 flags[cnt++] = CStringGetTextDatum("HEAP_HOT_UPDATED");
588 if ((t_infomask2 & HEAP_ONLY_TUPLE) != 0)
589 flags[cnt++] = CStringGetTextDatum("HEAP_ONLY_TUPLE");
590
591 /* build value */
592 Assert(cnt <= bitcnt);
593 a = construct_array(flags, cnt, TEXTOID, -1, false, TYPALIGN_INT);
594 values[0] = PointerGetDatum(a);
595
596 /*
597 * Build set of combined flags. Use the same array as previously, this
598 * keeps the code simple.
599 */
600 cnt = 0;
601 MemSet(flags, 0, sizeof(Datum) * bitcnt);
602
603 /* decode combined masks of t_infomask */
604 if ((t_infomask & HEAP_XMAX_SHR_LOCK) == HEAP_XMAX_SHR_LOCK)
605 flags[cnt++] = CStringGetTextDatum("HEAP_XMAX_SHR_LOCK");
606 if ((t_infomask & HEAP_XMIN_FROZEN) == HEAP_XMIN_FROZEN)
607 flags[cnt++] = CStringGetTextDatum("HEAP_XMIN_FROZEN");
608 if ((t_infomask & HEAP_MOVED) == HEAP_MOVED)
609 flags[cnt++] = CStringGetTextDatum("HEAP_MOVED");
610
611 /* Build an empty array if there are no combined flags */
612 if (cnt == 0)
613 a = construct_empty_array(TEXTOID);
614 else
615 a = construct_array(flags, cnt, TEXTOID, -1, false, TYPALIGN_INT);
616 pfree(flags);
617 values[1] = PointerGetDatum(a);
618
619 /* Returns the record as Datum */
620 tuple = heap_form_tuple(tupdesc, values, nulls);
621 PG_RETURN_DATUM(HeapTupleGetDatum(tuple));
622 }
623