repositories / deb_libnfs.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
libnfs: Add lstat
[deb_libnfs.git] / lib / libnfs-sync.c
... / ...
CommitLineData
1/*
2 Copyright (C) 2010 by Ronnie Sahlberg <ronniesahlberg@gmail.com>
3
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU Lesser General Public License as published by
6 the Free Software Foundation; either version 2.1 of the License, or
7 (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU Lesser General Public License for more details.
13
14 You should have received a copy of the GNU Lesser General Public License
15 along with this program; if not, see <http://www.gnu.org/licenses/>.
16*/
17/*
18 * High level api to nfs filesystems
19 */
20#ifdef HAVE_CONFIG_H
21#include "config.h"
22#endif
23
24#ifdef AROS
25#include "aros_compat.h"
26#endif
27
28#ifdef WIN32
29#include "win32_compat.h"
30#endif
31
32#ifdef HAVE_SYS_SOCKET_H
33#include <sys/socket.h>
34#endif
35
36#ifdef HAVE_NET_IF_H
37#include <net/if.h>
38#endif
39
40#ifdef ANDROID
41#define statvfs statfs
42#endif
43
44#ifdef HAVE_SYS_VFS_H
45#include <sys/vfs.h>
46#endif
47
48#ifdef HAVE_SYS_STATVFS_H
49#include <sys/statvfs.h>
50#endif
51
52#ifdef HAVE_SYS_IOCTL_H
53#include <sys/ioctl.h>
54#endif
55
56#ifdef HAVE_POLL_H
57#include <poll.h>
58#endif
59
60#ifdef HAVE_NETDB_H
61#include <netdb.h>
62#endif
63
64#ifdef HAVE_UNISTD_H
65#include <unistd.h>
66#endif
67
68#ifdef HAVE_NETINET_IN_H
69#include <netinet/in.h>
70#endif
71
72#ifdef HAVE_STRINGS_H
73#include <strings.h>
74#endif
75
76#include <stdio.h>
77#include <stdlib.h>
78#include <string.h>
79#include <assert.h>
80#include <sys/types.h>
81#include <sys/stat.h>
82#include <fcntl.h>
83#include <errno.h>
84
85#ifdef HAVE_SYS_SOCKIO_H
86#include <sys/sockio.h>
87#endif
88
89#include "libnfs-zdr.h"
90#include "libnfs.h"
91#include "libnfs-raw.h"
92#include "libnfs-raw-mount.h"
93#include "libnfs-raw-nfs.h"
94#include "libnfs-private.h"
95
96struct sync_cb_data {
97 int is_finished;
98 int status;
99 uint64_t offset;
100 void *return_data;
101 int return_int;
102 const char *call;
103};
104
105
106static void wait_for_reply(struct rpc_context *rpc, struct sync_cb_data *cb_data)
107{
108 struct pollfd pfd;
109
110 assert(rpc->magic == RPC_CONTEXT_MAGIC);
111
112 while (!cb_data->is_finished) {
113
114 pfd.fd = rpc_get_fd(rpc);
115 pfd.events = rpc_which_events(rpc);
116 if (poll(&pfd, 1, -1) < 0) {
117 rpc_set_error(rpc, "Poll failed");
118 cb_data->status = -EIO;
119 break;
120 }
121 if (rpc_service(rpc, pfd.revents) < 0) {
122 rpc_set_error(rpc, "rpc_service failed");
123 cb_data->status = -EIO;
124 break;
125 }
126 if (rpc_get_fd(rpc) == -1) {
127 rpc_set_error(rpc, "Socket closed\n");
128 break;
129 }
130 }
131}
132
133static void wait_for_nfs_reply(struct nfs_context *nfs, struct sync_cb_data *cb_data)
134{
135 struct pollfd pfd;
136
137 while (!cb_data->is_finished) {
138
139 pfd.fd = nfs_get_fd(nfs);
140 pfd.events = nfs_which_events(nfs);
141 if (poll(&pfd, 1, -1) < 0) {
142 nfs_set_error(nfs, "Poll failed");
143 cb_data->status = -EIO;
144 break;
145 }
146 if (nfs_service(nfs, pfd.revents) < 0) {
147 nfs_set_error(nfs, "nfs_service failed");
148 cb_data->status = -EIO;
149 break;
150 }
151 }
152}
153
154
155
156
157
158
159/*
160 * connect to the server and mount the export
161 */
162static void mount_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
163{
164 struct sync_cb_data *cb_data = private_data;
165
166 cb_data->is_finished = 1;
167 cb_data->status = status;
168
169 if (status < 0) {
170 nfs_set_error(nfs, "mount/mnt call failed with \"%s\"", (char *)data);
171 return;
172 }
173}
174
175int nfs_mount(struct nfs_context *nfs, const char *server, const char *export)
176{
177 struct sync_cb_data cb_data;
178 struct rpc_context *rpc = nfs_get_rpc_context(nfs);
179
180 assert(rpc->magic == RPC_CONTEXT_MAGIC);
181
182 cb_data.is_finished = 0;
183
184 if (nfs_mount_async(nfs, server, export, mount_cb, &cb_data) != 0) {
185 nfs_set_error(nfs, "nfs_mount_async failed");
186 return -1;
187 }
188
189 wait_for_nfs_reply(nfs, &cb_data);
190
191 /* Dont want any more callbacks even if the socket is closed */
192 rpc->connect_cb = NULL;
193
194 return cb_data.status;
195}
196
197
198/*
199 * stat()
200 */
201static void stat_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
202{
203 struct sync_cb_data *cb_data = private_data;
204
205 cb_data->is_finished = 1;
206 cb_data->status = status;
207
208 if (status < 0) {
209 nfs_set_error(nfs, "stat call failed with \"%s\"", (char *)data);
210 return;
211 }
212#ifdef WIN32
213 memcpy(cb_data->return_data, data, sizeof(struct __stat64));
214#else
215 memcpy(cb_data->return_data, data, sizeof(struct stat));
216#endif
217}
218
219#ifdef WIN32
220int nfs_stat(struct nfs_context *nfs, const char *path, struct __stat64 *st)
221#else
222int nfs_stat(struct nfs_context *nfs, const char *path, struct stat *st)
223#endif
224{
225 struct sync_cb_data cb_data;
226
227 cb_data.is_finished = 0;
228 cb_data.return_data = st;
229
230 if (nfs_stat_async(nfs, path, stat_cb, &cb_data) != 0) {
231 nfs_set_error(nfs, "nfs_stat_async failed");
232 return -1;
233 }
234
235 wait_for_nfs_reply(nfs, &cb_data);
236
237 return cb_data.status;
238}
239
240static void stat64_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
241{
242 struct sync_cb_data *cb_data = private_data;
243
244 cb_data->is_finished = 1;
245 cb_data->status = status;
246
247 if (status < 0) {
248 nfs_set_error(nfs, "stat call failed with \"%s\"", (char *)data);
249 return;
250 }
251 memcpy(cb_data->return_data, data, sizeof(struct nfs_stat_64));
252}
253
254int nfs_stat64(struct nfs_context *nfs, const char *path, struct nfs_stat_64 *st)
255{
256 struct sync_cb_data cb_data;
257
258 cb_data.is_finished = 0;
259 cb_data.return_data = st;
260
261 if (nfs_stat64_async(nfs, path, stat64_cb, &cb_data) != 0) {
262 nfs_set_error(nfs, "nfs_stat64_async failed");
263 return -1;
264 }
265
266 wait_for_nfs_reply(nfs, &cb_data);
267
268 return cb_data.status;
269}
270
271int nfs_lstat64(struct nfs_context *nfs, const char *path, struct nfs_stat_64 *st)
272{
273 struct sync_cb_data cb_data;
274
275 cb_data.is_finished = 0;
276 cb_data.return_data = st;
277
278 if (nfs_lstat64_async(nfs, path, stat64_cb, &cb_data) != 0) {
279 nfs_set_error(nfs, "nfs_lstat64_async failed");
280 return -1;
281 }
282
283 wait_for_nfs_reply(nfs, &cb_data);
284
285 return cb_data.status;
286}
287
288/*
289 * open()
290 */
291static void open_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
292{
293 struct sync_cb_data *cb_data = private_data;
294 struct nfsfh *fh, **nfsfh;
295
296 cb_data->is_finished = 1;
297 cb_data->status = status;
298
299 if (status < 0) {
300 nfs_set_error(nfs, "open call failed with \"%s\"", (char *)data);
301 return;
302 }
303
304 fh = data;
305 nfsfh = cb_data->return_data;
306 *nfsfh = fh;
307}
308
309int nfs_open(struct nfs_context *nfs, const char *path, int flags, struct nfsfh **nfsfh)
310{
311 struct sync_cb_data cb_data;
312
313 cb_data.is_finished = 0;
314 cb_data.return_data = nfsfh;
315
316 if (nfs_open_async(nfs, path, flags, open_cb, &cb_data) != 0) {
317 nfs_set_error(nfs, "nfs_open_async failed");
318 return -1;
319 }
320
321 wait_for_nfs_reply(nfs, &cb_data);
322
323 return cb_data.status;
324}
325
326/*
327 * chdir()
328 */
329static void chdir_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
330{
331 struct sync_cb_data *cb_data = private_data;
332
333 cb_data->is_finished = 1;
334 cb_data->status = status;
335
336 if (status < 0) {
337 nfs_set_error(nfs, "chdir call failed with \"%s\"", (char *)data);
338 return;
339 }
340}
341
342int nfs_chdir(struct nfs_context *nfs, const char *path)
343{
344 struct sync_cb_data cb_data;
345
346 cb_data.is_finished = 0;
347
348 if (nfs_chdir_async(nfs, path, chdir_cb, &cb_data) != 0) {
349 nfs_set_error(nfs, "nfs_chdir_async failed with %s",
350 nfs_get_error(nfs));
351 return -1;
352 }
353
354 wait_for_nfs_reply(nfs, &cb_data);
355
356 return cb_data.status;
357}
358
359
360
361/*
362 * pread()
363 */
364static void pread_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
365{
366 struct sync_cb_data *cb_data = private_data;
367 char *buffer;
368 cb_data->is_finished = 1;
369 cb_data->status = status;
370
371 if (status < 0) {
372 nfs_set_error(nfs, "%s call failed with \"%s\"", cb_data->call, (char *)data);
373 return;
374 }
375
376 buffer = cb_data->return_data;
377 memcpy(buffer, (char *)data, status);
378}
379
380int nfs_pread(struct nfs_context *nfs, struct nfsfh *nfsfh, uint64_t offset, uint64_t count, char *buffer)
381{
382 struct sync_cb_data cb_data;
383
384 cb_data.is_finished = 0;
385 cb_data.return_data = buffer;
386 cb_data.call = "pread";
387
388 if (nfs_pread_async(nfs, nfsfh, offset, count, pread_cb, &cb_data) != 0) {
389 nfs_set_error(nfs, "nfs_pread_async failed");
390 return -1;
391 }
392
393 wait_for_nfs_reply(nfs, &cb_data);
394
395 return cb_data.status;
396}
397
398/*
399 * read()
400 */
401int nfs_read(struct nfs_context *nfs, struct nfsfh *nfsfh, uint64_t count, char *buffer)
402{
403 struct sync_cb_data cb_data;
404
405 cb_data.is_finished = 0;
406 cb_data.return_data = buffer;
407 cb_data.call = "read";
408
409 if (nfs_read_async(nfs, nfsfh, count, pread_cb, &cb_data) != 0) {
410 nfs_set_error(nfs, "nfs_read_async failed");
411 return -1;
412 }
413
414 wait_for_nfs_reply(nfs, &cb_data);
415
416 return cb_data.status;
417}
418
419/*
420 * close()
421 */
422static void close_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
423{
424 struct sync_cb_data *cb_data = private_data;
425 cb_data->is_finished = 1;
426 cb_data->status = status;
427
428 if (status < 0) {
429 nfs_set_error(nfs, "close call failed with \"%s\"", (char *)data);
430 return;
431 }
432}
433
434int nfs_close(struct nfs_context *nfs, struct nfsfh *nfsfh)
435{
436 struct sync_cb_data cb_data;
437
438 cb_data.is_finished = 0;
439
440 if (nfs_close_async(nfs, nfsfh, close_cb, &cb_data) != 0) {
441 nfs_set_error(nfs, "nfs_close_async failed");
442 return -1;
443 }
444
445 wait_for_nfs_reply(nfs, &cb_data);
446
447 return cb_data.status;
448}
449
450
451
452
453/*
454 * fstat()
455 */
456int nfs_fstat(struct nfs_context *nfs, struct nfsfh *nfsfh, struct stat *st)
457{
458 struct sync_cb_data cb_data;
459
460 cb_data.is_finished = 0;
461 cb_data.return_data = st;
462
463 if (nfs_fstat_async(nfs, nfsfh, stat_cb, &cb_data) != 0) {
464 nfs_set_error(nfs, "nfs_fstat_async failed");
465 return -1;
466 }
467
468 wait_for_nfs_reply(nfs, &cb_data);
469
470 return cb_data.status;
471}
472
473/*
474 * fstat64()
475 */
476int nfs_fstat64(struct nfs_context *nfs, struct nfsfh *nfsfh, struct nfs_stat_64 *st)
477{
478 struct sync_cb_data cb_data;
479
480 cb_data.is_finished = 0;
481 cb_data.return_data = st;
482
483 if (nfs_fstat64_async(nfs, nfsfh, stat64_cb, &cb_data) != 0) {
484 nfs_set_error(nfs, "nfs_fstat64_async failed");
485 return -1;
486 }
487
488 wait_for_nfs_reply(nfs, &cb_data);
489
490 return cb_data.status;
491}
492
493
494/*
495 * pwrite()
496 */
497static void pwrite_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
498{
499 struct sync_cb_data *cb_data = private_data;
500 cb_data->is_finished = 1;
501 cb_data->status = status;
502
503 if (status < 0)
504 nfs_set_error(nfs, "%s call failed with \"%s\"", cb_data->call, (char *)data);
505}
506
507int nfs_pwrite(struct nfs_context *nfs, struct nfsfh *nfsfh, uint64_t offset, uint64_t count, char *buf)
508{
509 struct sync_cb_data cb_data;
510
511 cb_data.is_finished = 0;
512 cb_data.call = "pwrite";
513
514 if (nfs_pwrite_async(nfs, nfsfh, offset, count, buf, pwrite_cb, &cb_data) != 0) {
515 nfs_set_error(nfs, "nfs_pwrite_async failed");
516 return -1;
517 }
518
519 wait_for_nfs_reply(nfs, &cb_data);
520
521 return cb_data.status;
522}
523
524/*
525 * write()
526 */
527int nfs_write(struct nfs_context *nfs, struct nfsfh *nfsfh, uint64_t count, char *buf)
528{
529 struct sync_cb_data cb_data;
530
531 cb_data.is_finished = 0;
532 cb_data.call = "write";
533
534 if (nfs_write_async(nfs, nfsfh, count, buf, pwrite_cb, &cb_data) != 0) {
535 nfs_set_error(nfs, "nfs_write_async failed");
536 return -1;
537 }
538
539 wait_for_nfs_reply(nfs, &cb_data);
540
541 return cb_data.status;
542}
543
544
545/*
546 * fsync()
547 */
548static void fsync_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
549{
550 struct sync_cb_data *cb_data = private_data;
551 cb_data->is_finished = 1;
552 cb_data->status = status;
553
554 if (status < 0) {
555 nfs_set_error(nfs, "fsync call failed with \"%s\"", (char *)data);
556 return;
557 }
558}
559
560int nfs_fsync(struct nfs_context *nfs, struct nfsfh *nfsfh)
561{
562 struct sync_cb_data cb_data;
563
564 cb_data.is_finished = 0;
565
566 if (nfs_fsync_async(nfs, nfsfh, fsync_cb, &cb_data) != 0) {
567 nfs_set_error(nfs, "nfs_fsync_async failed");
568 return -1;
569 }
570
571 wait_for_nfs_reply(nfs, &cb_data);
572
573 return cb_data.status;
574}
575
576
577
578
579/*
580 * ftruncate()
581 */
582static void ftruncate_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
583{
584 struct sync_cb_data *cb_data = private_data;
585 cb_data->is_finished = 1;
586 cb_data->status = status;
587
588 if (status < 0) {
589 nfs_set_error(nfs, "ftruncate call failed with \"%s\"", (char *)data);
590 return;
591 }
592}
593
594int nfs_ftruncate(struct nfs_context *nfs, struct nfsfh *nfsfh, uint64_t length)
595{
596 struct sync_cb_data cb_data;
597
598 cb_data.is_finished = 0;
599
600 if (nfs_ftruncate_async(nfs, nfsfh, length, ftruncate_cb, &cb_data) != 0) {
601 nfs_set_error(nfs, "nfs_ftruncate_async failed");
602 return -1;
603 }
604
605 wait_for_nfs_reply(nfs, &cb_data);
606
607 return cb_data.status;
608}
609
610
611
612/*
613 * truncate()
614 */
615static void truncate_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
616{
617 struct sync_cb_data *cb_data = private_data;
618 cb_data->is_finished = 1;
619 cb_data->status = status;
620
621 if (status < 0) {
622 nfs_set_error(nfs, "truncate call failed with \"%s\"", (char *)data);
623 return;
624 }
625}
626
627int nfs_truncate(struct nfs_context *nfs, const char *path, uint64_t length)
628{
629 struct sync_cb_data cb_data;
630
631 cb_data.is_finished = 0;
632
633 if (nfs_truncate_async(nfs, path, length, truncate_cb, &cb_data) != 0) {
634 nfs_set_error(nfs, "nfs_ftruncate_async failed");
635 return -1;
636 }
637
638 wait_for_nfs_reply(nfs, &cb_data);
639
640 return cb_data.status;
641}
642
643
644
645
646
647/*
648 * mkdir()
649 */
650static void mkdir_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
651{
652 struct sync_cb_data *cb_data = private_data;
653 cb_data->is_finished = 1;
654 cb_data->status = status;
655
656 if (status < 0) {
657 nfs_set_error(nfs, "mkdir call failed with \"%s\"", (char *)data);
658 return;
659 }
660}
661
662int nfs_mkdir(struct nfs_context *nfs, const char *path)
663{
664 struct sync_cb_data cb_data;
665
666 cb_data.is_finished = 0;
667
668 if (nfs_mkdir_async(nfs, path, mkdir_cb, &cb_data) != 0) {
669 nfs_set_error(nfs, "nfs_mkdir_async failed");
670 return -1;
671 }
672
673 wait_for_nfs_reply(nfs, &cb_data);
674
675 return cb_data.status;
676}
677
678
679
680
681
682/*
683 * rmdir()
684 */
685static void rmdir_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
686{
687 struct sync_cb_data *cb_data = private_data;
688 cb_data->is_finished = 1;
689 cb_data->status = status;
690
691 if (status < 0) {
692 nfs_set_error(nfs, "rmdir call failed with \"%s\"", (char *)data);
693 return;
694 }
695}
696
697int nfs_rmdir(struct nfs_context *nfs, const char *path)
698{
699 struct sync_cb_data cb_data;
700
701 cb_data.is_finished = 0;
702
703 if (nfs_rmdir_async(nfs, path, rmdir_cb, &cb_data) != 0) {
704 nfs_set_error(nfs, "nfs_rmdir_async failed");
705 return -1;
706 }
707
708 wait_for_nfs_reply(nfs, &cb_data);
709
710 return cb_data.status;
711}
712
713
714
715/*
716 * creat()
717 */
718static void creat_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
719{
720 struct sync_cb_data *cb_data = private_data;
721 struct nfsfh *fh, **nfsfh;
722
723 cb_data->is_finished = 1;
724 cb_data->status = status;
725
726 if (status < 0) {
727 nfs_set_error(nfs, "creat call failed with \"%s\"", (char *)data);
728 return;
729 }
730
731 fh = data;
732 nfsfh = cb_data->return_data;
733 *nfsfh = fh;
734}
735
736int nfs_create(struct nfs_context *nfs, const char *path, int flags, int mode, struct nfsfh **nfsfh)
737{
738 struct sync_cb_data cb_data;
739
740 cb_data.is_finished = 0;
741 cb_data.return_data = nfsfh;
742
743 if (nfs_create_async(nfs, path, flags, mode, creat_cb, &cb_data) != 0) {
744 nfs_set_error(nfs, "nfs_create_async failed");
745 return -1;
746 }
747
748 wait_for_nfs_reply(nfs, &cb_data);
749
750 return cb_data.status;
751}
752
753int nfs_creat(struct nfs_context *nfs, const char *path, int mode, struct nfsfh **nfsfh)
754{
755 return nfs_create(nfs, path, 0, mode, nfsfh);
756}
757
758/*
759 * mknod()
760 */
761static void mknod_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
762{
763 struct sync_cb_data *cb_data = private_data;
764
765 cb_data->is_finished = 1;
766 cb_data->status = status;
767
768 if (status < 0) {
769 nfs_set_error(nfs, "mknod call failed with \"%s\"", (char *)data);
770 return;
771 }
772}
773
774int nfs_mknod(struct nfs_context *nfs, const char *path, int mode, int dev)
775{
776 struct sync_cb_data cb_data;
777
778 cb_data.is_finished = 0;
779
780 if (nfs_mknod_async(nfs, path, mode, dev, mknod_cb, &cb_data) != 0) {
781 nfs_set_error(nfs, "nfs_creat_async failed");
782 return -1;
783 }
784
785 wait_for_nfs_reply(nfs, &cb_data);
786
787 return cb_data.status;
788}
789
790
791/*
792 * unlink()
793 */
794static void unlink_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
795{
796 struct sync_cb_data *cb_data = private_data;
797
798 cb_data->is_finished = 1;
799 cb_data->status = status;
800
801 if (status < 0) {
802 nfs_set_error(nfs, "unlink call failed with \"%s\"", (char *)data);
803 return;
804 }
805}
806
807int nfs_unlink(struct nfs_context *nfs, const char *path)
808{
809 struct sync_cb_data cb_data;
810
811 cb_data.is_finished = 0;
812
813 if (nfs_unlink_async(nfs, path, unlink_cb, &cb_data) != 0) {
814 nfs_set_error(nfs, "nfs_unlink_async failed");
815 return -1;
816 }
817
818 wait_for_nfs_reply(nfs, &cb_data);
819
820 return cb_data.status;
821}
822
823
824
825/*
826 * opendir()
827 */
828static void opendir_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
829{
830 struct sync_cb_data *cb_data = private_data;
831 struct nfsdir *dir, **nfsdir;
832
833 cb_data->is_finished = 1;
834 cb_data->status = status;
835
836 if (status < 0) {
837 nfs_set_error(nfs, "opendir call failed with \"%s\"", (char *)data);
838 return;
839 }
840
841 dir = data;
842 nfsdir = cb_data->return_data;
843 *nfsdir = dir;
844}
845
846int nfs_opendir(struct nfs_context *nfs, const char *path, struct nfsdir **nfsdir)
847{
848 struct sync_cb_data cb_data;
849
850 cb_data.is_finished = 0;
851 cb_data.return_data = nfsdir;
852
853 if (nfs_opendir_async(nfs, path, opendir_cb, &cb_data) != 0) {
854 nfs_set_error(nfs, "nfs_opendir_async failed");
855 return -1;
856 }
857
858 wait_for_nfs_reply(nfs, &cb_data);
859
860 return cb_data.status;
861}
862
863
864/*
865 * lseek()
866 */
867static void lseek_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
868{
869 struct sync_cb_data *cb_data = private_data;
870
871 cb_data->is_finished = 1;
872 cb_data->status = status;
873
874 if (status < 0) {
875 nfs_set_error(nfs, "lseek call failed with \"%s\"", (char *)data);
876 return;
877 }
878
879 if (cb_data->return_data != NULL) {
880 memcpy(cb_data->return_data, data, sizeof(uint64_t));
881 }
882}
883
884int nfs_lseek(struct nfs_context *nfs, struct nfsfh *nfsfh, int64_t offset, int whence, uint64_t *current_offset)
885{
886 struct sync_cb_data cb_data;
887
888 cb_data.is_finished = 0;
889 cb_data.return_data = current_offset;
890
891 if (nfs_lseek_async(nfs, nfsfh, offset, whence, lseek_cb, &cb_data) != 0) {
892 nfs_set_error(nfs, "nfs_lseek_async failed");
893 return -1;
894 }
895
896 wait_for_nfs_reply(nfs, &cb_data);
897
898 return cb_data.status;
899}
900
901
902
903/*
904 * statvfs()
905 */
906static void statvfs_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
907{
908 struct sync_cb_data *cb_data = private_data;
909
910 cb_data->is_finished = 1;
911 cb_data->status = status;
912
913 if (status < 0) {
914 nfs_set_error(nfs, "statvfs call failed with \"%s\"", (char *)data);
915 return;
916 }
917
918 memcpy(cb_data->return_data, data, sizeof(struct statvfs));
919}
920
921int nfs_statvfs(struct nfs_context *nfs, const char *path, struct statvfs *svfs)
922{
923 struct sync_cb_data cb_data;
924
925 cb_data.is_finished = 0;
926 cb_data.return_data = svfs;
927
928 if (nfs_statvfs_async(nfs, path, statvfs_cb, &cb_data) != 0) {
929 nfs_set_error(nfs, "nfs_statvfs_async failed");
930 return -1;
931 }
932
933 wait_for_nfs_reply(nfs, &cb_data);
934
935 return cb_data.status;
936}
937
938
939
940
941
942/*
943 * readlink()
944 */
945static void readlink_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
946{
947 struct sync_cb_data *cb_data = private_data;
948
949 cb_data->is_finished = 1;
950 cb_data->status = status;
951
952 if (status < 0) {
953 nfs_set_error(nfs, "readlink call failed with \"%s\"", (char *)data);
954 return;
955 }
956
957 if (strlen(data) > (size_t)cb_data->return_int) {
958 nfs_set_error(nfs, "Too small buffer for readlink");
959 cb_data->status = -ENAMETOOLONG;
960 return;
961 }
962
963 memcpy(cb_data->return_data, data, strlen(data)+1);
964}
965
966int nfs_readlink(struct nfs_context *nfs, const char *path, char *buf, int bufsize)
967{
968 struct sync_cb_data cb_data;
969
970 cb_data.is_finished = 0;
971 cb_data.return_data = buf;
972 cb_data.return_int = bufsize;
973
974 if (nfs_readlink_async(nfs, path, readlink_cb, &cb_data) != 0) {
975 nfs_set_error(nfs, "nfs_readlink_async failed");
976 return -1;
977 }
978
979 wait_for_nfs_reply(nfs, &cb_data);
980
981 return cb_data.status;
982}
983
984
985
986/*
987 * chmod()
988 */
989static void chmod_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
990{
991 struct sync_cb_data *cb_data = private_data;
992
993 cb_data->is_finished = 1;
994 cb_data->status = status;
995
996 if (status < 0) {
997 nfs_set_error(nfs, "chmod call failed with \"%s\"", (char *)data);
998 return;
999 }
1000}
1001
1002int nfs_chmod(struct nfs_context *nfs, const char *path, int mode)
1003{
1004 struct sync_cb_data cb_data;
1005
1006 cb_data.is_finished = 0;
1007
1008 if (nfs_chmod_async(nfs, path, mode, chmod_cb, &cb_data) != 0) {
1009 nfs_set_error(nfs, "nfs_chmod_async failed");
1010 return -1;
1011 }
1012
1013 wait_for_nfs_reply(nfs, &cb_data);
1014
1015 return cb_data.status;
1016}
1017
1018
1019
1020
1021/*
1022 * fchmod()
1023 */
1024static void fchmod_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
1025{
1026 struct sync_cb_data *cb_data = private_data;
1027
1028 cb_data->is_finished = 1;
1029 cb_data->status = status;
1030
1031 if (status < 0) {
1032 nfs_set_error(nfs, "fchmod call failed with \"%s\"", (char *)data);
1033 return;
1034 }
1035}
1036
1037int nfs_fchmod(struct nfs_context *nfs, struct nfsfh *nfsfh, int mode)
1038{
1039 struct sync_cb_data cb_data;
1040
1041 cb_data.is_finished = 0;
1042
1043 if (nfs_fchmod_async(nfs, nfsfh, mode, fchmod_cb, &cb_data) != 0) {
1044 nfs_set_error(nfs, "nfs_fchmod_async failed");
1045 return -1;
1046 }
1047
1048 wait_for_nfs_reply(nfs, &cb_data);
1049
1050 return cb_data.status;
1051}
1052
1053
1054
1055
1056/*
1057 * chown()
1058 */
1059static void chown_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
1060{
1061 struct sync_cb_data *cb_data = private_data;
1062
1063 cb_data->is_finished = 1;
1064 cb_data->status = status;
1065
1066 if (status < 0) {
1067 nfs_set_error(nfs, "chown call failed with \"%s\"", (char *)data);
1068 return;
1069 }
1070}
1071
1072int nfs_chown(struct nfs_context *nfs, const char *path, int uid, int gid)
1073{
1074 struct sync_cb_data cb_data;
1075
1076 cb_data.is_finished = 0;
1077
1078 if (nfs_chown_async(nfs, path, uid, gid, chown_cb, &cb_data) != 0) {
1079 nfs_set_error(nfs, "nfs_chown_async failed");
1080 return -1;
1081 }
1082
1083 wait_for_nfs_reply(nfs, &cb_data);
1084
1085 return cb_data.status;
1086}
1087
1088/*
1089 * lchown()
1090 */
1091int nfs_lchown(struct nfs_context *nfs, const char *path, int uid, int gid)
1092{
1093 struct sync_cb_data cb_data;
1094
1095 cb_data.is_finished = 0;
1096
1097 if (nfs_lchown_async(nfs, path, uid, gid, chown_cb, &cb_data) != 0) {
1098 nfs_set_error(nfs, "nfs_lchown_async failed");
1099 return -1;
1100 }
1101
1102 wait_for_nfs_reply(nfs, &cb_data);
1103
1104 return cb_data.status;
1105}
1106
1107/*
1108 * fchown()
1109 */
1110static void fchown_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
1111{
1112 struct sync_cb_data *cb_data = private_data;
1113
1114 cb_data->is_finished = 1;
1115 cb_data->status = status;
1116
1117 if (status < 0) {
1118 nfs_set_error(nfs, "fchown call failed with \"%s\"", (char *)data);
1119 return;
1120 }
1121}
1122
1123int nfs_fchown(struct nfs_context *nfs, struct nfsfh *nfsfh, int uid, int gid)
1124{
1125 struct sync_cb_data cb_data;
1126
1127 cb_data.is_finished = 0;
1128
1129 if (nfs_fchown_async(nfs, nfsfh, uid, gid, fchown_cb, &cb_data) != 0) {
1130 nfs_set_error(nfs, "nfs_fchown_async failed");
1131 return -1;
1132 }
1133
1134 wait_for_nfs_reply(nfs, &cb_data);
1135
1136 return cb_data.status;
1137}
1138
1139
1140
1141/*
1142 * utimes()
1143 */
1144static void utimes_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
1145{
1146 struct sync_cb_data *cb_data = private_data;
1147
1148 cb_data->is_finished = 1;
1149 cb_data->status = status;
1150
1151 if (status < 0) {
1152 nfs_set_error(nfs, "utimes call failed with \"%s\"", (char *)data);
1153 return;
1154 }
1155}
1156
1157int nfs_utimes(struct nfs_context *nfs, const char *path, struct timeval *times)
1158{
1159 struct sync_cb_data cb_data;
1160
1161 cb_data.is_finished = 0;
1162
1163 if (nfs_utimes_async(nfs, path, times, utimes_cb, &cb_data) != 0) {
1164 nfs_set_error(nfs, "nfs_utimes_async failed");
1165 return -1;
1166 }
1167
1168 wait_for_nfs_reply(nfs, &cb_data);
1169
1170 return cb_data.status;
1171}
1172
1173
1174
1175/*
1176 * utime()
1177 */
1178static void utime_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
1179{
1180 struct sync_cb_data *cb_data = private_data;
1181
1182 cb_data->is_finished = 1;
1183 cb_data->status = status;
1184
1185 if (status < 0) {
1186 nfs_set_error(nfs, "utime call failed with \"%s\"", (char *)data);
1187 return;
1188 }
1189}
1190
1191int nfs_utime(struct nfs_context *nfs, const char *path, struct utimbuf *times)
1192{
1193 struct sync_cb_data cb_data;
1194
1195 cb_data.is_finished = 0;
1196
1197 if (nfs_utime_async(nfs, path, times, utime_cb, &cb_data) != 0) {
1198 nfs_set_error(nfs, "nfs_utimes_async failed");
1199 return -1;
1200 }
1201
1202 wait_for_nfs_reply(nfs, &cb_data);
1203
1204 return cb_data.status;
1205}
1206
1207
1208
1209
1210/*
1211 * access()
1212 */
1213static void access_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
1214{
1215 struct sync_cb_data *cb_data = private_data;
1216
1217 cb_data->is_finished = 1;
1218 cb_data->status = status;
1219
1220 if (status < 0) {
1221 nfs_set_error(nfs, "access call failed with \"%s\"", (char *)data);
1222 return;
1223 }
1224}
1225
1226int nfs_access(struct nfs_context *nfs, const char *path, int mode)
1227{
1228 struct sync_cb_data cb_data;
1229
1230 cb_data.is_finished = 0;
1231
1232 if (nfs_access_async(nfs, path, mode, access_cb, &cb_data) != 0) {
1233 nfs_set_error(nfs, "nfs_access_async failed");
1234 return -1;
1235 }
1236
1237 wait_for_nfs_reply(nfs, &cb_data);
1238
1239 return cb_data.status;
1240}
1241
1242
1243
1244/*
1245 * symlink()
1246 */
1247static void symlink_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
1248{
1249 struct sync_cb_data *cb_data = private_data;
1250
1251 cb_data->is_finished = 1;
1252 cb_data->status = status;
1253
1254 if (status < 0) {
1255 nfs_set_error(nfs, "symlink call failed with \"%s\"", (char *)data);
1256 return;
1257 }
1258}
1259
1260int nfs_symlink(struct nfs_context *nfs, const char *oldpath, const char *newpath)
1261{
1262 struct sync_cb_data cb_data;
1263
1264 cb_data.is_finished = 0;
1265
1266 if (nfs_symlink_async(nfs, oldpath, newpath, symlink_cb, &cb_data) != 0) {
1267 nfs_set_error(nfs, "nfs_symlink_async failed");
1268 return -1;
1269 }
1270
1271 wait_for_nfs_reply(nfs, &cb_data);
1272
1273 return cb_data.status;
1274}
1275
1276
1277
1278/*
1279 * rename()
1280 */
1281static void rename_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
1282{
1283 struct sync_cb_data *cb_data = private_data;
1284
1285 cb_data->is_finished = 1;
1286 cb_data->status = status;
1287
1288 if (status < 0) {
1289 nfs_set_error(nfs, "rename call failed with \"%s\"", (char *)data);
1290 return;
1291 }
1292}
1293
1294int nfs_rename(struct nfs_context *nfs, const char *oldpath, const char *newpath)
1295{
1296 struct sync_cb_data cb_data;
1297
1298 cb_data.is_finished = 0;
1299
1300 if (nfs_rename_async(nfs, oldpath, newpath, rename_cb, &cb_data) != 0) {
1301 nfs_set_error(nfs, "nfs_rename_async failed");
1302 return -1;
1303 }
1304
1305 wait_for_nfs_reply(nfs, &cb_data);
1306
1307 return cb_data.status;
1308}
1309
1310
1311
1312/*
1313 * link()
1314 */
1315static void link_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
1316{
1317 struct sync_cb_data *cb_data = private_data;
1318
1319 cb_data->is_finished = 1;
1320 cb_data->status = status;
1321
1322 if (status < 0) {
1323 nfs_set_error(nfs, "link call failed with \"%s\"", (char *)data);
1324 return;
1325 }
1326}
1327
1328int nfs_link(struct nfs_context *nfs, const char *oldpath, const char *newpath)
1329{
1330 struct sync_cb_data cb_data;
1331
1332 cb_data.is_finished = 0;
1333
1334 if (nfs_link_async(nfs, oldpath, newpath, link_cb, &cb_data) != 0) {
1335 nfs_set_error(nfs, "nfs_link_async failed");
1336 return -1;
1337 }
1338
1339 wait_for_nfs_reply(nfs, &cb_data);
1340
1341 return cb_data.status;
1342}
1343
1344void mount_getexports_cb(struct rpc_context *mount_context, int status, void *data, void *private_data)
1345{
1346 struct sync_cb_data *cb_data = private_data;
1347 exports export;
1348
1349 assert(mount_context->magic == RPC_CONTEXT_MAGIC);
1350
1351 cb_data->is_finished = 1;
1352 cb_data->status = status;
1353 cb_data->return_data = NULL;
1354
1355 if (status != 0) {
1356 rpc_set_error(mount_context, "mount/export call failed with \"%s\"", (char *)data);
1357 return;
1358 }
1359
1360 export = *(exports *)data;
1361 while (export != NULL) {
1362 exports new_export;
1363
1364 new_export = malloc(sizeof(*new_export));
1365 memset(new_export, 0, sizeof(*new_export));
1366 new_export->ex_dir = strdup(export->ex_dir);
1367 new_export->ex_next = cb_data->return_data;
1368
1369 cb_data->return_data = new_export;
1370
1371 export = export->ex_next;
1372 }
1373}
1374
1375struct exportnode *mount_getexports(const char *server)
1376{
1377 struct sync_cb_data cb_data;
1378 struct rpc_context *rpc;
1379
1380
1381 cb_data.is_finished = 0;
1382 cb_data.return_data = NULL;
1383
1384 rpc = rpc_init_context();
1385 if (mount_getexports_async(rpc, server, mount_getexports_cb, &cb_data) != 0) {
1386 rpc_destroy_context(rpc);
1387 return NULL;
1388 }
1389
1390 wait_for_reply(rpc, &cb_data);
1391 rpc_destroy_context(rpc);
1392
1393 return cb_data.return_data;
1394}
1395
1396void mount_free_export_list(struct exportnode *exports)
1397{
1398 struct exportnode *tmp;
1399
1400 while ((tmp = exports)) {
1401 exports = exports->ex_next;
1402 free(tmp->ex_dir);
1403 free(tmp);
1404 }
1405}
1406
1407
1408
1409void free_nfs_srvr_list(struct nfs_server_list *srv)
1410{
1411 while (srv != NULL) {
1412 struct nfs_server_list *next = srv->next;
1413
1414 free(srv->addr);
1415 free(srv);
1416 srv = next;
1417 }
1418}
1419
1420struct nfs_list_data {
1421 int status;
1422 struct nfs_server_list *srvrs;
1423};
1424
1425void callit_cb(struct rpc_context *rpc, int status, void *data _U_, void *private_data)
1426{
1427 struct nfs_list_data *srv_data = private_data;
1428 struct sockaddr *sin;
1429 char hostdd[16];
1430 struct nfs_server_list *srvr;
1431
1432 assert(rpc->magic == RPC_CONTEXT_MAGIC);
1433
1434 if (status == RPC_STATUS_CANCEL) {
1435 return;
1436 }
1437 if (status != 0) {
1438 srv_data->status = -1;
1439 return;
1440 }
1441
1442 sin = rpc_get_recv_sockaddr(rpc);
1443 if (sin == NULL) {
1444 rpc_set_error(rpc, "failed to get sockaddr in CALLIT callback");
1445 srv_data->status = -1;
1446 return;
1447 }
1448
1449 if (getnameinfo(sin, sizeof(struct sockaddr_in), &hostdd[0], sizeof(hostdd), NULL, 0, NI_NUMERICHOST) < 0) {
1450 rpc_set_error(rpc, "getnameinfo failed in CALLIT callback");
1451 srv_data->status = -1;
1452 return;
1453 }
1454
1455 /* check for dupes */
1456 for (srvr = srv_data->srvrs; srvr; srvr = srvr->next) {
1457 if (!strcmp(hostdd, srvr->addr)) {
1458 return;
1459 }
1460 }
1461
1462 srvr = malloc(sizeof(struct nfs_server_list));
1463 if (srvr == NULL) {
1464 rpc_set_error(rpc, "Malloc failed when allocating server structure");
1465 srv_data->status = -1;
1466 return;
1467 }
1468
1469 srvr->addr = strdup(hostdd);
1470 if (srvr->addr == NULL) {
1471 rpc_set_error(rpc, "Strdup failed when allocating server structure");
1472 free(srvr);
1473 srv_data->status = -1;
1474 return;
1475 }
1476
1477 srvr->next = srv_data->srvrs;
1478 srv_data->srvrs = srvr;
1479}
1480
1481#ifdef WIN32
1482
1483static int send_nfsd_probes(struct rpc_context *rpc, INTERFACE_INFO *InterfaceList, int numIfs, struct nfs_list_data *data)
1484{
1485 int i=0;
1486
1487 assert(rpc->magic == RPC_CONTEXT_MAGIC);
1488
1489 for(i = 0; i < numIfs; i++)
1490 {
1491 SOCKADDR *pAddress;
1492 char bcdd[16];
1493 unsigned long nFlags = 0;
1494
1495 pAddress = (SOCKADDR *) & (InterfaceList[i].iiBroadcastAddress);
1496
1497 if(pAddress->sa_family != AF_INET)
1498 continue;
1499
1500 nFlags = InterfaceList[i].iiFlags;
1501
1502 if (!(nFlags & IFF_UP))
1503 {
1504 continue;
1505 }
1506
1507 if (nFlags & IFF_LOOPBACK)
1508 {
1509 continue;
1510 }
1511
1512 if (!(nFlags & IFF_BROADCAST))
1513 {
1514 continue;
1515 }
1516
1517 if (getnameinfo(pAddress, sizeof(struct sockaddr_in), &bcdd[0], sizeof(bcdd), NULL, 0, NI_NUMERICHOST) < 0)
1518 {
1519 continue;
1520 }
1521
1522 if (rpc_set_udp_destination(rpc, bcdd, 111, 1) < 0)
1523 {
1524 return -1;
1525 }
1526
1527 if (rpc_pmap2_callit_async(rpc, MOUNT_PROGRAM, 2, 0, NULL, 0, callit_cb, data) < 0)
1528 {
1529 return -1;
1530 }
1531 }
1532 return 0;
1533}
1534
1535struct nfs_server_list *nfs_find_local_servers(void)
1536{
1537 struct rpc_context *rpc;
1538 struct nfs_list_data data = {0, NULL};
1539 struct timeval tv_start, tv_current;
1540 int loop;
1541 struct pollfd pfd;
1542 INTERFACE_INFO InterfaceList[20];
1543 unsigned long nBytesReturned;
1544 int nNumInterfaces = 0;
1545
1546 rpc = rpc_init_udp_context();
1547 if (rpc == NULL)
1548 {
1549 return NULL;
1550 }
1551
1552 if (rpc_bind_udp(rpc, "0.0.0.0", 0) < 0)
1553 {
1554 rpc_destroy_context(rpc);
1555 return NULL;
1556 }
1557
1558 if (WSAIoctl(rpc_get_fd(rpc), SIO_GET_INTERFACE_LIST, 0, 0, &InterfaceList, sizeof(InterfaceList), &nBytesReturned, 0, 0) == SOCKET_ERROR)
1559 {
1560 return NULL;
1561 }
1562
1563 nNumInterfaces = nBytesReturned / sizeof(INTERFACE_INFO);
1564
1565 for (loop=0; loop<3; loop++)
1566 {
1567 if (send_nfsd_probes(rpc, InterfaceList, nNumInterfaces, &data) != 0)
1568 {
1569 rpc_destroy_context(rpc);
1570 return NULL;
1571 }
1572
1573 win32_gettimeofday(&tv_start, NULL);
1574 for(;;)
1575 {
1576 int mpt;
1577
1578 pfd.fd = rpc_get_fd(rpc);
1579 pfd.events = rpc_which_events(rpc);
1580
1581 win32_gettimeofday(&tv_current, NULL);
1582 mpt = 1000
1583 - (tv_current.tv_sec *1000 + tv_current.tv_usec / 1000)
1584 + (tv_start.tv_sec *1000 + tv_start.tv_usec / 1000);
1585
1586 if (poll(&pfd, 1, mpt) < 0)
1587 {
1588 free_nfs_srvr_list(data.srvrs);
1589 rpc_destroy_context(rpc);
1590 return NULL;
1591 }
1592 if (pfd.revents == 0)
1593 {
1594 break;
1595 }
1596
1597 if (rpc_service(rpc, pfd.revents) < 0)
1598 {
1599 break;
1600 }
1601 }
1602 }
1603
1604 rpc_destroy_context(rpc);
1605
1606 if (data.status != 0)
1607 {
1608 free_nfs_srvr_list(data.srvrs);
1609 return NULL;
1610 }
1611 return data.srvrs;
1612}
1613#else
1614
1615static int send_nfsd_probes(struct rpc_context *rpc, struct ifconf *ifc, struct nfs_list_data *data)
1616{
1617 char *ptr;
1618
1619 assert(rpc->magic == RPC_CONTEXT_MAGIC);
1620
1621 for (ptr =(char *)(ifc->ifc_buf); ptr < (char *)(ifc->ifc_buf) + ifc->ifc_len; ) {
1622 struct ifreq *ifr;
1623 char bcdd[16];
1624
1625 ifr = (struct ifreq *)ptr;
1626#ifdef HAVE_SOCKADDR_LEN
1627 if (ifr->ifr_addr.sa_len > sizeof(struct sockaddr)) {
1628 ptr += sizeof(ifr->ifr_name) + ifr->ifr_addr.sa_len;
1629 } else {
1630 ptr += sizeof(ifr->ifr_name) + sizeof(struct sockaddr);
1631 }
1632#else
1633 ptr += sizeof(struct ifreq);
1634#endif
1635
1636 if (ifr->ifr_addr.sa_family != AF_INET) {
1637 continue;
1638 }
1639 if (ioctl(rpc_get_fd(rpc), SIOCGIFFLAGS, ifr) < 0) {
1640 return -1;
1641 }
1642 if (!(ifr->ifr_flags & IFF_UP)) {
1643 continue;
1644 }
1645 if (ifr->ifr_flags & IFF_LOOPBACK) {
1646 continue;
1647 }
1648 if (!(ifr->ifr_flags & IFF_BROADCAST)) {
1649 continue;
1650 }
1651 if (ioctl(rpc_get_fd(rpc), SIOCGIFBRDADDR, ifr) < 0) {
1652 continue;
1653 }
1654 if (getnameinfo(&ifr->ifr_broadaddr, sizeof(struct sockaddr_in), &bcdd[0], sizeof(bcdd), NULL, 0, NI_NUMERICHOST) < 0) {
1655 continue;
1656 }
1657 if (rpc_set_udp_destination(rpc, bcdd, 111, 1) < 0) {
1658 return -1;
1659 }
1660
1661 if (rpc_pmap2_callit_async(rpc, MOUNT_PROGRAM, 2, 0, NULL, 0, callit_cb, data) < 0) {
1662 return -1;
1663 }
1664 }
1665
1666 return 0;
1667}
1668
1669struct nfs_server_list *nfs_find_local_servers(void)
1670{
1671 struct rpc_context *rpc;
1672 struct nfs_list_data data = {0, NULL};
1673 struct timeval tv_start, tv_current;
1674 struct ifconf ifc;
1675 int size, loop;
1676 struct pollfd pfd;
1677
1678 rpc = rpc_init_udp_context();
1679 if (rpc == NULL) {
1680 return NULL;
1681 }
1682
1683 if (rpc_bind_udp(rpc, "0.0.0.0", 0) < 0) {
1684 rpc_destroy_context(rpc);
1685 return NULL;
1686 }
1687
1688
1689 /* get list of all interfaces */
1690 size = sizeof(struct ifreq);
1691 ifc.ifc_buf = NULL;
1692 ifc.ifc_len = size;
1693
1694 while(ifc.ifc_len > (size - sizeof(struct ifreq))) {
1695 size *= 2;
1696
1697 free(ifc.ifc_buf);
1698 ifc.ifc_len = size;
1699 ifc.ifc_buf = malloc(size);
1700 memset(ifc.ifc_buf, 0, size);
1701 if (ioctl(rpc_get_fd(rpc), SIOCGIFCONF, (caddr_t)&ifc) < 0) {
1702 rpc_destroy_context(rpc);
1703 free(ifc.ifc_buf);
1704 return NULL;
1705 }
1706 }
1707
1708 for (loop=0; loop<3; loop++) {
1709 if (send_nfsd_probes(rpc, &ifc, &data) != 0) {
1710 rpc_destroy_context(rpc);
1711 free(ifc.ifc_buf);
1712 return NULL;
1713 }
1714
1715 gettimeofday(&tv_start, NULL);
1716 for(;;) {
1717 int mpt;
1718
1719 pfd.fd = rpc_get_fd(rpc);
1720 pfd.events = rpc_which_events(rpc);
1721
1722 gettimeofday(&tv_current, NULL);
1723 mpt = 1000
1724 - (tv_current.tv_sec *1000 + tv_current.tv_usec / 1000)
1725 + (tv_start.tv_sec *1000 + tv_start.tv_usec / 1000);
1726
1727 if (poll(&pfd, 1, mpt) < 0) {
1728 free_nfs_srvr_list(data.srvrs);
1729 rpc_destroy_context(rpc);
1730 return NULL;
1731 }
1732 if (pfd.revents == 0) {
1733 break;
1734 }
1735
1736 if (rpc_service(rpc, pfd.revents) < 0) {
1737 break;
1738 }
1739 }
1740 }
1741
1742 free(ifc.ifc_buf);
1743 rpc_destroy_context(rpc);
1744
1745 if (data.status != 0) {
1746 free_nfs_srvr_list(data.srvrs);
1747 return NULL;
1748 }
1749 return data.srvrs;
1750}
1751#endif//WIN32
libnfs Piment Noir Debian package repository