/filesystems/sshfs/sshfs-fuse-2.1-macosx.patch

http://macfuse.googlecode.com/ · Patch · 416 lines · 390 code · 26 blank · 0 comment · 0 complexity · f7b3cb74a4d8dba031c2cb12c8c51109 MD5 · raw file 

    

  1. diff -Naur old/Makefile.in new/Makefile.in
    2. 

  2. --- old/Makefile.in	2008-07-11 04:04:11.000000000 -0700
    3. 

  3. +++ new/Makefile.in	2008-07-14 18:14:24.000000000 -0700
    4. 

  4. @@ -660,7 +660,11 @@
    5. 

  5.  @SSH_NODELAY_SO_TRUE@	rm -f "$(DESTDIR)$(libdir)/sshnodelay.so"
    6. 

  6.  
    7. 

  7.  @SSH_NODELAY_SO_TRUE@sshnodelay.so:
    8. 

  8. +ifeq "$(shell uname)" "Darwin"
    9. 

  9. +@SSH_NODELAY_SO_TRUE@	$(CC) -Wall -dynamiclib $(CFLAGS) $(sshnodelay_libs) -install_name "$(DESTDIR)$(libdir)/sshnodelay.so" sshnodelay.c -o sshnodelay.so
    10. 

  10. +else
    11. 

  11.  @SSH_NODELAY_SO_TRUE@	$(CC) -Wall -W -s --shared -fPIC $(sshnodelay_libs) sshnodelay.c -o sshnodelay.so
    12. 

  12. +endif
    13. 

  13.  # Tell versions [3.59,3.63) of GNU make to not export all variables.
    14. 

  14.  # Otherwise a system limit (for SysV at least) may be exceeded.
    15. 

  15.  .NOEXPORT:
    16. 

  16. diff -Naur old/README.MacFUSE new/README.MacFUSE
    17. 

  17. --- old/README.MacFUSE	1969-12-31 16:00:00.000000000 -0800
    18. 

  18. +++ new/README.MacFUSE	2008-07-14 18:14:24.000000000 -0700
    19. 

  19. @@ -0,0 +1,9 @@
    20. 

  20. +MacFUSE Project Page:
    21. 

  21. +
    22. 

  22. +http://code.google.com/p/macfuse/
    23. 

  23. +
    24. 

  24. +Making a Universal build of sshfs:
    25. 

  25. +
    26. 

  26. +0. Make sure dependencies (glib, MacFUSE) are installed
    27. 

  27. +1. Run ./configure_for_macfuse.sh
    28. 

  28. +2. Run make
    29. 

  29. diff -Naur old/cache.c new/cache.c
    30. 

  30. --- old/cache.c	2008-07-11 04:00:33.000000000 -0700
    31. 

  31. +++ new/cache.c	2008-07-14 18:30:25.000000000 -0700
    32. 

  32. @@ -553,6 +553,9 @@
    33. 

  33.  	cache.next_oper = oper;
    34. 

  34.  
    35. 

  35.  	cache_unity_fill(oper, &cache_oper);
    36. 

  36. +#if (__FreeBSD__ >= 10)
    37. 

  37. +	cache_enabled = cache.on;
    38. 

  38. +#endif
    39. 

  39.  	if (cache.on) {
    40. 

  40.  		cache_fill(oper, &cache_oper);
    41. 

  41.  		pthread_mutex_init(&cache.lock, NULL);
    42. 

  42. @@ -587,3 +590,7 @@
    43. 

  43.  
    44. 

  44.  	return fuse_opt_parse(args, &cache, cache_opts, NULL);
    45. 

  45.  }
    46. 

  46. +
    47. 

  47. +#if (__FreeBSD__ >= 10)
    48. 

  48. +int cache_enabled;
    49. 

  49. +#endif
    50. 

  50. diff -Naur old/cache.h new/cache.h
    51. 

  51. --- old/cache.h	2008-07-11 04:00:33.000000000 -0700
    52. 

  52. +++ new/cache.h	2008-07-14 18:16:57.000000000 -0700
    53. 

  53. @@ -27,3 +27,7 @@
    54. 

  54.  void cache_add_attr(const char *path, const struct stat *stbuf, uint64_t wrctr);
    55. 

  55.  void cache_invalidate(const char *path);
    56. 

  56.  uint64_t cache_get_write_ctr(void);
    57. 

  57. +
    58. 

  58. +#if (__FreeBSD__ >= 10)
    59. 

  59. +extern int cache_enabled;
    60. 

  60. +#endif
    61. 

  61. diff -Naur old/sshfs.c new/sshfs.c
    62. 

  62. --- old/sshfs.c	2008-07-11 04:00:33.000000000 -0700
    63. 

  63. +++ new/sshfs.c	2008-07-14 18:32:07.000000000 -0700
    64. 

  64. @@ -19,7 +19,12 @@
    65. 

  65.  #include <string.h>
    66. 

  66.  #include <stdint.h>
    67. 

  67.  #include <errno.h>
    68. 

  68. +#if !(__FreeBSD__ >= 10)
    69. 

  69.  #include <semaphore.h>
    70. 

  70. +#else
    71. 

  71. +#define MACFUSE_SSHFS_VERSION "1.7.0"
    72. 

  72. +#include "fuse_darwin.h"
    73. 

  73. +#endif
    74. 

  74.  #include <pthread.h>
    75. 

  75.  #include <netdb.h>
    76. 

  76.  #include <signal.h>
    77. 

  77. @@ -34,6 +39,10 @@
    78. 

  78.  #include <netinet/in.h>
    79. 

  79.  #include <netinet/tcp.h>
    80. 

  80.  #include <glib.h>
    81. 

  81. +#if (__FreeBSD__ >= 10)
    82. 

  82. +#include <libgen.h>
    83. 

  83. +#include <strings.h>
    84. 

  84. +#endif
    85. 

  85.  
    86. 

  86.  #include "cache.h"
    87. 

  87.  
    88. 

  88. @@ -120,6 +129,16 @@
    89. 

  89.  
    90. 

  90.  #define SSHNODELAY_SO "sshnodelay.so"
    91. 

  91.  
    92. 

  92. +#if (__FreeBSD__ >= 10)
    93. 

  93. +
    94. 

  94. +#ifndef LIBDIR
    95. 

  95. +#define LIBDIR "/usr/local/lib"
    96. 

  96. +#endif
    97. 

  97. +
    98. 

  98. +static char sshfs_program_path[PATH_MAX] = { 0 };
    99. 

  99. +
    100. 

  100. +#endif
    101. 

  101. +
    102. 

  102.  struct buffer {
    103. 

  103.  	uint8_t *p;
    104. 

  104.  	size_t len;
    105. 

  105. @@ -169,6 +188,9 @@
    106. 

  106.  	int connver;
    107. 

  107.  	int modifver;
    108. 

  108.  	int refs;
    109. 

  109. +#if (__FreeBSD__ >= 10)
    110. 

  110. +	pthread_mutex_t file_lock;
    111. 

  111. +#endif
    112. 

  112.  };
    113. 

  113.  
    114. 

  114.  struct sshfs {
    115. 

  115. @@ -208,6 +230,10 @@
    116. 

  116.  	int server_version;
    117. 

  117.  	unsigned remote_uid;
    118. 

  118.  	unsigned local_uid;
    119. 

  119. +#if (__FreeBSD__ >= 10)
    120. 

  120. +	unsigned remote_gid;
    121. 

  121. +	unsigned local_gid;
    122. 

  122. +#endif
    123. 

  123.  	int remote_uid_detected;
    124. 

  124.  	unsigned blksize;
    125. 

  125.  	char *progname;
    126. 

  126. @@ -641,8 +667,17 @@
    127. 

  127.  		}
    128. 

  128.  	}
    129. 

  129.  
    130. 

  130. +#if (__FreeBSD__ >= 10)
    131. 

  131. +	if (sshfs.remote_uid_detected) {
    132. 

  132. +		if (uid == sshfs.remote_uid)
    133. 

  133. +			uid = sshfs.local_uid;
    134. 

  134. +		if (gid == sshfs.remote_gid)
    135. 

  135. +			gid = sshfs.local_gid;
    136. 

  136. +	}
    137. 

  137. +#else
    138. 

  138.  	if (sshfs.remote_uid_detected && uid == sshfs.remote_uid)
    139. 

  139.  		uid = sshfs.local_uid;
    140. 

  140. +#endif
    141. 

  141.  
    142. 

  142.  	memset(stbuf, 0, sizeof(struct stat));
    143. 

  143.  	stbuf->st_mode = mode;
    144. 

  144. @@ -745,11 +780,33 @@
    145. 

  145.  #ifdef SSH_NODELAY_WORKAROUND
    146. 

  146.  static int do_ssh_nodelay_workaround(void)
    147. 

  147.  {
    148. 

  148. +#if (__FreeBSD__ >= 10)
    149. 

  149. +	char *oldpreload = getenv("DYLD_INSERT_LIBRARIES");
    150. 

  150. +#else
    151. 

  151.  	char *oldpreload = getenv("LD_PRELOAD");
    152. 

  152. +#endif
    153. 

  153.  	char *newpreload;
    154. 

  154.  	char sopath[PATH_MAX];
    155. 

  155.  	int res;
    156. 

  156.  
    157. 

  157. +#if (__FreeBSD__ >= 10)
    158. 

  158. +	char *sshfs_program_path_base = NULL;
    159. 

  159. +	if (!sshfs_program_path[0]) {
    160. 

  160. +		goto nobundle;
    161. 

  161. +	}
    162. 

  162. +	sshfs_program_path_base = dirname(sshfs_program_path);
    163. 

  163. +	if (!sshfs_program_path_base) {
    164. 

  164. +		goto nobundle;
    165. 

  165. +	}
    166. 

  166. +	snprintf(sopath, sizeof(sopath), "%s/%s", sshfs_program_path_base,
    167. 

  167. +		SSHNODELAY_SO);
    168. 

  168. +	res = access(sopath, R_OK);
    169. 

  169. +	if (res == -1) {
    170. 

  170. +		goto nobundle;
    171. 

  171. +	}
    172. 

  172. +	goto pathok;
    173. 

  173. +nobundle:
    174. 

  174. +#endif
    175. 

  175.  	snprintf(sopath, sizeof(sopath), "%s/%s", LIBDIR, SSHNODELAY_SO);
    176. 

  176.  	res = access(sopath, R_OK);
    177. 

  177.  	if (res == -1) {
    178. 

  178. @@ -774,16 +831,24 @@
    179. 

  179.  			return -1;
    180. 

  180.  		}
    181. 

  181.  	}
    182. 

  182. +#if (__FreeBSD__ >= 10)
    183. 

  183. +pathok:
    184. 

  184. +#endif
    185. 

  185.  
    186. 

  186.  	newpreload = g_strdup_printf("%s%s%s",
    187. 

  187.  				     oldpreload ? oldpreload : "",
    188. 

  188.  				     oldpreload ? " " : "",
    189. 

  189.  				     sopath);
    190. 

  190.  
    191. 

  191. +#if (__FreeBSD__ >= 10)
    192. 

  192. +	if (!newpreload || setenv("DYLD_INSERT_LIBRARIES", newpreload, 1) == -1)
    193. 

  193. +		fprintf(stderr, "warning: failed set DYLD_INSERT_LIBRARIES for ssh nodelay workaround\n");
    194. 

  194. +#else
    195. 

  195.  	if (!newpreload || setenv("LD_PRELOAD", newpreload, 1) == -1) {
    196. 

  196.  		fprintf(stderr, "warning: failed set LD_PRELOAD "
    197. 

  197.  			"for ssh nodelay workaround\n");
    198. 

  198.  	}
    199. 

  199. +#endif
    200. 

  200.  	g_free(newpreload);
    201. 

  201.  	return 0;
    202. 

  202.  }
    203. 

  203. @@ -1476,6 +1541,10 @@
    204. 

  204.  
    205. 

  205.  	sshfs.remote_uid = stbuf.st_uid;
    206. 

  206.  	sshfs.local_uid = getuid();
    207. 

  207. +#if (__FreeBSD__ >= 10)
    208. 

  208. +	sshfs.remote_gid = stbuf.st_gid;
    209. 

  209. +	sshfs.local_gid = getgid();
    210. 

  210. +#endif
    211. 

  211.  	sshfs.remote_uid_detected = 1;
    212. 

  212.  	DEBUG("remote_uid = %i\n", sshfs.remote_uid);
    213. 

  213.  
    214. 

  214. @@ -2070,6 +2139,14 @@
    215. 

  215.  	buf_init(&buf, 0);
    216. 

  216.  	buf_add_path(&buf, path);
    217. 

  217.  	buf_add_uint32(&buf, SSH_FILEXFER_ATTR_UIDGID);
    218. 

  218. +#if (__FreeBSD__ >= 10)
    219. 

  219. +	if (sshfs.remote_uid_detected) {
    220. 

  220. +		if (uid == sshfs.local_uid)
    221. 

  221. +			uid = sshfs.remote_uid;
    222. 

  222. +		if (gid == sshfs.local_gid)
    223. 

  223. +			gid = sshfs.remote_gid;
    224. 

  224. +	}
    225. 

  225. +#endif
    226. 

  226.  	buf_add_uint32(&buf, uid);
    227. 

  227.  	buf_add_uint32(&buf, gid);
    228. 

  228.  	err = sftp_request(SSH_FXP_SETSTAT, &buf, SSH_FXP_STATUS, NULL);
    229. 

  229. @@ -2153,6 +2230,9 @@
    230. 

  230.  	sf = g_new0(struct sshfs_file, 1);
    231. 

  231.  	list_init(&sf->write_reqs);
    232. 

  232.  	pthread_cond_init(&sf->write_finished, NULL);
    233. 

  233. +#if (__FreeBSD__ >= 10)
    234. 

  234. +	pthread_mutex_init(&sf->file_lock, NULL);
    235. 

  235. +#endif
    236. 

  236.  	/* Assume random read after open */
    237. 

  237.  	sf->is_seq = 0;
    238. 

  238.  	sf->refs = 1;
    239. 

  239. @@ -2186,11 +2266,21 @@
    240. 

  240.  	}
    241. 

  241.  
    242. 

  242.  	if (!err) {
    243. 

  243. +#if (__FreeBSD__ >= 10)
    244. 

  244. +		if (cache_enabled)
    245. 

  245. +			cache_add_attr(path, &stbuf, wrctr);
    246. 

  246. +#else
    247. 

  247.  		cache_add_attr(path, &stbuf, wrctr);
    248. 

  248. +#endif
    249. 

  249.  		buf_finish(&sf->handle);
    250. 

  250.  		fi->fh = (unsigned long) sf;
    251. 

  251.  	} else {
    252. 

  252. +#if (__FreeBSD__ >= 10)
    253. 

  253. +		if (cache_enabled)
    254. 

  254. +			cache_invalidate(path);
    255. 

  255. +#else
    256. 

  256.  		cache_invalidate(path);
    257. 

  257. +#endif
    258. 

  258.  		g_free(sf);
    259. 

  259.  	}
    260. 

  260.  	buf_free(&buf);
    261. 

  261. @@ -2245,14 +2335,32 @@
    262. 

  262.  
    263. 

  263.  static void sshfs_file_put(struct sshfs_file *sf)
    264. 

  264.  {
    265. 

  265. +#if (__FreeBSD__ >= 10)
    266. 

  266. +	pthread_mutex_lock(&sf->file_lock);
    267. 

  267. +#endif
    268. 

  268.  	sf->refs--;
    269. 

  269. +#if (__FreeBSD__ >= 10)
    270. 

  270. +	if (!sf->refs) {
    271. 

  271. +		pthread_mutex_unlock(&sf->file_lock);
    272. 

  272. +		g_free(sf);
    273. 

  273. +	} else {
    274. 

  274. +		pthread_mutex_unlock(&sf->file_lock);
    275. 

  275. +	}
    276. 

  276. +#else
    277. 

  277.  	if (!sf->refs)
    278. 

  278.  		g_free(sf);
    279. 

  279. +#endif
    280. 

  280.  }
    281. 

  281.  
    282. 

  282.  static void sshfs_file_get(struct sshfs_file *sf)
    283. 

  283.  {
    284. 

  284. +#if (__FreeBSD__ >= 10)
    285. 

  285. +	pthread_mutex_lock(&sf->file_lock);
    286. 

  286. +#endif
    287. 

  287.  	sf->refs++;
    288. 

  288. +#if (__FreeBSD__ >= 10)
    289. 

  289. +	pthread_mutex_unlock(&sf->file_lock);
    290. 

  290. +#endif
    291. 

  291.  }
    292. 

  292.  
    293. 

  293.  static int sshfs_release(const char *path, struct fuse_file_info *fi)
    294. 

  294. @@ -2942,7 +3050,12 @@
    295. 

  295.  		exit(1);
    296. 

  296.  
    297. 

  297.  	case KEY_VERSION:
    298. 

  298. +#if (__FreeBSD__ >= 10)
    299. 

  299. +		fprintf(stderr, "SSHFS version %s (MacFUSE SSHFS %s)\n",
    300. 

  300. +			PACKAGE_VERSION, MACFUSE_SSHFS_VERSION);
    301. 

  301. +#else
    302. 

  302.  		fprintf(stderr, "SSHFS version %s\n", PACKAGE_VERSION);
    303. 

  303. +#endif
    304. 

  304.  #if FUSE_VERSION >= 25
    305. 

  305.  		fuse_opt_add_arg(outargs, "--version");
    306. 

  306.  		sshfs_fuse_main(outargs);
    307. 

  307. @@ -3026,6 +3139,15 @@
    308. 

  308.  		perror("Failed to allocate locked page for password");
    309. 

  309.  		return -1;
    310. 

  310.  	}
    311. 

  311. +#if (__FreeBSD__ >= 10)
    312. 

  312. +	if (mlock(sshfs.password, size) != 0) {
    313. 

  313. +		memset(sshfs.password, 0, size);
    314. 

  314. +		munmap(sshfs.password, size);
    315. 

  315. +		sshfs.password = NULL;
    316. 

  316. +		perror("Failed to allocate locked page for password");
    317. 

  317. +		return -1;
    318. 

  318. +	}
    319. 

  319. +#endif /* __FreeBSD__ >= 10 */
    320. 

  320.  
    321. 

  321.  	/* Don't use fgets() because password might stay in memory */
    322. 

  322.  	for (n = 0; n < max_password; n++) {
    323. 

  323. @@ -3091,8 +3213,17 @@
    324. 

  324.  	}
    325. 

  325.  }
    326. 

  326.  
    327. 

  327. +#if (__FreeBSD__ >= 10)
    328. 

  328. +int main(int argc, char *argv[], __unused char *envp[], char **exec_path)
    329. 

  329. +#else
    330. 

  330.  int main(int argc, char *argv[])
    331. 

  331. +#endif
    332. 

  332.  {
    333. 

  333. +#if (__FreeBSD__ >= 10)
    334. 

  334. +	if (!realpath(*exec_path, sshfs_program_path)) {
    335. 

  335. +		memset(sshfs_program_path, 0, PATH_MAX);
    336. 

  336. +	}
    337. 

  337. +#endif
    338. 

  338.  	int res;
    339. 

  339.  	struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
    340. 

  340.  	char *tmp;
    341. 

  341. @@ -3101,6 +3232,10 @@
    342. 

  342.  	const char *sftp_server;
    343. 

  343.  	int libver;
    344. 

  344.  
    345. 

  345. +#if (__FreeBSD__ >= 10)
    346. 

  346. +	/* Until this gets fixed somewhere else. */
    347. 

  347. +	g_slice_set_config(G_SLICE_CONFIG_ALWAYS_MALLOC, TRUE);
    348. 

  348. +#endif /* __FreeBSD__ >= 10 */
    349. 

  349.  	g_thread_init(NULL);
    350. 

  350.  
    351. 

  351.  	sshfs.blksize = 4096;
    352. 

  352. @@ -3108,7 +3243,11 @@
    353. 

  353.  	sshfs.max_write = 65536;
    354. 

  354.  	sshfs.nodelay_workaround = 1;
    355. 

  355.  	sshfs.nodelaysrv_workaround = 0;
    356. 

  356. +#if (__FreeBSD__ >= 10)
    357. 

  357. +	sshfs.rename_workaround = 1;
    358. 

  358. +#else
    359. 

  359.  	sshfs.rename_workaround = 0;
    360. 

  360. +#endif /* __FreeBSD__ >= 10 */
    361. 

  361.  	sshfs.truncate_workaround = 0;
    362. 

  362.  	sshfs.buflimit_workaround = 1;
    363. 

  363.  	sshfs.ssh_ver = 2;
    364. 

  364. @@ -3121,6 +3260,10 @@
    365. 

  365.  	ssh_add_arg("-a");
    366. 

  366.  	ssh_add_arg("-oClearAllForwardings=yes");
    367. 

  367.  
    368. 

  368. +#if (__FreeBSD__ >= 10)
    369. 

  369. +	sshfs.detect_uid = 1;
    370. 

  370. +#endif
    371. 

  371. +
    372. 

  372.  	if (fuse_opt_parse(&args, &sshfs, sshfs_opts, sshfs_opt_proc) == -1 ||
    373. 

  373.  	    parse_workarounds() == -1)
    374. 

  374.  		exit(1);
    375. 

  375. diff -Naur old/sshnodelay.c new/sshnodelay.c
    376. 

  376. --- old/sshnodelay.c	2007-12-11 14:23:29.000000000 -0800
    377. 

  377. +++ new/sshnodelay.c	2008-07-14 18:14:32.000000000 -0700
    378. 

  378. @@ -5,6 +5,32 @@
    379. 

  379.  #include <netinet/in.h>
    380. 

  380.  #include <netinet/tcp.h>
    381. 

  381.  
    382. 

  382. +#if (__FreeBSD__ >= 10)
    383. 

  383. +
    384. 

  384. +int custom_connect(int sock, const struct sockaddr *addr, socklen_t addrlen);
    385. 

  385. +
    386. 

  386. +typedef struct interpose_s {
    387. 

  387. +	void *new_func;
    388. 

  388. +	void *orig_func;
    389. 

  389. +} interpose_t;
    390. 

  390. +
    391. 

  391. +static const interpose_t interposers[] \
    392. 

  392. +	__attribute__ ((section("__DATA, __interpose"))) = {
    393. 

  393. +	{ (void *)custom_connect,  (void *)connect  },
    394. 

  394. +};
    395. 

  395. +
    396. 

  396. +int custom_connect(int sock, const struct sockaddr *addr, socklen_t addrlen)
    397. 

  397. +{
    398. 

  398. +	int res = connect(sock, addr, addrlen);
    399. 

  399. +	if (!res && addr->sa_family == AF_INET) {
    400. 

  400. +		int opt = 1;
    401. 

  401. +		setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, &opt, sizeof(opt));
    402. 

  402. +	}
    403. 

  403. +	return res;
    404. 

  404. +}
    405. 

  405. +
    406. 

  406. +#else
    407. 

  407. +
    408. 

  408.  int connect(int sock, const struct sockaddr *addr, socklen_t addrlen)
    409. 

  409.  {
    410. 

  410.  	int (*next_connect)(int, const struct sockaddr *, socklen_t) =
    411. 

  411. @@ -16,3 +42,5 @@
    412. 

  412.  	}
    413. 

  413.  	return res;
    414. 

  414.  }
    415. 

  415. +
    416. 

  416. +#endif
    417.