modules/access/sftp.c

   1 /*****************************************************************************
   2  * sftp.c: SFTP input module
   3  *****************************************************************************
   4  * Copyright (C) 2009 VLC authors and VideoLAN
   5  * $Id$
   6  *
   7  * Authors: Rémi Duraffort <ivoire@videolan.org>
   8  *          Petri Hintukainen <phintuka@gmail.com>
   9  *
  10  * This program is free software; you can redistribute it and/or modify it
  11  * under the terms of the GNU Lesser General Public License as published by
  12  * the Free Software Foundation; either version 2.1 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  18  * GNU Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public License
  21  * along with this program; if not, write to the Free Software Foundation,
  22  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23  *****************************************************************************/
  24
  25 /*****************************************************************************
  26  * Preamble
  27  *****************************************************************************/
  28 #ifdef HAVE_CONFIG_H
  29 # include "config.h"
  30 #endif
  31
  32 #include <vlc_common.h>
  33 #include <vlc_plugin.h>
  34
  35 #include <assert.h>
  36
  37 #include <vlc_access.h>
  38 #include <vlc_input_item.h>
  39 #include <vlc_network.h>
  40 #include <vlc_url.h>
  41 #include <vlc_keystore.h>
  42
  43 #include <libssh2.h>
  44 #include <libssh2_sftp.h>
  45
  46
  47 /*****************************************************************************
  48  * Module descriptor
  49  *****************************************************************************/
  50 static int  Open ( vlc_object_t* );
  51 static void Close( vlc_object_t* );
  52
  53 #define PORT_TEXT N_("SFTP port")
  54 #define PORT_LONGTEXT N_("SFTP port number to use on the server")
  55 #define USER_TEXT N_("Username")
  56 #define USER_LONGTEXT N_("Username that will be used for the connection, " \
  57         "if no username is set in the URL.")
  58 #define PASS_TEXT N_("Password")
  59 #define PASS_LONGTEXT N_("Password that will be used for the connection, " \
  60         "if no username or password are set in URL.")
  61
  62 vlc_module_begin ()
  63     set_shortname( "SFTP" )
  64     set_description( N_("SFTP input") )
  65     set_capability( "access", 0 )
  66     set_category( CAT_INPUT )
  67     set_subcategory( SUBCAT_INPUT_ACCESS )
  68     add_integer( "sftp-port", 22, PORT_TEXT, PORT_LONGTEXT, true )
  69     add_string( "sftp-user", NULL, USER_TEXT, USER_LONGTEXT, false )
  70     add_password( "sftp-pwd", NULL, PASS_TEXT, PASS_LONGTEXT, false )
  71     add_shortcut( "sftp" )
  72     set_callbacks( Open, Close )
  73 vlc_module_end ()
  74
  75
  76 /*****************************************************************************
  77  * Local prototypes
  78  *****************************************************************************/
  79 static ssize_t  Read( stream_t *, void *, size_t );
  80 static int      Seek( stream_t *, uint64_t );
  81 static int      Control( stream_t *, int, va_list );
  82
  83 static int DirRead( stream_t *, input_item_node_t * );
  84
  85 struct access_sys_t
  86 {
  87     int i_socket;
  88     LIBSSH2_SESSION* ssh_session;
  89     LIBSSH2_SFTP* sftp_session;
  90     LIBSSH2_SFTP_HANDLE* file;
  91     uint64_t filesize;
  92     char *psz_base_url;
  93 };
  94
  95 static int AuthKeyAgent( stream_t *p_access, const char *psz_username )
  96 {
  97     access_sys_t* p_sys = p_access->p_sys;
  98     int i_result = VLC_EGENERIC;
  99     LIBSSH2_AGENT *p_sshagent = NULL;
 100     struct libssh2_agent_publickey *p_identity = NULL,
 101                                    *p_prev_identity = NULL;
 102
 103     if( !psz_username || !psz_username[0] )
 104         return i_result;
 105
 106     p_sshagent = libssh2_agent_init( p_sys->ssh_session );
 107
 108     if( !p_sshagent )
 109     {
 110         msg_Dbg( p_access, "Failed to initialize key agent" );
 111         goto bailout;
 112     }
 113     if( libssh2_agent_connect( p_sshagent ) )
 114     {
 115         msg_Dbg( p_access, "Failed to connect key agent" );
 116         goto bailout;
 117     }
 118     if( libssh2_agent_list_identities( p_sshagent ) )
 119     {
 120         msg_Dbg( p_access, "Failed to request identities" );
 121         goto bailout;
 122     }
 123
 124     while( libssh2_agent_get_identity( p_sshagent, &p_identity, p_prev_identity ) == 0 )
 125     {
 126         msg_Dbg( p_access, "Using key %s", p_identity->comment );
 127         if( libssh2_agent_userauth( p_sshagent, psz_username, p_identity ) == 0 )
 128         {
 129             msg_Info( p_access, "Public key agent authentication succeeded" );
 130             i_result = VLC_SUCCESS;
 131             goto bailout;
 132         }
 133         msg_Dbg( p_access, "Public key agent authentication failed" );
 134         p_prev_identity = p_identity;
 135     }
 136
 137 bailout:
 138     if( p_sshagent )
 139     {
 140         libssh2_agent_disconnect( p_sshagent );
 141         libssh2_agent_free( p_sshagent );
 142     }
 143     return i_result;
 144 }
 145
 146
 147 static int AuthPublicKey( stream_t *p_access, const char *psz_home, const char *psz_username )
 148 {
 149     access_sys_t* p_sys = p_access->p_sys;
 150     int i_result = VLC_EGENERIC;
 151     char *psz_keyfile1 = NULL;
 152     char *psz_keyfile2 = NULL;
 153
 154     if( !psz_username || !psz_username[0] )
 155         return i_result;
 156
 157     if( asprintf( &psz_keyfile1, "%s/.ssh/id_rsa.pub", psz_home ) == -1 ||
 158         asprintf( &psz_keyfile2, "%s/.ssh/id_rsa",     psz_home ) == -1 )
 159         goto bailout;
 160
 161     if( libssh2_userauth_publickey_fromfile( p_sys->ssh_session, psz_username, psz_keyfile1, psz_keyfile2, NULL ) )
 162     {
 163         msg_Dbg( p_access, "Public key authentication failed" );
 164         goto bailout;
 165     }
 166
 167     msg_Info( p_access, "Public key authentication succeeded" );
 168     i_result = VLC_SUCCESS;
 169
 170  bailout:
 171     free( psz_keyfile1 );
 172     free( psz_keyfile2 );
 173     return i_result;
 174 }
 175
 176 static void SSHSessionDestroy( stream_t *p_access )
 177 {
 178     access_sys_t* p_sys = p_access->p_sys;
 179
 180     if( p_sys->ssh_session )
 181     {
 182         libssh2_session_free( p_sys->ssh_session );
 183         p_sys->ssh_session = NULL;
 184     }
 185     if( p_sys->i_socket >= 0 )
 186     {
 187         net_Close( p_sys->i_socket );
 188         p_sys->i_socket = -1;
 189     }
 190 }
 191
 192 static int SSHSessionInit( stream_t *p_access, const char *psz_host, int i_port )
 193 {
 194     access_sys_t* p_sys = p_access->p_sys;
 195
 196     /* Connect to the server using a regular socket */
 197     assert( p_sys->i_socket == -1 );
 198     p_sys->i_socket = net_ConnectTCP( p_access, psz_host, i_port );
 199     if( p_sys->i_socket < 0 )
 200         goto error;
 201
 202     /* Create the ssh connexion and wait until the server answer */
 203     p_sys->ssh_session = libssh2_session_init();
 204     if( p_sys->ssh_session == NULL )
 205         goto error;
 206
 207     int i_ret;
 208     while( ( i_ret = libssh2_session_startup( p_sys->ssh_session, p_sys->i_socket ) )
 209            == LIBSSH2_ERROR_EAGAIN );
 210
 211     if( i_ret != 0 )
 212         goto error;
 213
 214     /* Set the socket in non-blocking mode */
 215     libssh2_session_set_blocking( p_sys->ssh_session, 1 );
 216     return VLC_SUCCESS;
 217
 218 error:
 219     msg_Err( p_access, "Impossible to open the connection to %s:%i",
 220              psz_host, i_port );
 221     SSHSessionDestroy( p_access );
 222     return VLC_EGENERIC;
 223 }
 224
 225 /**
 226  * Connect to the sftp server and ask for a file
 227  * @param p_this: the vlc_object
 228  * @return VLC_SUCCESS if everything was fine
 229  */
 230 static int Open( vlc_object_t* p_this )
 231 {
 232     stream_t*   p_access = (stream_t*)p_this;
 233     access_sys_t* p_sys;
 234     vlc_url_t credential_url;
 235     vlc_credential credential;
 236     const char* psz_path;
 237     char *psz_session_username = NULL;
 238     char* psz_remote_home = NULL;
 239     char* psz_home = NULL;
 240     int i_port;
 241     vlc_url_t url;
 242     size_t i_len;
 243     int i_type;
 244     int i_result = VLC_EGENERIC;
 245
 246     if( !p_access->psz_location )
 247         return VLC_EGENERIC;
 248
 249     p_sys = p_access->p_sys = vlc_obj_calloc( p_this, 1, sizeof( access_sys_t ) );
 250     if( !p_sys ) return VLC_ENOMEM;
 251
 252     p_sys->i_socket = -1;
 253
 254     vlc_UrlParse( &credential_url, p_access->psz_url );
 255     vlc_credential_init( &credential, &credential_url );
 256
 257     /* Parse the URL */
 258     vlc_UrlParse( &url, p_access->psz_url );
 259     vlc_uri_decode( url.psz_path );
 260
 261     /* Check for some parameters */
 262     if( EMPTY_STR( url.psz_host ) )
 263     {
 264         msg_Err( p_access, "Unable to extract host from %s", p_access->psz_url );
 265         goto error;
 266     }
 267
 268     if( url.i_port <= 0 )
 269         i_port = var_InheritInteger( p_access, "sftp-port" );
 270     else
 271         i_port = url.i_port;
 272
 273     /* Create the ssh connexion and wait until the server answer */
 274     if( SSHSessionInit( p_access, url.psz_host, i_port ) != VLC_SUCCESS )
 275         goto error;
 276
 277     /* List the know hosts */
 278     LIBSSH2_KNOWNHOSTS *ssh_knownhosts = libssh2_knownhost_init( p_sys->ssh_session );
 279     if( !ssh_knownhosts )
 280         goto error;
 281
 282     psz_home = config_GetUserDir( VLC_HOME_DIR );
 283     char *psz_knownhosts_file;
 284     if( asprintf( &psz_knownhosts_file, "%s/.ssh/known_hosts", psz_home ) != -1 )
 285     {
 286         libssh2_knownhost_readfile( ssh_knownhosts, psz_knownhosts_file,
 287                 LIBSSH2_KNOWNHOST_FILE_OPENSSH );
 288         free( psz_knownhosts_file );
 289     }
 290
 291     const char *fingerprint = libssh2_session_hostkey( p_sys->ssh_session, &i_len, &i_type );
 292     struct libssh2_knownhost *host;
 293     int knownhost_fingerprint_algo;
 294
 295     switch( i_type )
 296     {
 297         case LIBSSH2_HOSTKEY_TYPE_RSA:
 298             knownhost_fingerprint_algo = LIBSSH2_KNOWNHOST_KEY_SSHRSA;
 299             break;
 300
 301         case LIBSSH2_HOSTKEY_TYPE_DSS:
 302             knownhost_fingerprint_algo = LIBSSH2_KNOWNHOST_KEY_SSHDSS;
 303             break;
 304
 305         default:
 306             msg_Err( p_access, "Host uses unrecognized session-key algorithm" );
 307             libssh2_knownhost_free( ssh_knownhosts );
 308             goto error;
 309
 310     }
 311
 312     int check = libssh2_knownhost_check( ssh_knownhosts, url.psz_host,
 313                                          fingerprint, i_len,
 314                                          LIBSSH2_KNOWNHOST_TYPE_PLAIN |
 315                                          LIBSSH2_KNOWNHOST_KEYENC_RAW |
 316                                          knownhost_fingerprint_algo,
 317                                          &host );
 318
 319     libssh2_knownhost_free( ssh_knownhosts );
 320
 321     /* Check that it does match or at least that the host is unknown */
 322     switch(check)
 323     {
 324     case LIBSSH2_KNOWNHOST_CHECK_FAILURE:
 325     case LIBSSH2_KNOWNHOST_CHECK_NOTFOUND:
 326         msg_Dbg( p_access, "Unable to check the remote host" );
 327         break;
 328     case LIBSSH2_KNOWNHOST_CHECK_MATCH:
 329         msg_Dbg( p_access, "Succesfuly matched the host" );
 330         break;
 331     case LIBSSH2_KNOWNHOST_CHECK_MISMATCH:
 332         msg_Err( p_access, "The host does not match !! The remote key changed !!" );
 333         goto error;
 334     }
 335
 336     vlc_credential_get( &credential, p_access, "sftp-user", "sftp-pwd",
 337                         NULL, NULL );
 338     char* psz_userauthlist = NULL;
 339     bool b_publickey_tried = false;
 340     do
 341     {
 342         if (!credential.psz_username || !credential.psz_username[0])
 343             continue;
 344
 345         if( !psz_session_username )
 346         {
 347             psz_session_username = strdup( credential.psz_username );
 348             psz_userauthlist =
 349                 libssh2_userauth_list( p_sys->ssh_session, credential.psz_username,
 350                                        strlen( credential.psz_username ) );
 351         }
 352         else if( strcmp( psz_session_username, credential.psz_username ) != 0 )
 353         {
 354             msg_Warn( p_access, "The username changed, starting a new ssh session" );
 355
 356             SSHSessionDestroy( p_access );
 357             if( SSHSessionInit( p_access, url.psz_host, i_port ) != VLC_SUCCESS )
 358                 goto error;
 359
 360             b_publickey_tried = false;
 361             free( psz_session_username );
 362             psz_session_username = strdup( credential.psz_username );
 363             psz_userauthlist =
 364                 libssh2_userauth_list( p_sys->ssh_session, credential.psz_username,
 365                                        strlen( credential.psz_username ) );
 366         }
 367         if( !psz_session_username || !psz_userauthlist )
 368             goto error;
 369
 370         /* TODO: Follow PreferredAuthentications in ssh_config */
 371
 372         if( strstr( psz_userauthlist, "publickey" ) != NULL && !b_publickey_tried )
 373         {
 374             /* Don't try public key multiple times to avoid getting black
 375              * listed */
 376             b_publickey_tried = true;
 377             if( AuthKeyAgent( p_access, credential.psz_username ) == VLC_SUCCESS
 378              || AuthPublicKey( p_access, psz_home, credential.psz_username ) == VLC_SUCCESS )
 379                 break;
 380         }
 381
 382         if( strstr( psz_userauthlist, "password" ) != NULL
 383          && credential.psz_password != NULL
 384          && libssh2_userauth_password( p_sys->ssh_session,
 385                                        credential.psz_username,
 386                                        credential.psz_password ) == 0 )
 387         {
 388             vlc_credential_store( &credential, p_access );
 389             break;
 390         }
 391
 392         msg_Warn( p_access, "sftp auth failed for %s", credential.psz_username );
 393     } while( vlc_credential_get( &credential, p_access, "sftp-user", "sftp-pwd",
 394                                 _("SFTP authentication"),
 395                                 _("Please enter a valid login and password for "
 396                                 "the sftp connexion to %s"), url.psz_host ) );
 397
 398     /* Create the sftp session */
 399     p_sys->sftp_session = libssh2_sftp_init( p_sys->ssh_session );
 400
 401     if( !p_sys->sftp_session )
 402     {
 403         msg_Err( p_access, "Unable to initialize the SFTP session" );
 404         goto error;
 405     }
 406
 407     /* No path, default to user Home */
 408     if( !url.psz_path )
 409     {
 410         const size_t i_size = 1024;
 411         int i_read;
 412
 413         psz_remote_home = malloc( i_size );
 414         if( !psz_remote_home )
 415             goto error;
 416
 417         i_read = libssh2_sftp_symlink_ex( p_sys->sftp_session, ".", 1,
 418                                           psz_remote_home, i_size - 1,
 419                                           LIBSSH2_SFTP_REALPATH );
 420         if( i_read <= 0 )
 421         {
 422             msg_Err( p_access, "Impossible to get the Home directory" );
 423             goto error;
 424         }
 425         psz_remote_home[i_read] = '\0';
 426         psz_path = psz_remote_home;
 427
 428         /* store base url for directory read */
 429         char *base = vlc_path2uri( psz_path, "sftp" );
 430         if( !base )
 431             goto error;
 432         if( -1 == asprintf( &p_sys->psz_base_url, "sftp://%s%s", p_access->psz_location, base + 7 ) )
 433         {
 434             free( base );
 435             goto error;
 436         }
 437         free( base );
 438     }
 439     else
 440         psz_path = url.psz_path;
 441
 442     /* Get some information */
 443     LIBSSH2_SFTP_ATTRIBUTES attributes;
 444     if( libssh2_sftp_stat( p_sys->sftp_session, psz_path, &attributes ) )
 445     {
 446         msg_Err( p_access, "Impossible to get information about the remote path %s", psz_path );
 447         goto error;
 448     }
 449
 450     if( !LIBSSH2_SFTP_S_ISDIR( attributes.permissions ))
 451     {
 452         /* Open the given file */
 453         p_sys->file = libssh2_sftp_open( p_sys->sftp_session, psz_path, LIBSSH2_FXF_READ, 0 );
 454         p_sys->filesize = attributes.filesize;
 455
 456         ACCESS_SET_CALLBACKS( Read, NULL, Control, Seek );
 457     }
 458     else
 459     {
 460         /* Open the given directory */
 461         p_sys->file = libssh2_sftp_opendir( p_sys->sftp_session, psz_path );
 462
 463         p_access->pf_readdir = DirRead;
 464         p_access->pf_control = access_vaDirectoryControlHelper;
 465
 466         if( !p_sys->psz_base_url )
 467         {
 468             if( asprintf( &p_sys->psz_base_url, "sftp://%s", p_access->psz_location ) == -1 )
 469                 goto error;
 470
 471             /* trim trailing '/' */
 472             size_t len = strlen( p_sys->psz_base_url );
 473             if( len > 0 && p_sys->psz_base_url[ len - 1 ] == '/' )
 474                 p_sys->psz_base_url[ len - 1 ] = 0;
 475         }
 476     }
 477
 478     if( !p_sys->file )
 479     {
 480         msg_Err( p_access, "Unable to open the remote path %s", psz_path );
 481         goto error;
 482     }
 483
 484     i_result = VLC_SUCCESS;
 485
 486 error:
 487     free( psz_home );
 488     free( psz_remote_home );
 489     free( psz_session_username );
 490     vlc_UrlClean( &url );
 491     vlc_credential_clean( &credential );
 492     vlc_UrlClean( &credential_url );
 493     if( i_result != VLC_SUCCESS ) {
 494         Close( p_this );
 495     }
 496     return i_result;
 497 }
 498
 499
 500 /* Close: quit the module */
 501 static void Close( vlc_object_t* p_this )
 502 {
 503     stream_t*   p_access = (stream_t*)p_this;
 504     access_sys_t* p_sys = p_access->p_sys;
 505
 506     if( p_sys->file )
 507         libssh2_sftp_close_handle( p_sys->file );
 508     if( p_sys->sftp_session )
 509         libssh2_sftp_shutdown( p_sys->sftp_session );
 510     SSHSessionDestroy( p_access );
 511
 512     free( p_sys->psz_base_url );
 513 }
 514
 515
 516 static ssize_t Read( stream_t *p_access, void *buf, size_t len )
 517 {
 518     access_sys_t *p_sys = p_access->p_sys;
 519
 520     ssize_t val = libssh2_sftp_read(  p_sys->file, buf, len );
 521     if( val < 0 )
 522     {
 523         msg_Err( p_access, "read failed" );
 524         return 0;
 525     }
 526
 527     return val;
 528 }
 529
 530
 531 static int Seek( stream_t* p_access, uint64_t i_pos )
 532 {
 533     access_sys_t *sys = p_access->p_sys;
 534
 535     libssh2_sftp_seek( sys->file, i_pos );
 536     return VLC_SUCCESS;
 537 }
 538
 539
 540 static int Control( stream_t* p_access, int i_query, va_list args )
 541 {
 542     access_sys_t *sys = p_access->p_sys;
 543     bool*       pb_bool;
 544     int64_t*    pi_64;
 545
 546     switch( i_query )
 547     {
 548     case STREAM_CAN_SEEK:
 549         pb_bool = va_arg( args, bool * );
 550         *pb_bool = true;
 551         break;
 552
 553     case STREAM_CAN_FASTSEEK:
 554         pb_bool = va_arg( args, bool * );
 555         *pb_bool = false;
 556         break;
 557
 558     case STREAM_CAN_PAUSE:
 559     case STREAM_CAN_CONTROL_PACE:
 560         pb_bool = va_arg( args, bool * );
 561         *pb_bool = true;
 562         break;
 563
 564     case STREAM_GET_SIZE:
 565         if( p_access->pf_readdir != NULL )
 566             return VLC_EGENERIC;
 567         *va_arg( args, uint64_t * ) = sys->filesize;
 568         break;
 569
 570     case STREAM_GET_PTS_DELAY:
 571         pi_64 = va_arg( args, int64_t * );
 572         *pi_64 = INT64_C(1000)
 573                * var_InheritInteger( p_access, "network-caching" );
 574         break;
 575
 576     case STREAM_SET_PAUSE_STATE:
 577         break;
 578
 579     default:
 580         return VLC_EGENERIC;
 581     }
 582
 583     return VLC_SUCCESS;
 584 }
 585
 586
 587 /*****************************************************************************
 588  * Directory access
 589  *****************************************************************************/
 590
 591 static int DirRead (stream_t *p_access, input_item_node_t *p_current_node)
 592 {
 593     access_sys_t *p_sys = p_access->p_sys;
 594     LIBSSH2_SFTP_ATTRIBUTES attrs;
 595     int i_ret = VLC_SUCCESS;
 596     int err;
 597     /* Allocate 1024 bytes for file name. Longer names are skipped.
 598      * libssh2 does not support seeking in directory streams.
 599      * Retrying with larger buffer is possible, but would require
 600      * re-opening the directory stream.
 601      */
 602     size_t i_size = 1024;
 603     char *psz_file = malloc( i_size );
 604
 605     if( !psz_file )
 606         return VLC_ENOMEM;
 607
 608     struct vlc_readdir_helper rdh;
 609     vlc_readdir_helper_init( &rdh, p_access, p_current_node );
 610
 611     while( i_ret == VLC_SUCCESS
 612         && 0 != ( err = libssh2_sftp_readdir( p_sys->file, psz_file, i_size, &attrs ) ) )
 613     {
 614         if( err < 0 )
 615         {
 616             if( err == LIBSSH2_ERROR_BUFFER_TOO_SMALL )
 617             {
 618                 /* seeking back is not possible ... */
 619                 msg_Dbg( p_access, "skipped too long file name" );
 620                 continue;
 621             }
 622             if( err == LIBSSH2_ERROR_EAGAIN )
 623             {
 624                 continue;
 625             }
 626             msg_Err( p_access, "directory read failed" );
 627             break;
 628         }
 629
 630         /* Create an input item for the current entry */
 631
 632         char *psz_full_uri, *psz_uri;
 633
 634         psz_uri = vlc_uri_encode( psz_file );
 635         if( psz_uri == NULL )
 636         {
 637             i_ret = VLC_ENOMEM;
 638             break;
 639         }
 640
 641         if( asprintf( &psz_full_uri, "%s/%s", p_sys->psz_base_url, psz_uri ) == -1 )
 642         {
 643             free( psz_uri );
 644             i_ret = VLC_ENOMEM;
 645             break;
 646         }
 647         free( psz_uri );
 648
 649         int i_type = LIBSSH2_SFTP_S_ISDIR( attrs.permissions ) ? ITEM_TYPE_DIRECTORY : ITEM_TYPE_FILE;
 650         i_ret = vlc_readdir_helper_additem( &rdh, psz_full_uri, NULL, psz_file,
 651                                             i_type, ITEM_NET );
 652         free( psz_full_uri );
 653     }
 654
 655     vlc_readdir_helper_finish( &rdh, i_ret == VLC_SUCCESS );
 656     free( psz_file );
 657     return i_ret;
 658 }