server/object.c

   1 /*
   2  * Server-side objects
   3  *
   4  * Copyright (C) 1998 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include <assert.h>
  25 #include <limits.h>
  26 #include <stdlib.h>
  27 #include <stdio.h>
  28 #include <string.h>
  29 #include <unistd.h>
  30 #include <stdarg.h>
  31 #ifdef HAVE_VALGRIND_MEMCHECK_H
  32 #include <valgrind/memcheck.h>
  33 #endif
  34
  35 #include "ntstatus.h"
  36 #define WIN32_NO_STATUS
  37 #include "winternl.h"
  38
  39 #include "file.h"
  40 #include "process.h"
  41 #include "thread.h"
  42 #include "unicode.h"
  43 #include "security.h"
  44
  45
  46 struct namespace
  47 {
  48     unsigned int        hash_size;       /* size of hash table */
  49     struct list         names[1];        /* array of hash entry lists */
  50 };
  51
  52
  53 #ifdef DEBUG_OBJECTS
  54 static struct list object_list = LIST_INIT(object_list);
  55 static struct list static_object_list = LIST_INIT(static_object_list);
  56
  57 void dump_objects(void)
  58 {
  59     struct list *p;
  60
  61     LIST_FOR_EACH( p, &static_object_list )
  62     {
  63         struct object *ptr = LIST_ENTRY( p, struct object, obj_list );
  64         fprintf( stderr, "%p:%d: ", ptr, ptr->refcount );
  65         dump_object_name( ptr );
  66         ptr->ops->dump( ptr, 1 );
  67     }
  68     LIST_FOR_EACH( p, &object_list )
  69     {
  70         struct object *ptr = LIST_ENTRY( p, struct object, obj_list );
  71         fprintf( stderr, "%p:%d: ", ptr, ptr->refcount );
  72         dump_object_name( ptr );
  73         ptr->ops->dump( ptr, 1 );
  74     }
  75 }
  76
  77 void close_objects(void)
  78 {
  79     struct list *ptr;
  80
  81     /* release the static objects */
  82     while ((ptr = list_head( &static_object_list )))
  83     {
  84         struct object *obj = LIST_ENTRY( ptr, struct object, obj_list );
  85         /* move it back to the standard list before freeing */
  86         list_remove( &obj->obj_list );
  87         list_add_head( &object_list, &obj->obj_list );
  88         release_object( obj );
  89     }
  90
  91     dump_objects();  /* dump any remaining objects */
  92 }
  93
  94 #endif  /* DEBUG_OBJECTS */
  95
  96 /*****************************************************************/
  97
  98 /* mark a block of memory as uninitialized for debugging purposes */
  99 static inline void mark_block_uninitialized( void *ptr, size_t size )
 100 {
 101     memset( ptr, 0x55, size );
 102 #if defined(VALGRIND_MAKE_MEM_UNDEFINED)
 103     VALGRIND_DISCARD( VALGRIND_MAKE_MEM_UNDEFINED( ptr, size ));
 104 #elif defined(VALGRIND_MAKE_WRITABLE)
 105     VALGRIND_DISCARD( VALGRIND_MAKE_WRITABLE( ptr, size ));
 106 #endif
 107 }
 108
 109 /* malloc replacement */
 110 void *mem_alloc( size_t size )
 111 {
 112     void *ptr = malloc( size );
 113     if (ptr) mark_block_uninitialized( ptr, size );
 114     else set_error( STATUS_NO_MEMORY );
 115     return ptr;
 116 }
 117
 118 /* duplicate a block of memory */
 119 void *memdup( const void *data, size_t len )
 120 {
 121     void *ptr = malloc( len );
 122     if (ptr) memcpy( ptr, data, len );
 123     else set_error( STATUS_NO_MEMORY );
 124     return ptr;
 125 }
 126
 127
 128 /*****************************************************************/
 129
 130 void namespace_add( struct namespace *namespace, struct object_name *ptr )
 131 {
 132     unsigned int hash = hash_strW( ptr->name, ptr->len, namespace->hash_size );
 133
 134     list_add_head( &namespace->names[hash], &ptr->entry );
 135 }
 136
 137 /* allocate a name for an object */
 138 static struct object_name *alloc_name( const struct unicode_str *name )
 139 {
 140     struct object_name *ptr;
 141
 142     if ((ptr = mem_alloc( sizeof(*ptr) + name->len - sizeof(ptr->name) )))
 143     {
 144         ptr->len = name->len;
 145         ptr->parent = NULL;
 146         memcpy( ptr->name, name->str, name->len );
 147     }
 148     return ptr;
 149 }
 150
 151 /* get the name of an existing object */
 152 const WCHAR *get_object_name( struct object *obj, data_size_t *len )
 153 {
 154     struct object_name *ptr = obj->name;
 155     if (!ptr) return NULL;
 156     *len = ptr->len;
 157     return ptr->name;
 158 }
 159
 160 /* get the full path name of an existing object */
 161 WCHAR *get_object_full_name( struct object *obj, data_size_t *ret_len )
 162 {
 163     static const WCHAR backslash = '\\';
 164     struct object *ptr = obj;
 165     data_size_t len = 0;
 166     char *ret;
 167
 168     while (ptr && ptr->name)
 169     {
 170         struct object_name *name = ptr->name;
 171         len += name->len + sizeof(WCHAR);
 172         ptr = name->parent;
 173     }
 174     if (!len) return NULL;
 175     if (!(ret = malloc( len ))) return NULL;
 176
 177     *ret_len = len;
 178     while (obj && obj->name)
 179     {
 180         struct object_name *name = obj->name;
 181         memcpy( ret + len - name->len, name->name, name->len );
 182         len -= name->len + sizeof(WCHAR);
 183         memcpy( ret + len, &backslash, sizeof(WCHAR) );
 184         obj = name->parent;
 185     }
 186     return (WCHAR *)ret;
 187 }
 188
 189 /* allocate and initialize an object */
 190 void *alloc_object( const struct object_ops *ops )
 191 {
 192     struct object *obj = mem_alloc( ops->size );
 193     if (obj)
 194     {
 195         obj->refcount     = 1;
 196         obj->handle_count = 0;
 197         obj->ops          = ops;
 198         obj->name         = NULL;
 199         obj->sd           = NULL;
 200         list_init( &obj->wait_queue );
 201 #ifdef DEBUG_OBJECTS
 202         list_add_head( &object_list, &obj->obj_list );
 203 #endif
 204         return obj;
 205     }
 206     return NULL;
 207 }
 208
 209 /* free an object once it has been destroyed */
 210 static void free_object( struct object *obj )
 211 {
 212     free( obj->sd );
 213 #ifdef DEBUG_OBJECTS
 214     list_remove( &obj->obj_list );
 215     memset( obj, 0xaa, obj->ops->size );
 216 #endif
 217     free( obj );
 218 }
 219
 220 /* find an object by name starting from the specified root */
 221 /* if it doesn't exist, its parent is returned, and name_left contains the remaining name */
 222 struct object *lookup_named_object( struct object *root, const struct unicode_str *name,
 223                                     unsigned int attr, struct unicode_str *name_left )
 224 {
 225     struct object *obj, *parent;
 226     struct unicode_str name_tmp = *name, *ptr = &name_tmp;
 227
 228     if (root)
 229     {
 230         /* if root is specified path shouldn't start with backslash */
 231         if (name_tmp.len && name_tmp.str[0] == '\\')
 232         {
 233             set_error( STATUS_OBJECT_PATH_SYNTAX_BAD );
 234             return NULL;
 235         }
 236         parent = grab_object( root );
 237     }
 238     else
 239     {
 240         if (!name_tmp.len || name_tmp.str[0] != '\\')
 241         {
 242             set_error( STATUS_OBJECT_PATH_SYNTAX_BAD );
 243             return NULL;
 244         }
 245         /* skip leading backslash */
 246         name_tmp.str++;
 247         name_tmp.len -= sizeof(WCHAR);
 248         parent = get_root_directory();
 249     }
 250
 251     if (!name_tmp.len) ptr = NULL;  /* special case for empty path */
 252
 253     clear_error();
 254
 255     while ((obj = parent->ops->lookup_name( parent, ptr, attr )))
 256     {
 257         /* move to the next element */
 258         release_object ( parent );
 259         parent = obj;
 260     }
 261     if (get_error())
 262     {
 263         release_object( parent );
 264         return NULL;
 265     }
 266
 267     if (name_left) *name_left = name_tmp;
 268     return parent;
 269 }
 270
 271 /* return length of first path element in name */
 272 data_size_t get_path_element( const WCHAR *name, data_size_t len )
 273 {
 274     data_size_t i;
 275
 276     for (i = 0; i < len / sizeof(WCHAR); i++) if (name[i] == '\\') break;
 277     return i * sizeof(WCHAR);
 278 }
 279
 280 static struct object *create_object( struct object *parent, const struct object_ops *ops,
 281                                      const struct unicode_str *name, const struct security_descriptor *sd )
 282 {
 283     struct object *obj;
 284     struct object_name *name_ptr;
 285
 286     if (!(name_ptr = alloc_name( name ))) return NULL;
 287     if (!(obj = alloc_object( ops ))) goto failed;
 288     if (sd && !default_set_sd( obj, sd, OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION |
 289                                DACL_SECURITY_INFORMATION | SACL_SECURITY_INFORMATION ))
 290         goto failed;
 291     if (!obj->ops->link_name( obj, name_ptr, parent )) goto failed;
 292
 293     name_ptr->obj = obj;
 294     obj->name = name_ptr;
 295     return obj;
 296
 297 failed:
 298     if (obj) free_object( obj );
 299     free( name_ptr );
 300     return NULL;
 301 }
 302
 303 /* create an object as named child under the specified parent */
 304 void *create_named_object( struct object *parent, const struct object_ops *ops,
 305                            const struct unicode_str *name, unsigned int attributes,
 306                            const struct security_descriptor *sd )
 307 {
 308     struct object *obj, *new_obj;
 309     struct unicode_str new_name;
 310
 311     clear_error();
 312
 313     if (!name || !name->len)
 314     {
 315         if (!(new_obj = alloc_object( ops ))) return NULL;
 316         if (sd && !default_set_sd( new_obj, sd, OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION |
 317                                    DACL_SECURITY_INFORMATION | SACL_SECURITY_INFORMATION ))
 318         {
 319             free_object( new_obj );
 320             return NULL;
 321         }
 322         return new_obj;
 323     }
 324
 325     if (!(obj = lookup_named_object( parent, name, attributes, &new_name ))) return NULL;
 326
 327     if (!new_name.len)
 328     {
 329         if (attributes & OBJ_OPENIF && obj->ops == ops)
 330             set_error( STATUS_OBJECT_NAME_EXISTS );
 331         else
 332         {
 333             release_object( obj );
 334             obj = NULL;
 335             if (attributes & OBJ_OPENIF)
 336                 set_error( STATUS_OBJECT_TYPE_MISMATCH );
 337             else
 338                 set_error( STATUS_OBJECT_NAME_COLLISION );
 339         }
 340         return obj;
 341     }
 342
 343     new_obj = create_object( obj, ops, &new_name, sd );
 344     release_object( obj );
 345     return new_obj;
 346 }
 347
 348 /* open a object by name under the specified parent */
 349 void *open_named_object( struct object *parent, const struct object_ops *ops,
 350                          const struct unicode_str *name, unsigned int attributes )
 351 {
 352     struct unicode_str name_left;
 353     struct object *obj;
 354
 355     if ((obj = lookup_named_object( parent, name, attributes, &name_left )))
 356     {
 357         if (name_left.len) /* not fully parsed */
 358             set_error( STATUS_OBJECT_NAME_NOT_FOUND );
 359         else if (ops && obj->ops != ops)
 360             set_error( STATUS_OBJECT_TYPE_MISMATCH );
 361         else
 362             return obj;
 363
 364         release_object( obj );
 365     }
 366     return NULL;
 367 }
 368
 369 /* recursive helper for dump_object_name */
 370 static void dump_name( struct object *obj )
 371 {
 372     struct object_name *name = obj->name;
 373
 374     if (!name) return;
 375     if (name->parent) dump_name( name->parent );
 376     fputs( "\\\\", stderr );
 377     dump_strW( name->name, name->len, stderr, "[]" );
 378 }
 379
 380 /* dump the name of an object to stderr */
 381 void dump_object_name( struct object *obj )
 382 {
 383     if (!obj->name) return;
 384     fputc( '[', stderr );
 385     dump_name( obj );
 386     fputs( "] ", stderr );
 387 }
 388
 389 /* unlink a named object from its namespace, without freeing the object itself */
 390 void unlink_named_object( struct object *obj )
 391 {
 392     struct object_name *name_ptr = obj->name;
 393
 394     if (!name_ptr) return;
 395     obj->name = NULL;
 396     obj->ops->unlink_name( obj, name_ptr );
 397     if (name_ptr->parent) release_object( name_ptr->parent );
 398     free( name_ptr );
 399 }
 400
 401 /* mark an object as being stored statically, i.e. only released at shutdown */
 402 void make_object_static( struct object *obj )
 403 {
 404 #ifdef DEBUG_OBJECTS
 405     list_remove( &obj->obj_list );
 406     list_add_head( &static_object_list, &obj->obj_list );
 407 #endif
 408 }
 409
 410 /* grab an object (i.e. increment its refcount) and return the object */
 411 struct object *grab_object( void *ptr )
 412 {
 413     struct object *obj = (struct object *)ptr;
 414     assert( obj->refcount < INT_MAX );
 415     obj->refcount++;
 416     return obj;
 417 }
 418
 419 /* release an object (i.e. decrement its refcount) */
 420 void release_object( void *ptr )
 421 {
 422     struct object *obj = (struct object *)ptr;
 423     assert( obj->refcount );
 424     if (!--obj->refcount)
 425     {
 426         assert( !obj->handle_count );
 427         /* if the refcount is 0, nobody can be in the wait queue */
 428         assert( list_empty( &obj->wait_queue ));
 429         free_kernel_objects( obj );
 430         unlink_named_object( obj );
 431         obj->ops->destroy( obj );
 432         free_object( obj );
 433     }
 434 }
 435
 436 /* find an object by its name; the refcount is incremented */
 437 struct object *find_object( const struct namespace *namespace, const struct unicode_str *name,
 438                             unsigned int attributes )
 439 {
 440     const struct list *list;
 441     struct list *p;
 442
 443     if (!name || !name->len) return NULL;
 444
 445     list = &namespace->names[ hash_strW( name->str, name->len, namespace->hash_size ) ];
 446     LIST_FOR_EACH( p, list )
 447     {
 448         const struct object_name *ptr = LIST_ENTRY( p, struct object_name, entry );
 449         if (ptr->len != name->len) continue;
 450         if (attributes & OBJ_CASE_INSENSITIVE)
 451         {
 452             if (!memicmp_strW( ptr->name, name->str, name->len ))
 453                 return grab_object( ptr->obj );
 454         }
 455         else
 456         {
 457             if (!memcmp( ptr->name, name->str, name->len ))
 458                 return grab_object( ptr->obj );
 459         }
 460     }
 461     return NULL;
 462 }
 463
 464 /* find an object by its index; the refcount is incremented */
 465 struct object *find_object_index( const struct namespace *namespace, unsigned int index )
 466 {
 467     unsigned int i;
 468
 469     /* FIXME: not efficient at all */
 470     for (i = 0; i < namespace->hash_size; i++)
 471     {
 472         const struct object_name *ptr;
 473         LIST_FOR_EACH_ENTRY( ptr, &namespace->names[i], const struct object_name, entry )
 474         {
 475             if (!index--) return grab_object( ptr->obj );
 476         }
 477     }
 478     set_error( STATUS_NO_MORE_ENTRIES );
 479     return NULL;
 480 }
 481
 482 /* allocate a namespace */
 483 struct namespace *create_namespace( unsigned int hash_size )
 484 {
 485     struct namespace *namespace;
 486     unsigned int i;
 487
 488     namespace = mem_alloc( sizeof(*namespace) + (hash_size - 1) * sizeof(namespace->names[0]) );
 489     if (namespace)
 490     {
 491         namespace->hash_size      = hash_size;
 492         for (i = 0; i < hash_size; i++) list_init( &namespace->names[i] );
 493     }
 494     return namespace;
 495 }
 496
 497 /* functions for unimplemented/default object operations */
 498
 499 struct object_type *no_get_type( struct object *obj )
 500 {
 501     return NULL;
 502 }
 503
 504 int no_add_queue( struct object *obj, struct wait_queue_entry *entry )
 505 {
 506     set_error( STATUS_OBJECT_TYPE_MISMATCH );
 507     return 0;
 508 }
 509
 510 void no_satisfied( struct object *obj, struct wait_queue_entry *entry )
 511 {
 512 }
 513
 514 int no_signal( struct object *obj, unsigned int access )
 515 {
 516     set_error( STATUS_OBJECT_TYPE_MISMATCH );
 517     return 0;
 518 }
 519
 520 struct fd *no_get_fd( struct object *obj )
 521 {
 522     set_error( STATUS_OBJECT_TYPE_MISMATCH );
 523     return NULL;
 524 }
 525
 526 unsigned int no_map_access( struct object *obj, unsigned int access )
 527 {
 528     if (access & GENERIC_READ)    access |= STANDARD_RIGHTS_READ;
 529     if (access & GENERIC_WRITE)   access |= STANDARD_RIGHTS_WRITE;
 530     if (access & GENERIC_EXECUTE) access |= STANDARD_RIGHTS_EXECUTE;
 531     if (access & GENERIC_ALL)     access |= STANDARD_RIGHTS_ALL;
 532     return access & ~(GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE | GENERIC_ALL);
 533 }
 534
 535 struct security_descriptor *default_get_sd( struct object *obj )
 536 {
 537     return obj->sd;
 538 }
 539
 540 int set_sd_defaults_from_token( struct object *obj, const struct security_descriptor *sd,
 541                                 unsigned int set_info, struct token *token )
 542 {
 543     struct security_descriptor new_sd, *new_sd_ptr;
 544     int present;
 545     const SID *owner = NULL, *group = NULL;
 546     const ACL *sacl, *dacl;
 547     ACL *replaced_sacl = NULL;
 548     char *ptr;
 549
 550     if (!set_info) return 1;
 551
 552     new_sd.control = sd->control & ~SE_SELF_RELATIVE;
 553
 554     if (set_info & OWNER_SECURITY_INFORMATION && sd->owner_len)
 555     {
 556         owner = sd_get_owner( sd );
 557         new_sd.owner_len = sd->owner_len;
 558     }
 559     else if (obj->sd && obj->sd->owner_len)
 560     {
 561         owner = sd_get_owner( obj->sd );
 562         new_sd.owner_len = obj->sd->owner_len;
 563     }
 564     else if (token)
 565     {
 566         owner = token_get_user( token );
 567         new_sd.owner_len = security_sid_len( owner );
 568     }
 569     else new_sd.owner_len = 0;
 570
 571     if (set_info & GROUP_SECURITY_INFORMATION && sd->group_len)
 572     {
 573         group = sd_get_group( sd );
 574         new_sd.group_len = sd->group_len;
 575     }
 576     else if (obj->sd && obj->sd->group_len)
 577     {
 578         group = sd_get_group( obj->sd );
 579         new_sd.group_len = obj->sd->group_len;
 580     }
 581     else if (token)
 582     {
 583         group = token_get_primary_group( token );
 584         new_sd.group_len = security_sid_len( group );
 585     }
 586     else new_sd.group_len = 0;
 587
 588     sacl = sd_get_sacl( sd, &present );
 589     if (set_info & SACL_SECURITY_INFORMATION && present)
 590     {
 591         new_sd.control |= SE_SACL_PRESENT;
 592         new_sd.sacl_len = sd->sacl_len;
 593     }
 594     else if (set_info & LABEL_SECURITY_INFORMATION && present)
 595     {
 596         const ACL *old_sacl = NULL;
 597         if (obj->sd && obj->sd->control & SE_SACL_PRESENT) old_sacl = sd_get_sacl( obj->sd, &present );
 598         if (!(replaced_sacl = replace_security_labels( old_sacl, sacl ))) return 0;
 599         new_sd.control |= SE_SACL_PRESENT;
 600         new_sd.sacl_len = replaced_sacl->AclSize;
 601         sacl = replaced_sacl;
 602     }
 603     else
 604     {
 605         if (obj->sd) sacl = sd_get_sacl( obj->sd, &present );
 606
 607         if (obj->sd && present)
 608         {
 609             new_sd.control |= SE_SACL_PRESENT;
 610             new_sd.sacl_len = obj->sd->sacl_len;
 611         }
 612         else
 613             new_sd.sacl_len = 0;
 614     }
 615
 616     dacl = sd_get_dacl( sd, &present );
 617     if (set_info & DACL_SECURITY_INFORMATION && present)
 618     {
 619         new_sd.control |= SE_DACL_PRESENT;
 620         new_sd.dacl_len = sd->dacl_len;
 621     }
 622     else
 623     {
 624         if (obj->sd) dacl = sd_get_dacl( obj->sd, &present );
 625
 626         if (obj->sd && present)
 627         {
 628             new_sd.control |= SE_DACL_PRESENT;
 629             new_sd.dacl_len = obj->sd->dacl_len;
 630         }
 631         else if (token)
 632         {
 633             dacl = token_get_default_dacl( token );
 634             new_sd.control |= SE_DACL_PRESENT;
 635             new_sd.dacl_len = dacl->AclSize;
 636         }
 637         else new_sd.dacl_len = 0;
 638     }
 639
 640     ptr = mem_alloc( sizeof(new_sd) + new_sd.owner_len + new_sd.group_len +
 641                      new_sd.sacl_len + new_sd.dacl_len );
 642     if (!ptr)
 643     {
 644         free( replaced_sacl );
 645         return 0;
 646     }
 647     new_sd_ptr = (struct security_descriptor*)ptr;
 648
 649     memcpy( ptr, &new_sd, sizeof(new_sd) );
 650     ptr += sizeof(new_sd);
 651     memcpy( ptr, owner, new_sd.owner_len );
 652     ptr += new_sd.owner_len;
 653     memcpy( ptr, group, new_sd.group_len );
 654     ptr += new_sd.group_len;
 655     memcpy( ptr, sacl, new_sd.sacl_len );
 656     ptr += new_sd.sacl_len;
 657     memcpy( ptr, dacl, new_sd.dacl_len );
 658
 659     free( replaced_sacl );
 660     free( obj->sd );
 661     obj->sd = new_sd_ptr;
 662     return 1;
 663 }
 664
 665 /** Set the security descriptor using the current primary token for defaults. */
 666 int default_set_sd( struct object *obj, const struct security_descriptor *sd,
 667                     unsigned int set_info )
 668 {
 669     return set_sd_defaults_from_token( obj, sd, set_info, current->process->token );
 670 }
 671
 672 struct object *no_lookup_name( struct object *obj, struct unicode_str *name,
 673                                unsigned int attr )
 674 {
 675     if (!name) set_error( STATUS_OBJECT_TYPE_MISMATCH );
 676     return NULL;
 677 }
 678
 679 int no_link_name( struct object *obj, struct object_name *name, struct object *parent )
 680 {
 681     set_error( STATUS_OBJECT_TYPE_MISMATCH );
 682     return 0;
 683 }
 684
 685 void default_unlink_name( struct object *obj, struct object_name *name )
 686 {
 687     list_remove( &name->entry );
 688 }
 689
 690 struct object *no_open_file( struct object *obj, unsigned int access, unsigned int sharing,
 691                              unsigned int options )
 692 {
 693     set_error( STATUS_OBJECT_TYPE_MISMATCH );
 694     return NULL;
 695 }
 696
 697 int no_close_handle( struct object *obj, struct process *process, obj_handle_t handle )
 698 {
 699     return 1;  /* ok to close */
 700 }
 701
 702 void no_destroy( struct object *obj )
 703 {
 704 }