interface.c 27 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950
  1. /*
  2. Virtual File System: interface functions
  3. Copyright (C) 2011
  4. The Free Software Foundation, Inc.
  5. Written by:
  6. Slava Zanko <slavazanko@gmail.com>, 2011
  7. This file is part of the Midnight Commander.
  8. The Midnight Commander is free software: you can redistribute it
  9. and/or modify it under the terms of the GNU General Public License as
  10. published by the Free Software Foundation, either version 3 of the License,
  11. or (at your option) any later version.
  12. The Midnight Commander is distributed in the hope that it will be useful,
  13. but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15. GNU General Public License for more details.
  16. You should have received a copy of the GNU General Public License
  17. along with this program. If not, see <http://www.gnu.org/licenses/>.
  18. */
  19. /**
  20. * \file
  21. * \brief Source: Virtual File System: path handlers
  22. * \author Slava Zanko
  23. * \date 2011
  24. */
  25. #include <config.h>
  26. #include <stdio.h>
  27. #include <stdlib.h> /* For atol() */
  28. #include <stdarg.h>
  29. #include <string.h>
  30. #include <errno.h>
  31. #include <sys/types.h>
  32. #include <signal.h>
  33. #include <ctype.h> /* is_digit() */
  34. #include <fcntl.h>
  35. #include <sys/stat.h>
  36. #include <unistd.h>
  37. #include <dirent.h>
  38. #include <pwd.h>
  39. #include <grp.h>
  40. #include "lib/global.h"
  41. #include "lib/widget.h" /* message() */
  42. #include "lib/strutil.h" /* str_crt_conv_from() */
  43. #include "lib/util.h"
  44. #include "vfs.h"
  45. #include "utilvfs.h"
  46. #include "path.h"
  47. #include "gc.h"
  48. #include "xdirentry.h"
  49. extern GString *vfs_str_buffer;
  50. extern struct vfs_class *current_vfs;
  51. /*** global variables ****************************************************************************/
  52. struct dirent *mc_readdir_result = NULL;
  53. /*** file scope macro definitions ****************************************************************/
  54. /*** file scope type declarations ****************************************************************/
  55. /*** file scope variables ************************************************************************/
  56. /*** file scope functions ************************************************************************/
  57. /* --------------------------------------------------------------------------------------------- */
  58. static vfs_path_t *
  59. mc_def_getlocalcopy (const vfs_path_t * filename_vpath)
  60. {
  61. vfs_path_t *tmp_vpath = NULL;
  62. int fdin = -1, fdout = -1;
  63. ssize_t i;
  64. char buffer[BUF_1K * 8];
  65. struct stat mystat;
  66. fdin = mc_open (filename_vpath, O_RDONLY | O_LINEAR);
  67. if (fdin == -1)
  68. goto fail;
  69. fdout = vfs_mkstemps (&tmp_vpath, "vfs", vfs_path_get_last_path_str (filename_vpath));
  70. if (fdout == -1)
  71. goto fail;
  72. while ((i = mc_read (fdin, buffer, sizeof (buffer))) > 0)
  73. {
  74. if (write (fdout, buffer, i) != i)
  75. goto fail;
  76. }
  77. if (i == -1)
  78. goto fail;
  79. i = mc_close (fdin);
  80. fdin = -1;
  81. if (i == -1)
  82. goto fail;
  83. i = close (fdout);
  84. fdout = -1;
  85. if (i == -1)
  86. {
  87. fdout = -1;
  88. goto fail;
  89. }
  90. if (mc_stat (filename_vpath, &mystat) != -1)
  91. mc_chmod (tmp_vpath, mystat.st_mode);
  92. return tmp_vpath;
  93. fail:
  94. vfs_path_free (tmp_vpath);
  95. if (fdout != -1)
  96. close (fdout);
  97. if (fdin != -1)
  98. mc_close (fdin);
  99. return NULL;
  100. }
  101. /* --------------------------------------------------------------------------------------------- */
  102. static int
  103. mc_def_ungetlocalcopy (const vfs_path_t * filename_vpath,
  104. const vfs_path_t * local_vpath, gboolean has_changed)
  105. {
  106. int fdin = -1, fdout = -1;
  107. const char *local;
  108. local = vfs_path_get_last_path_str (local_vpath);
  109. if (has_changed)
  110. {
  111. char buffer[BUF_1K * 8];
  112. ssize_t i;
  113. if (vfs_path_get_last_path_vfs (filename_vpath)->write == NULL)
  114. goto failed;
  115. fdin = open (local, O_RDONLY);
  116. if (fdin == -1)
  117. goto failed;
  118. fdout = mc_open (filename_vpath, O_WRONLY | O_TRUNC);
  119. if (fdout == -1)
  120. goto failed;
  121. while ((i = read (fdin, buffer, sizeof (buffer))) > 0)
  122. if (mc_write (fdout, buffer, (size_t) i) != i)
  123. goto failed;
  124. if (i == -1)
  125. goto failed;
  126. if (close (fdin) == -1)
  127. {
  128. fdin = -1;
  129. goto failed;
  130. }
  131. fdin = -1;
  132. if (mc_close (fdout) == -1)
  133. {
  134. fdout = -1;
  135. goto failed;
  136. }
  137. }
  138. unlink (local);
  139. return 0;
  140. failed:
  141. message (D_ERROR, _("Changes to file lost"), "%s", vfs_path_get_last_path_str (filename_vpath));
  142. if (fdout != -1)
  143. mc_close (fdout);
  144. if (fdin != -1)
  145. close (fdin);
  146. unlink (local);
  147. return -1;
  148. }
  149. /* --------------------------------------------------------------------------------------------- */
  150. /*** public functions ****************************************************************************/
  151. /* --------------------------------------------------------------------------------------------- */
  152. int
  153. mc_open (const vfs_path_t * vpath, int flags, ...)
  154. {
  155. int mode = 0, result = -1;
  156. const vfs_path_element_t *path_element;
  157. if (vpath == NULL)
  158. return -1;
  159. /* Get the mode flag */
  160. if (flags & O_CREAT)
  161. {
  162. va_list ap;
  163. va_start (ap, flags);
  164. mode = va_arg (ap, int);
  165. va_end (ap);
  166. }
  167. path_element = vfs_path_get_by_index (vpath, -1);
  168. if (vfs_path_element_valid (path_element) && path_element->class->open != NULL)
  169. {
  170. void *info;
  171. /* open must be supported */
  172. info = path_element->class->open (vpath, flags, mode);
  173. if (info == NULL)
  174. errno = vfs_ferrno (path_element->class);
  175. else
  176. result = vfs_new_handle (path_element->class, info);
  177. }
  178. else
  179. errno = -EOPNOTSUPP;
  180. return result;
  181. }
  182. /* --------------------------------------------------------------------------------------------- */
  183. /* *INDENT-OFF* */
  184. #define MC_NAMEOP(name, inarg, callarg) \
  185. int mc_##name inarg \
  186. { \
  187. int result; \
  188. const vfs_path_element_t *path_element; \
  189. \
  190. if (vpath == NULL) \
  191. return -1; \
  192. \
  193. path_element = vfs_path_get_by_index (vpath, -1); \
  194. if (!vfs_path_element_valid (path_element)) \
  195. { \
  196. return -1; \
  197. } \
  198. \
  199. result = path_element->class->name != NULL ? path_element->class->name callarg : -1; \
  200. if (result == -1) \
  201. errno = path_element->class->name != NULL ? vfs_ferrno (path_element->class) : E_NOTSUPP; \
  202. return result; \
  203. }
  204. MC_NAMEOP (chmod, (const vfs_path_t *vpath, mode_t mode), (vpath, mode))
  205. MC_NAMEOP (chown, (const vfs_path_t *vpath, uid_t owner, gid_t group), (vpath, owner, group))
  206. MC_NAMEOP (utime, (const vfs_path_t *vpath, struct utimbuf * times), (vpath, times))
  207. MC_NAMEOP (readlink, (const vfs_path_t *vpath, char *buf, size_t bufsiz), (vpath, buf, bufsiz))
  208. MC_NAMEOP (unlink, (const vfs_path_t *vpath), (vpath))
  209. MC_NAMEOP (mkdir, (const vfs_path_t *vpath, mode_t mode), (vpath, mode))
  210. MC_NAMEOP (rmdir, (const vfs_path_t *vpath), (vpath))
  211. MC_NAMEOP (mknod, (const vfs_path_t *vpath, mode_t mode, dev_t dev), (vpath, mode, dev))
  212. /* *INDENT-ON* */
  213. /* --------------------------------------------------------------------------------------------- */
  214. int
  215. mc_symlink (const vfs_path_t * vpath1, const vfs_path_t * vpath2)
  216. {
  217. int result = -1;
  218. if (vpath1 == NULL)
  219. return -1;
  220. if (vpath1 != NULL)
  221. {
  222. const vfs_path_element_t *path_element;
  223. path_element = vfs_path_get_by_index (vpath2, -1);
  224. if (vfs_path_element_valid (path_element))
  225. {
  226. result =
  227. path_element->class->symlink != NULL ?
  228. path_element->class->symlink (vpath1, vpath2) : -1;
  229. if (result == -1)
  230. errno =
  231. path_element->class->symlink != NULL ?
  232. vfs_ferrno (path_element->class) : E_NOTSUPP;
  233. }
  234. }
  235. return result;
  236. }
  237. /* --------------------------------------------------------------------------------------------- */
  238. /* *INDENT-OFF* */
  239. #define MC_HANDLEOP(name, inarg, callarg) \
  240. ssize_t mc_##name inarg \
  241. { \
  242. struct vfs_class *vfs; \
  243. int result; \
  244. if (handle == -1) \
  245. return -1; \
  246. vfs = vfs_class_find_by_handle (handle); \
  247. if (vfs == NULL) \
  248. return -1; \
  249. result = vfs->name != NULL ? vfs->name callarg : -1; \
  250. if (result == -1) \
  251. errno = vfs->name != NULL ? vfs_ferrno (vfs) : E_NOTSUPP; \
  252. return result; \
  253. }
  254. MC_HANDLEOP (read, (int handle, void *buffer, size_t count), (vfs_class_data_find_by_handle (handle), buffer, count))
  255. MC_HANDLEOP (write, (int handle, const void *buf, size_t nbyte), (vfs_class_data_find_by_handle (handle), buf, nbyte))
  256. /* --------------------------------------------------------------------------------------------- */
  257. #define MC_RENAMEOP(name) \
  258. int mc_##name (const vfs_path_t *vpath1, const vfs_path_t *vpath2) \
  259. { \
  260. int result; \
  261. const vfs_path_element_t *path_element1; \
  262. const vfs_path_element_t *path_element2; \
  263. \
  264. if (vpath1 == NULL || vpath2 == NULL) \
  265. return -1; \
  266. \
  267. path_element1 = vfs_path_get_by_index (vpath1, - 1); \
  268. path_element2 = vfs_path_get_by_index (vpath2, - 1); \
  269. \
  270. if (!vfs_path_element_valid (path_element1) || !vfs_path_element_valid (path_element2) || \
  271. path_element1->class != path_element2->class) \
  272. { \
  273. errno = EXDEV; \
  274. return -1; \
  275. }\
  276. \
  277. result = path_element1->class->name != NULL \
  278. ? path_element1->class->name (vpath1, vpath2) \
  279. : -1; \
  280. if (result == -1) \
  281. errno = path_element1->class->name != NULL ? vfs_ferrno (path_element1->class) : E_NOTSUPP; \
  282. return result; \
  283. }
  284. MC_RENAMEOP (link)
  285. MC_RENAMEOP (rename)
  286. /* *INDENT-ON* */
  287. /* --------------------------------------------------------------------------------------------- */
  288. int
  289. mc_ctl (int handle, int ctlop, void *arg)
  290. {
  291. struct vfs_class *vfs = vfs_class_find_by_handle (handle);
  292. if (vfs == NULL)
  293. return 0;
  294. return vfs->ctl ? (*vfs->ctl) (vfs_class_data_find_by_handle (handle), ctlop, arg) : 0;
  295. }
  296. /* --------------------------------------------------------------------------------------------- */
  297. int
  298. mc_setctl (const vfs_path_t * vpath, int ctlop, void *arg)
  299. {
  300. int result = -1;
  301. const vfs_path_element_t *path_element;
  302. if (vpath == NULL)
  303. vfs_die ("You don't want to pass NULL to mc_setctl.");
  304. path_element = vfs_path_get_by_index (vpath, -1);
  305. if (vfs_path_element_valid (path_element))
  306. result =
  307. path_element->class->setctl != NULL ? path_element->class->setctl (vpath,
  308. ctlop, arg) : 0;
  309. return result;
  310. }
  311. /* --------------------------------------------------------------------------------------------- */
  312. int
  313. mc_close (int handle)
  314. {
  315. struct vfs_class *vfs;
  316. int result;
  317. if (handle == -1 || !vfs_class_data_find_by_handle (handle))
  318. return -1;
  319. vfs = vfs_class_find_by_handle (handle);
  320. if (vfs == NULL)
  321. return -1;
  322. if (handle < 3)
  323. return close (handle);
  324. if (!vfs->close)
  325. vfs_die ("VFS must support close.\n");
  326. result = (*vfs->close) (vfs_class_data_find_by_handle (handle));
  327. vfs_free_handle (handle);
  328. if (result == -1)
  329. errno = vfs_ferrno (vfs);
  330. return result;
  331. }
  332. /* --------------------------------------------------------------------------------------------- */
  333. DIR *
  334. mc_opendir (const vfs_path_t * vpath)
  335. {
  336. int handle, *handlep;
  337. void *info;
  338. vfs_path_element_t *path_element;
  339. if (vpath == NULL)
  340. return NULL;
  341. path_element = (vfs_path_element_t *) vfs_path_get_by_index (vpath, -1);
  342. if (!vfs_path_element_valid (path_element))
  343. {
  344. errno = E_NOTSUPP;
  345. return NULL;
  346. }
  347. info = path_element->class->opendir ? (*path_element->class->opendir) (vpath) : NULL;
  348. if (info == NULL)
  349. {
  350. errno = path_element->class->opendir ? vfs_ferrno (path_element->class) : E_NOTSUPP;
  351. return NULL;
  352. }
  353. path_element->dir.info = info;
  354. path_element->dir.converter = (path_element->encoding != NULL) ?
  355. str_crt_conv_from (path_element->encoding) : str_cnv_from_term;
  356. if (path_element->dir.converter == INVALID_CONV)
  357. path_element->dir.converter = str_cnv_from_term;
  358. handle = vfs_new_handle (path_element->class, vfs_path_element_clone (path_element));
  359. handlep = g_new (int, 1);
  360. *handlep = handle;
  361. return (DIR *) handlep;
  362. }
  363. /* --------------------------------------------------------------------------------------------- */
  364. struct dirent *
  365. mc_readdir (DIR * dirp)
  366. {
  367. int handle;
  368. struct vfs_class *vfs;
  369. struct dirent *entry = NULL;
  370. vfs_path_element_t *vfs_path_element;
  371. estr_t state;
  372. if (!mc_readdir_result)
  373. {
  374. /* We can't just allocate struct dirent as (see man dirent.h)
  375. * struct dirent has VERY nonnaive semantics of allocating
  376. * d_name in it. Moreover, linux's glibc-2.9 allocates dirents _less_,
  377. * than 'sizeof (struct dirent)' making full bitwise (sizeof dirent) copy
  378. * heap corrupter. So, allocate longliving dirent with at least
  379. * (MAXNAMLEN + 1) for d_name in it.
  380. * Strictly saying resulting dirent is unusable as we don't adjust internal
  381. * structures, holding dirent size. But we don't use it in libc infrastructure.
  382. * TODO: to make simpler homemade dirent-alike structure.
  383. */
  384. mc_readdir_result = (struct dirent *) g_malloc (sizeof (struct dirent) + MAXNAMLEN + 1);
  385. }
  386. if (!dirp)
  387. {
  388. errno = EFAULT;
  389. return NULL;
  390. }
  391. handle = *(int *) dirp;
  392. vfs = vfs_class_find_by_handle (handle);
  393. if (vfs == NULL)
  394. return NULL;
  395. vfs_path_element = vfs_class_data_find_by_handle (handle);
  396. if (vfs->readdir)
  397. {
  398. entry = (*vfs->readdir) (vfs_path_element->dir.info);
  399. if (entry == NULL)
  400. return NULL;
  401. g_string_set_size (vfs_str_buffer, 0);
  402. state =
  403. str_vfs_convert_from (vfs_path_element->dir.converter, entry->d_name, vfs_str_buffer);
  404. mc_readdir_result->d_ino = entry->d_ino;
  405. g_strlcpy (mc_readdir_result->d_name, vfs_str_buffer->str, MAXNAMLEN + 1);
  406. }
  407. if (entry == NULL)
  408. errno = vfs->readdir ? vfs_ferrno (vfs) : E_NOTSUPP;
  409. return (entry != NULL) ? mc_readdir_result : NULL;
  410. }
  411. /* --------------------------------------------------------------------------------------------- */
  412. int
  413. mc_closedir (DIR * dirp)
  414. {
  415. int handle = *(int *) dirp;
  416. struct vfs_class *vfs;
  417. int result = -1;
  418. vfs = vfs_class_find_by_handle (handle);
  419. if (vfs != NULL)
  420. {
  421. vfs_path_element_t *vfs_path_element;
  422. vfs_path_element = vfs_class_data_find_by_handle (handle);
  423. if (vfs_path_element->dir.converter != str_cnv_from_term)
  424. {
  425. str_close_conv (vfs_path_element->dir.converter);
  426. vfs_path_element->dir.converter = INVALID_CONV;
  427. }
  428. result = vfs->closedir ? (*vfs->closedir) (vfs_path_element->dir.info) : -1;
  429. vfs_free_handle (handle);
  430. vfs_path_element_free (vfs_path_element);
  431. }
  432. g_free (dirp);
  433. return result;
  434. }
  435. /* --------------------------------------------------------------------------------------------- */
  436. int
  437. mc_stat (const vfs_path_t * vpath, struct stat *buf)
  438. {
  439. int result = -1;
  440. const vfs_path_element_t *path_element;
  441. if (vpath == NULL)
  442. return -1;
  443. path_element = vfs_path_get_by_index (vpath, -1);
  444. if (vfs_path_element_valid (path_element))
  445. {
  446. result = path_element->class->stat ? (*path_element->class->stat) (vpath, buf) : -1;
  447. if (result == -1)
  448. errno = path_element->class->name ? vfs_ferrno (path_element->class) : E_NOTSUPP;
  449. }
  450. return result;
  451. }
  452. /* --------------------------------------------------------------------------------------------- */
  453. int
  454. mc_lstat (const vfs_path_t * vpath, struct stat *buf)
  455. {
  456. int result = -1;
  457. const vfs_path_element_t *path_element;
  458. if (vpath == NULL)
  459. return -1;
  460. path_element = vfs_path_get_by_index (vpath, -1);
  461. if (vfs_path_element_valid (path_element))
  462. {
  463. result = path_element->class->lstat ? (*path_element->class->lstat) (vpath, buf) : -1;
  464. if (result == -1)
  465. errno = path_element->class->name ? vfs_ferrno (path_element->class) : E_NOTSUPP;
  466. }
  467. return result;
  468. }
  469. /* --------------------------------------------------------------------------------------------- */
  470. int
  471. mc_fstat (int handle, struct stat *buf)
  472. {
  473. struct vfs_class *vfs;
  474. int result;
  475. if (handle == -1)
  476. return -1;
  477. vfs = vfs_class_find_by_handle (handle);
  478. if (vfs == NULL)
  479. return -1;
  480. result = vfs->fstat ? (*vfs->fstat) (vfs_class_data_find_by_handle (handle), buf) : -1;
  481. if (result == -1)
  482. errno = vfs->name ? vfs_ferrno (vfs) : E_NOTSUPP;
  483. return result;
  484. }
  485. /* --------------------------------------------------------------------------------------------- */
  486. vfs_path_t *
  487. mc_getlocalcopy (const vfs_path_t * pathname_vpath)
  488. {
  489. vfs_path_t *result = NULL;
  490. const vfs_path_element_t *path_element;
  491. if (pathname_vpath == NULL)
  492. return NULL;
  493. path_element = vfs_path_get_by_index (pathname_vpath, -1);
  494. if (vfs_path_element_valid (path_element))
  495. {
  496. result = path_element->class->getlocalcopy != NULL ?
  497. path_element->class->getlocalcopy (pathname_vpath) :
  498. mc_def_getlocalcopy (pathname_vpath);
  499. if (result == NULL)
  500. errno = vfs_ferrno (path_element->class);
  501. }
  502. return result;
  503. }
  504. /* --------------------------------------------------------------------------------------------- */
  505. int
  506. mc_ungetlocalcopy (const vfs_path_t * pathname_vpath, const vfs_path_t * local_vpath,
  507. gboolean has_changed)
  508. {
  509. int return_value = -1;
  510. const vfs_path_element_t *path_element;
  511. if (pathname_vpath == NULL)
  512. return -1;
  513. path_element = vfs_path_get_by_index (pathname_vpath, -1);
  514. if (vfs_path_element_valid (path_element))
  515. return_value = path_element->class->ungetlocalcopy != NULL ?
  516. path_element->class->ungetlocalcopy (pathname_vpath, local_vpath, has_changed) :
  517. mc_def_ungetlocalcopy (pathname_vpath, local_vpath, has_changed);
  518. return return_value;
  519. }
  520. /* --------------------------------------------------------------------------------------------- */
  521. /**
  522. * VFS chdir.
  523. *
  524. * @param vpath VFS-path
  525. *
  526. * @return 0 on success, -1 on failure.
  527. */
  528. int
  529. mc_chdir (const vfs_path_t * vpath)
  530. {
  531. struct vfs_class *old_vfs;
  532. vfsid old_vfsid;
  533. int result;
  534. const vfs_path_element_t *path_element;
  535. vfs_path_t *cd_vpath;
  536. if (vpath == NULL)
  537. return -1;
  538. if (vpath->relative)
  539. cd_vpath = vfs_path_to_absolute (vpath);
  540. else
  541. cd_vpath = vfs_path_clone (vpath);
  542. path_element = vfs_path_get_by_index (cd_vpath, -1);
  543. if (!vfs_path_element_valid (path_element) || path_element->class->chdir == NULL)
  544. {
  545. goto error_end;
  546. }
  547. result = (*path_element->class->chdir) (cd_vpath);
  548. if (result == -1)
  549. {
  550. errno = vfs_ferrno (path_element->class);
  551. goto error_end;
  552. }
  553. old_vfsid = vfs_getid (vfs_get_raw_current_dir ());
  554. old_vfs = current_vfs;
  555. /* Actually change directory */
  556. vfs_set_raw_current_dir (cd_vpath);
  557. current_vfs = path_element->class;
  558. /* This function uses the new current_dir implicitly */
  559. vfs_stamp_create (old_vfs, old_vfsid);
  560. /* Sometimes we assume no trailing slash on cwd */
  561. path_element = vfs_path_get_by_index (vfs_get_raw_current_dir (), -1);
  562. if (vfs_path_element_valid (path_element))
  563. {
  564. struct vfs_s_super *super;
  565. if (*path_element->path != '\0')
  566. {
  567. char *p;
  568. p = strchr (path_element->path, 0) - 1;
  569. if (*p == PATH_SEP && p > path_element->path)
  570. *p = '\0';
  571. }
  572. super = vfs_get_super_by_vpath (vpath);
  573. if (super != NULL && super->path_element != NULL)
  574. {
  575. g_free (super->path_element->path);
  576. super->path_element->path = g_strdup (path_element->path);
  577. }
  578. }
  579. return 0;
  580. error_end:
  581. vfs_path_free (cd_vpath);
  582. return -1;
  583. }
  584. /* --------------------------------------------------------------------------------------------- */
  585. off_t
  586. mc_lseek (int fd, off_t offset, int whence)
  587. {
  588. struct vfs_class *vfs;
  589. off_t result;
  590. if (fd == -1)
  591. return -1;
  592. vfs = vfs_class_find_by_handle (fd);
  593. if (vfs == NULL)
  594. return -1;
  595. result = vfs->lseek ? (*vfs->lseek) (vfs_class_data_find_by_handle (fd), offset, whence) : -1;
  596. if (result == -1)
  597. errno = vfs->lseek ? vfs_ferrno (vfs) : E_NOTSUPP;
  598. return result;
  599. }
  600. /* --------------------------------------------------------------------------------------------- */
  601. /* Following code heavily borrows from libiberty, mkstemps.c */
  602. /*
  603. * Arguments:
  604. * pname (output) - pointer to the name of the temp file (needs g_free).
  605. * NULL if the function fails.
  606. * prefix - part of the filename before the random part.
  607. * Prepend $TMPDIR or /tmp if there are no path separators.
  608. * suffix - if not NULL, part of the filename after the random part.
  609. *
  610. * Result:
  611. * handle of the open file or -1 if couldn't open any.
  612. */
  613. int
  614. mc_mkstemps (vfs_path_t ** pname_vpath, const char *prefix, const char *suffix)
  615. {
  616. static const char letters[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
  617. static unsigned long value;
  618. struct timeval tv;
  619. char *tmpbase;
  620. char *tmpname;
  621. char *XXXXXX;
  622. char *ret_path;
  623. int count;
  624. if (strchr (prefix, PATH_SEP) == NULL)
  625. {
  626. /* Add prefix first to find the position of XXXXXX */
  627. tmpbase = g_build_filename (mc_tmpdir (), prefix, NULL);
  628. }
  629. else
  630. {
  631. tmpbase = g_strdup (prefix);
  632. }
  633. tmpname = g_strconcat (tmpbase, "XXXXXX", suffix, (char *) NULL);
  634. ret_path = tmpname;
  635. XXXXXX = &tmpname[strlen (tmpbase)];
  636. g_free (tmpbase);
  637. /* Get some more or less random data. */
  638. gettimeofday (&tv, NULL);
  639. value += (tv.tv_usec << 16) ^ tv.tv_sec ^ getpid ();
  640. for (count = 0; count < TMP_MAX; ++count)
  641. {
  642. unsigned long v = value;
  643. int fd;
  644. /* Fill in the random bits. */
  645. XXXXXX[0] = letters[v % 62];
  646. v /= 62;
  647. XXXXXX[1] = letters[v % 62];
  648. v /= 62;
  649. XXXXXX[2] = letters[v % 62];
  650. v /= 62;
  651. XXXXXX[3] = letters[v % 62];
  652. v /= 62;
  653. XXXXXX[4] = letters[v % 62];
  654. v /= 62;
  655. XXXXXX[5] = letters[v % 62];
  656. fd = open (tmpname, O_RDWR | O_CREAT | O_TRUNC | O_EXCL, S_IRUSR | S_IWUSR);
  657. if (fd >= 0)
  658. {
  659. /* Successfully created. */
  660. *pname_vpath = vfs_path_from_str (ret_path);
  661. g_free (ret_path);
  662. return fd;
  663. }
  664. /* This is a random value. It is only necessary that the next
  665. TMP_MAX values generated by adding 7777 to VALUE are different
  666. with (module 2^32). */
  667. value += 7777;
  668. }
  669. /* Unsuccessful. Free the filename. */
  670. g_free (ret_path);
  671. *pname_vpath = NULL;
  672. return -1;
  673. }
  674. /* --------------------------------------------------------------------------------------------- */
  675. /**
  676. * Return the directory where mc should keep its temporary files.
  677. * This directory is (in Bourne shell terms) "${TMPDIR=/tmp}/mc-$USER"
  678. * When called the first time, the directory is created if needed.
  679. * The first call should be done early, since we are using fprintf()
  680. * and not message() to report possible problems.
  681. */
  682. const char *
  683. mc_tmpdir (void)
  684. {
  685. static char buffer[64];
  686. static const char *tmpdir = NULL;
  687. const char *sys_tmp;
  688. struct passwd *pwd;
  689. struct stat st;
  690. const char *error = NULL;
  691. /* Check if already correctly initialized */
  692. if (tmpdir && lstat (tmpdir, &st) == 0 && S_ISDIR (st.st_mode) &&
  693. st.st_uid == getuid () && (st.st_mode & 0777) == 0700)
  694. return tmpdir;
  695. sys_tmp = getenv ("TMPDIR");
  696. if (!sys_tmp || sys_tmp[0] != '/')
  697. {
  698. sys_tmp = TMPDIR_DEFAULT;
  699. }
  700. pwd = getpwuid (getuid ());
  701. if (pwd)
  702. g_snprintf (buffer, sizeof (buffer), "%s/mc-%s", sys_tmp, pwd->pw_name);
  703. else
  704. g_snprintf (buffer, sizeof (buffer), "%s/mc-%lu", sys_tmp, (unsigned long) getuid ());
  705. canonicalize_pathname (buffer);
  706. if (lstat (buffer, &st) == 0)
  707. {
  708. /* Sanity check for existing directory */
  709. if (!S_ISDIR (st.st_mode))
  710. error = _("%s is not a directory\n");
  711. else if (st.st_uid != getuid ())
  712. error = _("Directory %s is not owned by you\n");
  713. else if (((st.st_mode & 0777) != 0700) && (chmod (buffer, 0700) != 0))
  714. error = _("Cannot set correct permissions for directory %s\n");
  715. }
  716. else
  717. {
  718. /* Need to create directory */
  719. if (mkdir (buffer, S_IRWXU) != 0)
  720. {
  721. fprintf (stderr,
  722. _("Cannot create temporary directory %s: %s\n"),
  723. buffer, unix_error_string (errno));
  724. error = "";
  725. }
  726. }
  727. if (error != NULL)
  728. {
  729. int test_fd;
  730. char *fallback_prefix;
  731. gboolean fallback_ok = FALSE;
  732. vfs_path_t *test_vpath;
  733. if (*error)
  734. fprintf (stderr, error, buffer);
  735. /* Test if sys_tmp is suitable for temporary files */
  736. fallback_prefix = g_strdup_printf ("%s/mctest", sys_tmp);
  737. test_fd = mc_mkstemps (&test_vpath, fallback_prefix, NULL);
  738. g_free (fallback_prefix);
  739. if (test_fd != -1)
  740. {
  741. char *test_fn;
  742. test_fn = vfs_path_to_str (test_vpath);
  743. close (test_fd);
  744. test_fd = open (test_fn, O_RDONLY);
  745. g_free (test_fn);
  746. if (test_fd != -1)
  747. {
  748. close (test_fd);
  749. unlink (test_fn);
  750. fallback_ok = TRUE;
  751. }
  752. }
  753. if (fallback_ok)
  754. {
  755. fprintf (stderr, _("Temporary files will be created in %s\n"), sys_tmp);
  756. g_snprintf (buffer, sizeof (buffer), "%s", sys_tmp);
  757. error = NULL;
  758. }
  759. else
  760. {
  761. fprintf (stderr, _("Temporary files will not be created\n"));
  762. g_snprintf (buffer, sizeof (buffer), "%s", "/dev/null/");
  763. }
  764. vfs_path_free (test_vpath);
  765. fprintf (stderr, "%s\n", _("Press any key to continue..."));
  766. getc (stdin);
  767. }
  768. tmpdir = buffer;
  769. if (!error)
  770. g_setenv ("MC_TMPDIR", tmpdir, TRUE);
  771. return tmpdir;
  772. }
  773. /* --------------------------------------------------------------------------------------------- */