开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Ftp客户端 > 查看源码
local.c
资源名称：FTP总集.rar　[点击查看]
上传用户：tjfeida
上传日期：2013-03-10
资源大小：1917k
文件大小：19k
源码类别：

Ftp客户端

开发平台：

Visual C++

local.c：源码内容
  1. /*****************************************************************************/
  2. /*  local.c - functions that will use the local system                       */
  3. /*  Copyright (C) 1998-2002 Brian Masney <masneyb@gftp.org>                  */
  4. /*                                                                           */
  5. /*  This program is free software; you can redistribute it and/or modify     */
  6. /*  it under the terms of the GNU General Public License as published by     */
  7. /*  the Free Software Foundation; either version 2 of the License, or        */
  8. /*  (at your option) any later version.                                      */
  9. /*                                                                           */
  10. /*  This program is distributed in the hope that it will be useful,          */
  11. /*  but WITHOUT ANY WARRANTY; without even the implied warranty of           */
  12. /*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the            */
  13. /*  GNU General Public License for more details.                             */
  14. /*                                                                           */
  15. /*  You should have received a copy of the GNU General Public License        */
  16. /*  along with this program; if not, write to the Free Software              */
  17. /*  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111 USA      */
  18. /*****************************************************************************/
  20. #include "gftp.h"
  21. static const char cvsid[] = "$Id: local.c,v 1.13 2002/11/27 02:23:51 masneyb Exp $";
  23. typedef struct local_protocol_data_tag
  24. {
  25.   DIR *dir;
  26.   GHashTable *userhash, *grouphash;
  27. } local_protocol_data;
  30. static void
  31. local_remove_key (gpointer key, gpointer value, gpointer user_data)
  32. {
  33.   g_free (value);
  34. }
  37. static void
  38. local_destroy (gftp_request * request)
  39. {
  40.   local_protocol_data * lpd;
  42.   g_return_if_fail (request != NULL);
  43.   g_return_if_fail (request->protonum == GFTP_LOCAL_NUM);
  45.   lpd = request->protocol_data;
  46.   g_hash_table_foreach (lpd->userhash, local_remove_key, NULL);
  47.   g_hash_table_destroy (lpd->userhash);
  48.   g_hash_table_foreach (lpd->grouphash, local_remove_key, NULL);
  49.   g_hash_table_destroy (lpd->grouphash);
  50.   lpd->userhash = lpd->grouphash = NULL;
  51. }
  54. static int
  55. local_connect (gftp_request * request)
  56. {
  57.   char tempstr[PATH_MAX];
  59.   g_return_val_if_fail (request != NULL, -2);
  60.   g_return_val_if_fail (request->protonum == GFTP_LOCAL_NUM, -2);
  62.   if (request->directory)
  63.     {
  64.       if (chdir (request->directory) != 0)
  65.         {
  66.           request->logging_function (gftp_logging_error, request->user_data,
  67.                              _("Could not change local directory to %s: %sn"),
  68.                              request->directory, g_strerror (errno));
  69.         }
  70.       g_free (request->directory);
  71.       request->directory = NULL;
  72.     }
  74.   if (getcwd (tempstr, sizeof (tempstr)) != NULL)
  75.     {
  76.       tempstr[sizeof (tempstr) - 1] = '';
  77.       request->directory = g_malloc (strlen (tempstr) + 1);
  78.       strcpy (request->directory, tempstr);
  79.     }
  80.   else
  81.     request->logging_function (gftp_logging_error, request->user_data,
  82.                              _("Could not get current working directory: %sn"),
  83.                              g_strerror (errno));
  85.   return (0);
  86. }
  89. static void
  90. local_disconnect (gftp_request * request)
  91. {
  92.   g_return_if_fail (request != NULL);
  93.   g_return_if_fail (request->protonum == GFTP_LOCAL_NUM);
  95.   if (request->datafd != -1)
  96.     {
  97.       if (close (request->datafd) < 0)
  98.         request->logging_function (gftp_logging_error, request->user_data,
  99.                                    _("Error closing file descriptor: %sn"),
  100.                                    g_strerror (errno));
  101.       request->datafd = -1;
  102.     }
  103. }
  106. static off_t
  107. local_get_file (gftp_request * request, const char *filename, int fd,
  108.                 off_t startsize)
  109. {
  110.   off_t size;
  111.   int flags;
  113.   g_return_val_if_fail (request != NULL, -2);
  114.   g_return_val_if_fail (request->protonum == GFTP_LOCAL_NUM, -2);
  115.   g_return_val_if_fail (filename != NULL, -2);
  117.   if (fd <= 0)
  118.     {
  119.       flags = O_RDONLY;
  120. #if defined (_LARGEFILE_SOURCE)
  121.       flags |= O_LARGEFILE;
  122. #endif
  124.       if ((request->datafd = open (filename, flags)) < 0)
  125.         {
  126.           request->logging_function (gftp_logging_error, request->user_data,
  127.                                    _("Error: Cannot open local file %s: %sn"),
  128.                                    filename, g_strerror (errno));
  129.           return (-2);
  130.         }
  131.     }
  132.   else
  133.     request->datafd = fd;
  135.   if ((size = lseek (request->datafd, 0, SEEK_END)) == -1)
  136.     {
  137.       request->logging_function (gftp_logging_error, request->user_data,
  138.                                  _("Error: Cannot seek on file %s: %sn"),
  139.                                  filename, g_strerror (errno));
  140.       gftp_disconnect (request);
  141.       return (-1);
  142.     }
  144.   if (lseek (request->datafd, startsize, SEEK_SET) == -1)
  145.     {
  146.       request->logging_function (gftp_logging_error, request->user_data,
  147.                                  _("Error: Cannot seek on file %s: %sn"),
  148.                                  filename, g_strerror (errno));
  149.       gftp_disconnect (request);
  150.       return (-1);
  151.     }
  153.   return (size);
  154. }
  157. static int
  158. local_put_file (gftp_request * request, const char *filename, int fd,
  159.                 off_t startsize, off_t totalsize)
  160. {
  161.   int flags;
  163.   g_return_val_if_fail (request != NULL, -2);
  164.   g_return_val_if_fail (request->protonum == GFTP_LOCAL_NUM, -2);
  165.   g_return_val_if_fail (filename != NULL, -2);
  167.   if (fd <= 0)
  168.     {
  169.       flags = O_WRONLY | O_CREAT;
  170.       if (startsize > 0)
  171.          flags |= O_APPEND;
  172. #if defined (_LARGEFILE_SOURCE)
  173.       flags |= O_LARGEFILE;
  174. #endif
  176.       if ((request->datafd = open (filename, flags, S_IRUSR | S_IWUSR)) < 0)
  177.         {
  178.           request->logging_function (gftp_logging_error, request->user_data,
  179.                                    _("Error: Cannot open local file %s: %sn"),
  180.                                    filename, g_strerror (errno));
  181.           return (-2);
  182.         }
  183.     }
  184.   else
  185.     request->datafd = fd;
  187.   if (ftruncate (request->datafd, startsize) == -1)
  188.     {
  189.       request->logging_function (gftp_logging_error, request->user_data,
  190.                                _("Error: Cannot truncate local file %s: %sn"),
  191.                                filename, g_strerror (errno));
  192.       gftp_disconnect (request);
  193.       return (-1);
  194.     }
  195.     
  196.   if (lseek (request->datafd, startsize, SEEK_SET) == -1)
  197.     {
  198.       request->logging_function (gftp_logging_error, request->user_data,
  199.                                  _("Error: Cannot seek on file %s: %sn"),
  200.                                  filename, g_strerror (errno));
  201.       gftp_disconnect (request);
  202.       return (-2);
  203.     }
  204.   return (0);
  205. }
  208. static int
  209. local_end_transfer (gftp_request * request)
  210. {
  211.   local_protocol_data * lpd;
  213.   lpd = request->protocol_data;
  214.   if (lpd->dir)
  215.     {
  216.       closedir (lpd->dir);
  217.       lpd->dir = NULL;
  218.     }
  220.   if (request->datafd > 0)
  221.     {
  222.       if (close (request->datafd) < 0)
  223.         request->logging_function (gftp_logging_error, request->user_data,
  224.                                    _("Error closing file descriptor: %sn"),
  225.                                    g_strerror (errno));
  227.       request->datafd = -1;
  228.     }
  230.   return (0);
  231. }
  234. static char *
  235. make_text_mode (gftp_file * fle, mode_t mode)
  236. {
  237.   char *str;
  239.   str = g_malloc0 (11);
  240.   
  241.   str[0] = '?';
  242.   if (S_ISREG (mode))
  243.     str[0] = '-';
  245.   if (S_ISLNK (mode))
  246.     {
  247.       fle->islink = 1; 
  248.       str[0] = 'l';
  249.     }
  251.   if (S_ISBLK (mode))
  252.      {
  253.        fle->isblock = 1;
  254.        str[0] = 'b';
  255.      }
  257.   if (S_ISCHR (mode))
  258.      {
  259.        fle->ischar = 1;
  260.        str[0] = 'c';
  261.     }
  263.   if (S_ISFIFO (mode))
  264.     {
  265.       fle->isfifo = 1;
  266.       str[0] = 'p';
  267.     }
  269.   if (S_ISSOCK (mode))
  270.     {
  271.       fle->issocket = 1;
  272.       str[0] = 's';
  273.     }
  275.   if (S_ISDIR (mode))
  276.     {
  277.       fle->isdir = 1;
  278.       str[0] = 'd';
  279.     }
  281.   str[1] = mode & S_IRUSR ? 'r' : '-';
  282.   str[2] = mode & S_IWUSR ? 'w' : '-';
  284.   if ((mode & S_ISUID) && (mode & S_IXUSR))
  285.     str[3] = 's';
  286.   else if (mode & S_ISUID)
  287.     str[3] = 'S';
  288.   else if (mode & S_IXUSR)
  289.     str[3] = 'x';
  290.   else
  291.     str[3] = '-';
  292.     
  293.   str[4] = mode & S_IRGRP ? 'r' : '-';
  294.   str[5] = mode & S_IWGRP ? 'w' : '-';
  296.   if ((mode & S_ISGID) && (mode & S_IXGRP))
  297.     str[6] = 's';
  298.   else if (mode & S_ISGID)
  299.     str[6] = 'S';
  300.   else if (mode & S_IXGRP)
  301.     str[6] = 'x';
  302.   else
  303.     str[6] = '-';
  305.   str[7] = mode & S_IROTH ? 'r' : '-';
  306.   str[8] = mode & S_IWOTH ? 'w' : '-';
  308.   if ((mode & S_ISVTX) && (mode & S_IXOTH))
  309.     str[9] = 't';
  310.   else if (mode & S_ISVTX)
  311.     str[9] = 'T';
  312.   else if (mode & S_IXOTH)
  313.     str[9] = 'x';
  314.   else
  315.     str[9] = '-';
  316.   return (str);
  317. }
  320. static int
  321. local_get_next_file (gftp_request * request, gftp_file * fle, int fd)
  322. {
  323.   local_protocol_data * lpd;
  324.   struct dirent *dirp;
  325.   char *user, *group;
  326.   struct passwd *pw;
  327.   struct group *gr;
  328.   struct stat st;
  330.   /* the struct passwd and struct group are not thread safe. But,
  331.      we're ok here because I have threading turned off for the local
  332.      protocol (see use_threads in local_init above) */
  333.   g_return_val_if_fail (request != NULL, -2);
  334.   g_return_val_if_fail (request->protonum == GFTP_LOCAL_NUM, -2);
  335.   g_return_val_if_fail (fle != NULL, -2);
  337.   lpd = request->protocol_data;
  338.   memset (fle, 0, sizeof (*fle));
  340.   if ((dirp = readdir (lpd->dir)) == NULL)
  341.     {
  342.       closedir (lpd->dir);
  343.       lpd->dir = NULL;
  344.       return (-2);
  345.     }
  347.   fle->file = g_malloc (strlen (dirp->d_name) + 1);
  348.   strcpy (fle->file, dirp->d_name);
  349.   if (lstat (fle->file, &st) != 0)
  350.     {
  351.       closedir (lpd->dir);
  352.       lpd->dir = NULL;
  353.       return (-2);
  354.     }
  356.   if ((user = g_hash_table_lookup (lpd->userhash, 
  357.                                    GUINT_TO_POINTER(st.st_uid))) != NULL)
  358.     {
  359.       fle->user = g_malloc (strlen (user) + 1);
  360.       strcpy (fle->user, user);
  361.     }
  362.   else
  363.     {
  364.       if ((pw = getpwuid (st.st_uid)) == NULL)
  365.         fle->user = g_strdup_printf ("%u", st.st_uid); 
  366.       else
  367.         {
  368.           fle->user = g_malloc (strlen (pw->pw_name) + 1);
  369.           strcpy (fle->user, pw->pw_name);
  370.         }
  372.       user = g_malloc (strlen (fle->user) + 1);
  373.       strcpy (user, fle->user);
  374.       g_hash_table_insert (lpd->userhash, GUINT_TO_POINTER (st.st_uid), user);
  375.     }
  377.   if ((group = g_hash_table_lookup (lpd->grouphash, 
  378.                                     GUINT_TO_POINTER(st.st_gid))) != NULL)
  379.     {
  380.       fle->group = g_malloc (strlen (group) + 1);
  381.       strcpy (fle->group, group);
  382.     }
  383.   else
  384.     {
  385.       if ((gr = getgrgid (st.st_gid)) == NULL)
  386.         fle->group = g_strdup_printf ("%u", st.st_gid); 
  387.       else
  388.         {
  389.           fle->group = g_malloc (strlen (gr->gr_name) + 1);
  390.           strcpy (fle->group, gr->gr_name);
  391.         }
  393.       group = g_malloc (strlen (fle->group) + 1);
  394.       strcpy (group, fle->group);
  395.       g_hash_table_insert (lpd->grouphash, GUINT_TO_POINTER (st.st_gid), group);
  396.     }
  398.   fle->attribs = make_text_mode (fle, st.st_mode);
  399.   fle->datetime = st.st_mtime;
  401.   if ((fle->attribs[0] == 'b' || fle->attribs[0] == 'u' ||
  402.        fle->attribs[0] == 'c'))
  403.     fle->size = (off_t) st.st_rdev;
  404.   else
  405.     fle->size = st.st_size;
  407.   if (*fle->attribs == 'd')
  408.     fle->isdir = 1;
  409.   if (*fle->attribs == 'l')
  410.     fle->islink = 1;
  411.   if (strchr (fle->attribs, 'x') != NULL && !fle->isdir && !fle->islink)
  412.     fle->isexe = 1;
  413.   if (*fle->attribs == 'b')
  414.     fle->isblock = 1;
  415.   if (*fle->attribs == 'c')
  416.     fle->ischar = 1;
  417.   if (*fle->attribs == 's')
  418.     fle->issocket = 1;
  419.   if (*fle->attribs == 'p')
  420.     fle->isfifo = 1;
  421.   return (1);
  422. }
  425. static int
  426. local_list_files (gftp_request * request)
  427. {
  428.   local_protocol_data *lpd;
  429.   char *tempstr;
  431.   g_return_val_if_fail (request != NULL, -2);
  432.   g_return_val_if_fail (request->protonum == GFTP_LOCAL_NUM, -2);
  433.   lpd = request->protocol_data;
  435.   tempstr = g_strconcat (request->directory, "/", NULL);
  437.   if ((lpd->dir = opendir (tempstr)) == NULL)
  438.     {
  439.       request->logging_function (gftp_logging_error, request->user_data,
  440.                            _("Could not get local directory listing %s: %sn"),
  441.                            tempstr, g_strerror (errno));
  442.       g_free (tempstr);
  443.       return (-1);
  444.     }
  446.   g_free (tempstr);
  447.   return (0);
  448. }
  451. static off_t 
  452. local_get_file_size (gftp_request * request, const char *filename)
  453. {
  454.   struct stat st;
  456.   if (stat (filename, &st) == -1)
  457.     return (-1);
  458.   return (st.st_size);
  459. }
  462. static int
  463. local_chdir (gftp_request * request, const char *directory)
  464. {
  465.   char tempstr[255];
  467.   g_return_val_if_fail (request != NULL, -2);
  468.   g_return_val_if_fail (request->protonum == GFTP_LOCAL_NUM, -2);
  469.   g_return_val_if_fail (directory != NULL, -2);
  471.   if (chdir (directory) == 0)
  472.     {
  473.       request->logging_function (gftp_logging_misc, request->user_data,
  474.                           _("Successfully changed local directory to %sn"),
  475.                           directory);
  476.       if (request->directory != directory)
  477.         {
  478.           if (getcwd (tempstr, sizeof (tempstr)) == NULL)
  479.     {
  480.               request->logging_function (gftp_logging_error, request->user_data,
  481.                             _("Could not get current working directory: %sn"),
  482.                             g_strerror (errno));
  483.       return (-1);
  484.     }
  485.           if (request->directory)
  486.     g_free (request->directory);
  487.           request->directory = g_malloc (strlen (tempstr) + 1);
  488.           strcpy (request->directory, tempstr);
  489.         }
  490.       return (0);
  491.     }
  492.   request->logging_function (gftp_logging_error, request->user_data,
  493.                              _("Could not change local directory to %s: %sn"),
  494.                              directory, g_strerror (errno));
  495.   return (-1);
  496. }
  499. static int
  500. local_rmdir (gftp_request * request, const char *directory)
  501. {
  502.   g_return_val_if_fail (request != NULL, -2);
  503.   g_return_val_if_fail (request->protonum == GFTP_LOCAL_NUM, -2);
  504.   g_return_val_if_fail (directory != NULL, -2);
  506.   if (rmdir (directory) == 0)
  507.     {
  508.       request->logging_function (gftp_logging_misc, request->user_data,
  509.                                  _("Successfully removed %sn"), directory);
  510.       return (0);
  511.     }
  512.   else
  513.     {
  514.       request->logging_function (gftp_logging_error, request->user_data,
  515.                               _("Error: Could not remove directory %s: %sn"),
  516.                               directory, g_strerror (errno));
  517.       return (-1);
  518.     }
  519. }
  522. static int
  523. local_rmfile (gftp_request * request, const char *file)
  524. {
  525.   g_return_val_if_fail (request != NULL, -2);
  526.   g_return_val_if_fail (request->protonum == GFTP_LOCAL_NUM, -2);
  527.   g_return_val_if_fail (file != NULL, -2);
  529.   if (unlink (file) == 0)
  530.     {
  531.       request->logging_function (gftp_logging_misc, request->user_data,
  532.                                  _("Successfully removed %sn"), file);
  533.       return (0);
  534.     }
  535.   else
  536.     {
  537.       request->logging_function (gftp_logging_error, request->user_data,
  538.                                  _("Error: Could not remove file %s: %sn"),
  539.                                  file, g_strerror (errno));
  540.       return (-1);
  541.     }
  542. }
  545. static int
  546. local_mkdir (gftp_request * request, const char *directory)
  547. {
  548.   g_return_val_if_fail (request != NULL, -2);
  549.   g_return_val_if_fail (request->protonum == GFTP_LOCAL_NUM, -2);
  550.   g_return_val_if_fail (directory != NULL, -2);
  552.   if (mkdir (directory, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH) == 0)
  553.     {
  554.       request->logging_function (gftp_logging_misc, request->user_data,
  555.                                  _("Successfully made directory %sn"),
  556.                                  directory);
  557.       return (0);
  558.     }
  559.   else
  560.     {
  561.       request->logging_function (gftp_logging_error, request->user_data,
  562.                                  _("Error: Could not make directory %s: %sn"),
  563.                                  directory, g_strerror (errno));
  564.       return (-1);
  565.     }
  566. }
  569. static int
  570. local_rename (gftp_request * request, const char *oldname,
  571.       const char *newname)
  572. {
  573.   g_return_val_if_fail (request != NULL, -2);
  574.   g_return_val_if_fail (request->protonum == GFTP_LOCAL_NUM, -2);
  575.   g_return_val_if_fail (oldname != NULL, -2);
  576.   g_return_val_if_fail (newname != NULL, -2);
  578.   if (rename (oldname, newname) == 0)
  579.     {
  580.       request->logging_function (gftp_logging_misc, request->user_data,
  581.                                  _("Successfully renamed %s to %sn"),
  582.                                  oldname, newname);
  583.       return (0);
  584.     }
  585.   else
  586.     {
  587.       request->logging_function (gftp_logging_error, request->user_data,
  588.                                  _("Error: Could not rename %s to %s: %sn"),
  589.                                  oldname, newname, g_strerror (errno));
  590.       return (-1);
  591.     }
  592. }
  595. static int
  596. local_chmod (gftp_request * request, const char *file, int mode)
  597. {
  598.   char buf[10];
  599.   int newmode;
  601.   g_return_val_if_fail (request != NULL, -2);
  602.   g_return_val_if_fail (request->protonum == GFTP_LOCAL_NUM, -2);
  603.   g_return_val_if_fail (file != NULL, -2);
  605.   g_snprintf (buf, sizeof (buf), "%d", mode);
  606.   newmode = strtol (buf, NULL, 8);
  608.   if (chmod (file, newmode) == 0) 
  609.     {
  610.       request->logging_function (gftp_logging_misc, request->user_data, 
  611.                                  _("Successfully changed mode of %s to %dn"),
  612.                                  file, mode);
  613.       return (0);
  614.     }
  615.   else 
  616.     {
  617.       request->logging_function (gftp_logging_error, request->user_data, 
  618.                           _("Error: Could not change mode of %s to %d: %sn"),
  619.                           file, mode, g_strerror (errno));
  620.       return (-1);
  621.     }
  622. }
  625. static int
  626. local_set_file_time (gftp_request * request, const char *file,
  627.      time_t datetime)
  628. {
  629.   struct utimbuf time_buf;
  631.   g_return_val_if_fail (request != NULL, -2);
  632.   g_return_val_if_fail (request->protonum == GFTP_LOCAL_NUM, -2);
  633.   g_return_val_if_fail (file != NULL, -2);
  635.   time_buf.modtime = time_buf.actime = datetime;
  636.   return (utime (file, &time_buf));
  637. }
  640. static gint
  641. hash_compare (gconstpointer path1, gconstpointer path2)
  642. {
  643.   return (GPOINTER_TO_UINT (path1) == GPOINTER_TO_UINT (path2));
  644. }
  647. static guint
  648. hash_function (gconstpointer key)
  649. {
  650.   return (GPOINTER_TO_UINT (key));
  651. }
  654. void
  655. local_init (gftp_request * request)
  656. {
  657.   local_protocol_data *lpd;
  659.   g_return_if_fail (request != NULL);
  661.   request->protonum = GFTP_LOCAL_NUM;
  662.   request->init = local_init;
  663.   request->destroy = local_destroy;
  664.   request->connect = local_connect;
  665.   request->disconnect = local_disconnect;
  666.   request->get_file = local_get_file;
  667.   request->put_file = local_put_file;
  668.   request->transfer_file = NULL;
  669.   request->get_next_file_chunk = NULL;
  670.   request->put_next_file_chunk = NULL;
  671.   request->end_transfer = local_end_transfer;
  672.   request->abort_transfer = local_end_transfer; /* NOTE: uses end_transfer */
  673.   request->list_files = local_list_files;
  674.   request->get_next_file = local_get_next_file;
  675.   request->set_data_type = NULL;
  676.   request->get_file_size = local_get_file_size;
  677.   request->chdir = local_chdir;
  678.   request->rmdir = local_rmdir;
  679.   request->rmfile = local_rmfile;
  680.   request->mkdir = local_mkdir;
  681.   request->rename = local_rename;
  682.   request->chmod = local_chmod;
  683.   request->set_file_time = local_set_file_time;
  684.   request->site = NULL;
  685.   request->parse_url = NULL;
  686.   request->set_config_options = NULL;
  687.   request->swap_socks = NULL;
  688.   request->url_prefix = "file";
  689.   request->protocol_name = "Local";
  690.   request->need_hostport = 0;
  691.   request->need_userpass = 0;
  692.   request->use_cache = 0;
  693.   request->use_threads = 0;
  694.   request->always_connected = 1;
  695.   gftp_set_config_options (request);
  697.   lpd = g_malloc0 (sizeof (*lpd));
  698.   request->protocol_data = lpd;
  699.   lpd->userhash = g_hash_table_new (hash_function, hash_compare);
  700.   lpd->grouphash = g_hash_table_new (hash_function, hash_compare);
  702.   if (request->hostname != NULL)
  703.     g_free (request->hostname);
  704.   request->hostname = g_strdup (_("local filesystem"));
  705. }