lib/libnfs-sync.c

   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
  96 struct 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
 106 static 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
 133 static 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  */
 162 static 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
 175 int 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  */
 201 static 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
 220 int nfs_stat(struct nfs_context *nfs, const char *path, struct __stat64 *st)
 221 #else
 222 int 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
 240 static 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
 254 int 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
 271 /*
 272  * open()
 273  */
 274 static void open_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
 275 {
 276         struct sync_cb_data *cb_data = private_data;
 277         struct nfsfh *fh, **nfsfh;
 278
 279         cb_data->is_finished = 1;
 280         cb_data->status = status;
 281
 282         if (status < 0) {
 283                 nfs_set_error(nfs, "open call failed with \"%s\"", (char *)data);
 284                 return;
 285         }
 286
 287         fh    = data;
 288         nfsfh = cb_data->return_data;
 289         *nfsfh = fh;
 290 }
 291
 292 int nfs_open(struct nfs_context *nfs, const char *path, int flags, struct nfsfh **nfsfh)
 293 {
 294         struct sync_cb_data cb_data;
 295
 296         cb_data.is_finished = 0;
 297         cb_data.return_data = nfsfh;
 298
 299         if (nfs_open_async(nfs, path, flags, open_cb, &cb_data) != 0) {
 300                 nfs_set_error(nfs, "nfs_open_async failed");
 301                 return -1;
 302         }
 303
 304         wait_for_nfs_reply(nfs, &cb_data);
 305
 306         return cb_data.status;
 307 }
 308
 309 /*
 310  * chdir()
 311  */
 312 static void chdir_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
 313 {
 314         struct sync_cb_data *cb_data = private_data;
 315
 316         cb_data->is_finished = 1;
 317         cb_data->status = status;
 318
 319         if (status < 0) {
 320                 nfs_set_error(nfs, "chdir call failed with \"%s\"", (char *)data);
 321                 return;
 322         }
 323 }
 324
 325 int nfs_chdir(struct nfs_context *nfs, const char *path)
 326 {
 327         struct sync_cb_data cb_data;
 328
 329         cb_data.is_finished = 0;
 330
 331         if (nfs_chdir_async(nfs, path, chdir_cb, &cb_data) != 0) {
 332                 nfs_set_error(nfs, "nfs_chdir_async failed with %s",
 333                         nfs_get_error(nfs));
 334                 return -1;
 335         }
 336
 337         wait_for_nfs_reply(nfs, &cb_data);
 338
 339         return cb_data.status;
 340 }
 341
 342
 343
 344 /*
 345  * pread()
 346  */
 347 static void pread_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
 348 {
 349         struct sync_cb_data *cb_data = private_data;
 350         char *buffer;
 351         cb_data->is_finished = 1;
 352         cb_data->status = status;
 353
 354         if (status < 0) {
 355                 nfs_set_error(nfs, "%s call failed with \"%s\"", cb_data->call, (char *)data);
 356                 return;
 357         }
 358
 359         buffer = cb_data->return_data;
 360         memcpy(buffer, (char *)data, status);
 361 }
 362
 363 int nfs_pread(struct nfs_context *nfs, struct nfsfh *nfsfh, uint64_t offset, uint64_t count, char *buffer)
 364 {
 365         struct sync_cb_data cb_data;
 366
 367         cb_data.is_finished = 0;
 368         cb_data.return_data = buffer;
 369         cb_data.call = "pread";
 370
 371         if (nfs_pread_async(nfs, nfsfh, offset, count, pread_cb, &cb_data) != 0) {
 372                 nfs_set_error(nfs, "nfs_pread_async failed");
 373                 return -1;
 374         }
 375
 376         wait_for_nfs_reply(nfs, &cb_data);
 377
 378         return cb_data.status;
 379 }
 380
 381 /*
 382  * read()
 383  */
 384 int nfs_read(struct nfs_context *nfs, struct nfsfh *nfsfh, uint64_t count, char *buffer)
 385 {
 386         struct sync_cb_data cb_data;
 387
 388         cb_data.is_finished = 0;
 389         cb_data.return_data = buffer;
 390         cb_data.call = "read";
 391
 392         if (nfs_read_async(nfs, nfsfh, count, pread_cb, &cb_data) != 0) {
 393                 nfs_set_error(nfs, "nfs_read_async failed");
 394                 return -1;
 395         }
 396
 397         wait_for_nfs_reply(nfs, &cb_data);
 398
 399         return cb_data.status;
 400 }
 401
 402 /*
 403  * close()
 404  */
 405 static void close_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
 406 {
 407         struct sync_cb_data *cb_data = private_data;
 408         cb_data->is_finished = 1;
 409         cb_data->status = status;
 410
 411         if (status < 0) {
 412                 nfs_set_error(nfs, "close call failed with \"%s\"", (char *)data);
 413                 return;
 414         }
 415 }
 416
 417 int nfs_close(struct nfs_context *nfs, struct nfsfh *nfsfh)
 418 {
 419         struct sync_cb_data cb_data;
 420
 421         cb_data.is_finished = 0;
 422
 423         if (nfs_close_async(nfs, nfsfh, close_cb, &cb_data) != 0) {
 424                 nfs_set_error(nfs, "nfs_close_async failed");
 425                 return -1;
 426         }
 427
 428         wait_for_nfs_reply(nfs, &cb_data);
 429
 430         return cb_data.status;
 431 }
 432
 433
 434
 435
 436 /*
 437  * fstat()
 438  */
 439 int nfs_fstat(struct nfs_context *nfs, struct nfsfh *nfsfh, struct stat *st)
 440 {
 441         struct sync_cb_data cb_data;
 442
 443         cb_data.is_finished = 0;
 444         cb_data.return_data = st;
 445
 446         if (nfs_fstat_async(nfs, nfsfh, stat_cb, &cb_data) != 0) {
 447                 nfs_set_error(nfs, "nfs_fstat_async failed");
 448                 return -1;
 449         }
 450
 451         wait_for_nfs_reply(nfs, &cb_data);
 452
 453         return cb_data.status;
 454 }
 455
 456
 457 /*
 458  * pwrite()
 459  */
 460 static void pwrite_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
 461 {
 462         struct sync_cb_data *cb_data = private_data;
 463         cb_data->is_finished = 1;
 464         cb_data->status = status;
 465
 466         if (status < 0)
 467                 nfs_set_error(nfs, "%s call failed with \"%s\"", cb_data->call, (char *)data);
 468 }
 469
 470 int nfs_pwrite(struct nfs_context *nfs, struct nfsfh *nfsfh, uint64_t offset, uint64_t count, char *buf)
 471 {
 472         struct sync_cb_data cb_data;
 473
 474         cb_data.is_finished = 0;
 475         cb_data.call = "pwrite";
 476
 477         if (nfs_pwrite_async(nfs, nfsfh, offset, count, buf, pwrite_cb, &cb_data) != 0) {
 478                 nfs_set_error(nfs, "nfs_pwrite_async failed");
 479                 return -1;
 480         }
 481
 482         wait_for_nfs_reply(nfs, &cb_data);
 483
 484         return cb_data.status;
 485 }
 486
 487 /*
 488  * write()
 489  */
 490 int nfs_write(struct nfs_context *nfs, struct nfsfh *nfsfh, uint64_t count, char *buf)
 491 {
 492         struct sync_cb_data cb_data;
 493
 494         cb_data.is_finished = 0;
 495         cb_data.call = "write";
 496
 497         if (nfs_write_async(nfs, nfsfh, count, buf, pwrite_cb, &cb_data) != 0) {
 498                 nfs_set_error(nfs, "nfs_write_async failed");
 499                 return -1;
 500         }
 501
 502         wait_for_nfs_reply(nfs, &cb_data);
 503
 504         return cb_data.status;
 505 }
 506
 507
 508 /*
 509  * fsync()
 510  */
 511 static void fsync_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
 512 {
 513         struct sync_cb_data *cb_data = private_data;
 514         cb_data->is_finished = 1;
 515         cb_data->status = status;
 516
 517         if (status < 0) {
 518                 nfs_set_error(nfs, "fsync call failed with \"%s\"", (char *)data);
 519                 return;
 520         }
 521 }
 522
 523 int nfs_fsync(struct nfs_context *nfs, struct nfsfh *nfsfh)
 524 {
 525         struct sync_cb_data cb_data;
 526
 527         cb_data.is_finished = 0;
 528
 529         if (nfs_fsync_async(nfs, nfsfh, fsync_cb, &cb_data) != 0) {
 530                 nfs_set_error(nfs, "nfs_fsync_async failed");
 531                 return -1;
 532         }
 533
 534         wait_for_nfs_reply(nfs, &cb_data);
 535
 536         return cb_data.status;
 537 }
 538
 539
 540
 541
 542 /*
 543  * ftruncate()
 544  */
 545 static void ftruncate_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
 546 {
 547         struct sync_cb_data *cb_data = private_data;
 548         cb_data->is_finished = 1;
 549         cb_data->status = status;
 550
 551         if (status < 0) {
 552                 nfs_set_error(nfs, "ftruncate call failed with \"%s\"", (char *)data);
 553                 return;
 554         }
 555 }
 556
 557 int nfs_ftruncate(struct nfs_context *nfs, struct nfsfh *nfsfh, uint64_t length)
 558 {
 559         struct sync_cb_data cb_data;
 560
 561         cb_data.is_finished = 0;
 562
 563         if (nfs_ftruncate_async(nfs, nfsfh, length, ftruncate_cb, &cb_data) != 0) {
 564                 nfs_set_error(nfs, "nfs_ftruncate_async failed");
 565                 return -1;
 566         }
 567
 568         wait_for_nfs_reply(nfs, &cb_data);
 569
 570         return cb_data.status;
 571 }
 572
 573
 574
 575 /*
 576  * truncate()
 577  */
 578 static void truncate_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
 579 {
 580         struct sync_cb_data *cb_data = private_data;
 581         cb_data->is_finished = 1;
 582         cb_data->status = status;
 583
 584         if (status < 0) {
 585                 nfs_set_error(nfs, "truncate call failed with \"%s\"", (char *)data);
 586                 return;
 587         }
 588 }
 589
 590 int nfs_truncate(struct nfs_context *nfs, const char *path, uint64_t length)
 591 {
 592         struct sync_cb_data cb_data;
 593
 594         cb_data.is_finished = 0;
 595
 596         if (nfs_truncate_async(nfs, path, length, truncate_cb, &cb_data) != 0) {
 597                 nfs_set_error(nfs, "nfs_ftruncate_async failed");
 598                 return -1;
 599         }
 600
 601         wait_for_nfs_reply(nfs, &cb_data);
 602
 603         return cb_data.status;
 604 }
 605
 606
 607
 608
 609
 610 /*
 611  * mkdir()
 612  */
 613 static void mkdir_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
 614 {
 615         struct sync_cb_data *cb_data = private_data;
 616         cb_data->is_finished = 1;
 617         cb_data->status = status;
 618
 619         if (status < 0) {
 620                 nfs_set_error(nfs, "mkdir call failed with \"%s\"", (char *)data);
 621                 return;
 622         }
 623 }
 624
 625 int nfs_mkdir(struct nfs_context *nfs, const char *path)
 626 {
 627         struct sync_cb_data cb_data;
 628
 629         cb_data.is_finished = 0;
 630
 631         if (nfs_mkdir_async(nfs, path, mkdir_cb, &cb_data) != 0) {
 632                 nfs_set_error(nfs, "nfs_mkdir_async failed");
 633                 return -1;
 634         }
 635
 636         wait_for_nfs_reply(nfs, &cb_data);
 637
 638         return cb_data.status;
 639 }
 640
 641
 642
 643
 644
 645 /*
 646  * rmdir()
 647  */
 648 static void rmdir_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
 649 {
 650         struct sync_cb_data *cb_data = private_data;
 651         cb_data->is_finished = 1;
 652         cb_data->status = status;
 653
 654         if (status < 0) {
 655                 nfs_set_error(nfs, "rmdir call failed with \"%s\"", (char *)data);
 656                 return;
 657         }
 658 }
 659
 660 int nfs_rmdir(struct nfs_context *nfs, const char *path)
 661 {
 662         struct sync_cb_data cb_data;
 663
 664         cb_data.is_finished = 0;
 665
 666         if (nfs_rmdir_async(nfs, path, rmdir_cb, &cb_data) != 0) {
 667                 nfs_set_error(nfs, "nfs_rmdir_async failed");
 668                 return -1;
 669         }
 670
 671         wait_for_nfs_reply(nfs, &cb_data);
 672
 673         return cb_data.status;
 674 }
 675
 676
 677
 678 /*
 679  * creat()
 680  */
 681 static void creat_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
 682 {
 683         struct sync_cb_data *cb_data = private_data;
 684         struct nfsfh *fh, **nfsfh;
 685
 686         cb_data->is_finished = 1;
 687         cb_data->status = status;
 688
 689         if (status < 0) {
 690                 nfs_set_error(nfs, "creat call failed with \"%s\"", (char *)data);
 691                 return;
 692         }
 693
 694         fh    = data;
 695         nfsfh = cb_data->return_data;
 696         *nfsfh = fh;
 697 }
 698
 699 int nfs_creat(struct nfs_context *nfs, const char *path, int mode, struct nfsfh **nfsfh)
 700 {
 701         struct sync_cb_data cb_data;
 702
 703         cb_data.is_finished = 0;
 704         cb_data.return_data = nfsfh;
 705
 706         if (nfs_creat_async(nfs, path, mode, creat_cb, &cb_data) != 0) {
 707                 nfs_set_error(nfs, "nfs_creat_async failed");
 708                 return -1;
 709         }
 710
 711         wait_for_nfs_reply(nfs, &cb_data);
 712
 713         return cb_data.status;
 714 }
 715
 716 /*
 717  * mknod()
 718  */
 719 static void mknod_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
 720 {
 721         struct sync_cb_data *cb_data = private_data;
 722
 723         cb_data->is_finished = 1;
 724         cb_data->status = status;
 725
 726         if (status < 0) {
 727                 nfs_set_error(nfs, "mknod call failed with \"%s\"", (char *)data);
 728                 return;
 729         }
 730 }
 731
 732 int nfs_mknod(struct nfs_context *nfs, const char *path, int mode, int dev)
 733 {
 734         struct sync_cb_data cb_data;
 735
 736         cb_data.is_finished = 0;
 737
 738         if (nfs_mknod_async(nfs, path, mode, dev, mknod_cb, &cb_data) != 0) {
 739                 nfs_set_error(nfs, "nfs_creat_async failed");
 740                 return -1;
 741         }
 742
 743         wait_for_nfs_reply(nfs, &cb_data);
 744
 745         return cb_data.status;
 746 }
 747
 748
 749 /*
 750  * unlink()
 751  */
 752 static void unlink_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
 753 {
 754         struct sync_cb_data *cb_data = private_data;
 755
 756         cb_data->is_finished = 1;
 757         cb_data->status = status;
 758
 759         if (status < 0) {
 760                 nfs_set_error(nfs, "unlink call failed with \"%s\"", (char *)data);
 761                 return;
 762         }
 763 }
 764
 765 int nfs_unlink(struct nfs_context *nfs, const char *path)
 766 {
 767         struct sync_cb_data cb_data;
 768
 769         cb_data.is_finished = 0;
 770
 771         if (nfs_unlink_async(nfs, path, unlink_cb, &cb_data) != 0) {
 772                 nfs_set_error(nfs, "nfs_unlink_async failed");
 773                 return -1;
 774         }
 775
 776         wait_for_nfs_reply(nfs, &cb_data);
 777
 778         return cb_data.status;
 779 }
 780
 781
 782
 783 /*
 784  * opendir()
 785  */
 786 static void opendir_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
 787 {
 788         struct sync_cb_data *cb_data = private_data;
 789         struct nfsdir *dir, **nfsdir;
 790
 791         cb_data->is_finished = 1;
 792         cb_data->status = status;
 793
 794         if (status < 0) {
 795                 nfs_set_error(nfs, "opendir call failed with \"%s\"", (char *)data);
 796                 return;
 797         }
 798
 799         dir     = data;
 800         nfsdir  = cb_data->return_data;
 801         *nfsdir = dir;
 802 }
 803
 804 int nfs_opendir(struct nfs_context *nfs, const char *path, struct nfsdir **nfsdir)
 805 {
 806         struct sync_cb_data cb_data;
 807
 808         cb_data.is_finished = 0;
 809         cb_data.return_data = nfsdir;
 810
 811         if (nfs_opendir_async(nfs, path, opendir_cb, &cb_data) != 0) {
 812                 nfs_set_error(nfs, "nfs_opendir_async failed");
 813                 return -1;
 814         }
 815
 816         wait_for_nfs_reply(nfs, &cb_data);
 817
 818         return cb_data.status;
 819 }
 820
 821
 822 /*
 823  * lseek()
 824  */
 825 static void lseek_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
 826 {
 827         struct sync_cb_data *cb_data = private_data;
 828
 829         cb_data->is_finished = 1;
 830         cb_data->status = status;
 831
 832         if (status < 0) {
 833                 nfs_set_error(nfs, "lseek call failed with \"%s\"", (char *)data);
 834                 return;
 835         }
 836
 837         if (cb_data->return_data != NULL) {
 838                 memcpy(cb_data->return_data, data, sizeof(uint64_t));
 839         }
 840 }
 841
 842 int nfs_lseek(struct nfs_context *nfs, struct nfsfh *nfsfh, int64_t offset, int whence, uint64_t *current_offset)
 843 {
 844         struct sync_cb_data cb_data;
 845
 846         cb_data.is_finished = 0;
 847         cb_data.return_data = current_offset;
 848
 849         if (nfs_lseek_async(nfs, nfsfh, offset, whence, lseek_cb, &cb_data) != 0) {
 850                 nfs_set_error(nfs, "nfs_lseek_async failed");
 851                 return -1;
 852         }
 853
 854         wait_for_nfs_reply(nfs, &cb_data);
 855
 856         return cb_data.status;
 857 }
 858
 859
 860
 861 /*
 862  * statvfs()
 863  */
 864 static void statvfs_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
 865 {
 866         struct sync_cb_data *cb_data = private_data;
 867
 868         cb_data->is_finished = 1;
 869         cb_data->status = status;
 870
 871         if (status < 0) {
 872                 nfs_set_error(nfs, "statvfs call failed with \"%s\"", (char *)data);
 873                 return;
 874         }
 875
 876         memcpy(cb_data->return_data, data, sizeof(struct statvfs));
 877 }
 878
 879 int nfs_statvfs(struct nfs_context *nfs, const char *path, struct statvfs *svfs)
 880 {
 881         struct sync_cb_data cb_data;
 882
 883         cb_data.is_finished = 0;
 884         cb_data.return_data = svfs;
 885
 886         if (nfs_statvfs_async(nfs, path, statvfs_cb, &cb_data) != 0) {
 887                 nfs_set_error(nfs, "nfs_statvfs_async failed");
 888                 return -1;
 889         }
 890
 891         wait_for_nfs_reply(nfs, &cb_data);
 892
 893         return cb_data.status;
 894 }
 895
 896
 897
 898
 899
 900 /*
 901  * readlink()
 902  */
 903 static void readlink_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
 904 {
 905         struct sync_cb_data *cb_data = private_data;
 906
 907         cb_data->is_finished = 1;
 908         cb_data->status = status;
 909
 910         if (status < 0) {
 911                 nfs_set_error(nfs, "readlink call failed with \"%s\"", (char *)data);
 912                 return;
 913         }
 914
 915         if (strlen(data) > (size_t)cb_data->return_int) {
 916                 nfs_set_error(nfs, "Too small buffer for readlink");
 917                 cb_data->status = -ENAMETOOLONG;
 918                 return;
 919         }
 920
 921         memcpy(cb_data->return_data, data, strlen(data)+1);
 922 }
 923
 924 int nfs_readlink(struct nfs_context *nfs, const char *path, char *buf, int bufsize)
 925 {
 926         struct sync_cb_data cb_data;
 927
 928         cb_data.is_finished = 0;
 929         cb_data.return_data = buf;
 930         cb_data.return_int  = bufsize;
 931
 932         if (nfs_readlink_async(nfs, path, readlink_cb, &cb_data) != 0) {
 933                 nfs_set_error(nfs, "nfs_readlink_async failed");
 934                 return -1;
 935         }
 936
 937         wait_for_nfs_reply(nfs, &cb_data);
 938
 939         return cb_data.status;
 940 }
 941
 942
 943
 944 /*
 945  * chmod()
 946  */
 947 static void chmod_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
 948 {
 949         struct sync_cb_data *cb_data = private_data;
 950
 951         cb_data->is_finished = 1;
 952         cb_data->status = status;
 953
 954         if (status < 0) {
 955                 nfs_set_error(nfs, "chmod call failed with \"%s\"", (char *)data);
 956                 return;
 957         }
 958 }
 959
 960 int nfs_chmod(struct nfs_context *nfs, const char *path, int mode)
 961 {
 962         struct sync_cb_data cb_data;
 963
 964         cb_data.is_finished = 0;
 965
 966         if (nfs_chmod_async(nfs, path, mode, chmod_cb, &cb_data) != 0) {
 967                 nfs_set_error(nfs, "nfs_chmod_async failed");
 968                 return -1;
 969         }
 970
 971         wait_for_nfs_reply(nfs, &cb_data);
 972
 973         return cb_data.status;
 974 }
 975
 976
 977
 978
 979 /*
 980  * fchmod()
 981  */
 982 static void fchmod_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
 983 {
 984         struct sync_cb_data *cb_data = private_data;
 985
 986         cb_data->is_finished = 1;
 987         cb_data->status = status;
 988
 989         if (status < 0) {
 990                 nfs_set_error(nfs, "fchmod call failed with \"%s\"", (char *)data);
 991                 return;
 992         }
 993 }
 994
 995 int nfs_fchmod(struct nfs_context *nfs, struct nfsfh *nfsfh, int mode)
 996 {
 997         struct sync_cb_data cb_data;
 998
 999         cb_data.is_finished = 0;
1000
1001         if (nfs_fchmod_async(nfs, nfsfh, mode, fchmod_cb, &cb_data) != 0) {
1002                 nfs_set_error(nfs, "nfs_fchmod_async failed");
1003                 return -1;
1004         }
1005
1006         wait_for_nfs_reply(nfs, &cb_data);
1007
1008         return cb_data.status;
1009 }
1010
1011
1012
1013
1014 /*
1015  * chown()
1016  */
1017 static void chown_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
1018 {
1019         struct sync_cb_data *cb_data = private_data;
1020
1021         cb_data->is_finished = 1;
1022         cb_data->status = status;
1023
1024         if (status < 0) {
1025                 nfs_set_error(nfs, "chown call failed with \"%s\"", (char *)data);
1026                 return;
1027         }
1028 }
1029
1030 int nfs_chown(struct nfs_context *nfs, const char *path, int uid, int gid)
1031 {
1032         struct sync_cb_data cb_data;
1033
1034         cb_data.is_finished = 0;
1035
1036         if (nfs_chown_async(nfs, path, uid, gid, chown_cb, &cb_data) != 0) {
1037                 nfs_set_error(nfs, "nfs_chown_async failed");
1038                 return -1;
1039         }
1040
1041         wait_for_nfs_reply(nfs, &cb_data);
1042
1043         return cb_data.status;
1044 }
1045
1046 /*
1047  * fchown()
1048  */
1049 static void fchown_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
1050 {
1051         struct sync_cb_data *cb_data = private_data;
1052
1053         cb_data->is_finished = 1;
1054         cb_data->status = status;
1055
1056         if (status < 0) {
1057                 nfs_set_error(nfs, "fchown call failed with \"%s\"", (char *)data);
1058                 return;
1059         }
1060 }
1061
1062 int nfs_fchown(struct nfs_context *nfs, struct nfsfh *nfsfh, int uid, int gid)
1063 {
1064         struct sync_cb_data cb_data;
1065
1066         cb_data.is_finished = 0;
1067
1068         if (nfs_fchown_async(nfs, nfsfh, uid, gid, fchown_cb, &cb_data) != 0) {
1069                 nfs_set_error(nfs, "nfs_fchown_async failed");
1070                 return -1;
1071         }
1072
1073         wait_for_nfs_reply(nfs, &cb_data);
1074
1075         return cb_data.status;
1076 }
1077
1078
1079
1080 /*
1081  * utimes()
1082  */
1083 static void utimes_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
1084 {
1085         struct sync_cb_data *cb_data = private_data;
1086
1087         cb_data->is_finished = 1;
1088         cb_data->status = status;
1089
1090         if (status < 0) {
1091                 nfs_set_error(nfs, "utimes call failed with \"%s\"", (char *)data);
1092                 return;
1093         }
1094 }
1095
1096 int nfs_utimes(struct nfs_context *nfs, const char *path, struct timeval *times)
1097 {
1098         struct sync_cb_data cb_data;
1099
1100         cb_data.is_finished = 0;
1101
1102         if (nfs_utimes_async(nfs, path, times, utimes_cb, &cb_data) != 0) {
1103                 nfs_set_error(nfs, "nfs_utimes_async failed");
1104                 return -1;
1105         }
1106
1107         wait_for_nfs_reply(nfs, &cb_data);
1108
1109         return cb_data.status;
1110 }
1111
1112
1113
1114 /*
1115  * utime()
1116  */
1117 static void utime_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
1118 {
1119         struct sync_cb_data *cb_data = private_data;
1120
1121         cb_data->is_finished = 1;
1122         cb_data->status = status;
1123
1124         if (status < 0) {
1125                 nfs_set_error(nfs, "utime call failed with \"%s\"", (char *)data);
1126                 return;
1127         }
1128 }
1129
1130 int nfs_utime(struct nfs_context *nfs, const char *path, struct utimbuf *times)
1131 {
1132         struct sync_cb_data cb_data;
1133
1134         cb_data.is_finished = 0;
1135
1136         if (nfs_utime_async(nfs, path, times, utime_cb, &cb_data) != 0) {
1137                 nfs_set_error(nfs, "nfs_utimes_async failed");
1138                 return -1;
1139         }
1140
1141         wait_for_nfs_reply(nfs, &cb_data);
1142
1143         return cb_data.status;
1144 }
1145
1146
1147
1148
1149 /*
1150  * access()
1151  */
1152 static void access_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
1153 {
1154         struct sync_cb_data *cb_data = private_data;
1155
1156         cb_data->is_finished = 1;
1157         cb_data->status = status;
1158
1159         if (status < 0) {
1160                 nfs_set_error(nfs, "access call failed with \"%s\"", (char *)data);
1161                 return;
1162         }
1163 }
1164
1165 int nfs_access(struct nfs_context *nfs, const char *path, int mode)
1166 {
1167         struct sync_cb_data cb_data;
1168
1169         cb_data.is_finished = 0;
1170
1171         if (nfs_access_async(nfs, path, mode, access_cb, &cb_data) != 0) {
1172                 nfs_set_error(nfs, "nfs_access_async failed");
1173                 return -1;
1174         }
1175
1176         wait_for_nfs_reply(nfs, &cb_data);
1177
1178         return cb_data.status;
1179 }
1180
1181
1182
1183 /*
1184  * symlink()
1185  */
1186 static void symlink_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
1187 {
1188         struct sync_cb_data *cb_data = private_data;
1189
1190         cb_data->is_finished = 1;
1191         cb_data->status = status;
1192
1193         if (status < 0) {
1194                 nfs_set_error(nfs, "symlink call failed with \"%s\"", (char *)data);
1195                 return;
1196         }
1197 }
1198
1199 int nfs_symlink(struct nfs_context *nfs, const char *oldpath, const char *newpath)
1200 {
1201         struct sync_cb_data cb_data;
1202
1203         cb_data.is_finished = 0;
1204
1205         if (nfs_symlink_async(nfs, oldpath, newpath, symlink_cb, &cb_data) != 0) {
1206                 nfs_set_error(nfs, "nfs_symlink_async failed");
1207                 return -1;
1208         }
1209
1210         wait_for_nfs_reply(nfs, &cb_data);
1211
1212         return cb_data.status;
1213 }
1214
1215
1216
1217 /*
1218  * rename()
1219  */
1220 static void rename_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
1221 {
1222         struct sync_cb_data *cb_data = private_data;
1223
1224         cb_data->is_finished = 1;
1225         cb_data->status = status;
1226
1227         if (status < 0) {
1228                 nfs_set_error(nfs, "rename call failed with \"%s\"", (char *)data);
1229                 return;
1230         }
1231 }
1232
1233 int nfs_rename(struct nfs_context *nfs, const char *oldpath, const char *newpath)
1234 {
1235         struct sync_cb_data cb_data;
1236
1237         cb_data.is_finished = 0;
1238
1239         if (nfs_rename_async(nfs, oldpath, newpath, rename_cb, &cb_data) != 0) {
1240                 nfs_set_error(nfs, "nfs_rename_async failed");
1241                 return -1;
1242         }
1243
1244         wait_for_nfs_reply(nfs, &cb_data);
1245
1246         return cb_data.status;
1247 }
1248
1249
1250
1251 /*
1252  * link()
1253  */
1254 static void link_cb(int status, struct nfs_context *nfs, void *data, void *private_data)
1255 {
1256         struct sync_cb_data *cb_data = private_data;
1257
1258         cb_data->is_finished = 1;
1259         cb_data->status = status;
1260
1261         if (status < 0) {
1262                 nfs_set_error(nfs, "link call failed with \"%s\"", (char *)data);
1263                 return;
1264         }
1265 }
1266
1267 int nfs_link(struct nfs_context *nfs, const char *oldpath, const char *newpath)
1268 {
1269         struct sync_cb_data cb_data;
1270
1271         cb_data.is_finished = 0;
1272
1273         if (nfs_link_async(nfs, oldpath, newpath, link_cb, &cb_data) != 0) {
1274                 nfs_set_error(nfs, "nfs_link_async failed");
1275                 return -1;
1276         }
1277
1278         wait_for_nfs_reply(nfs, &cb_data);
1279
1280         return cb_data.status;
1281 }
1282
1283 void mount_getexports_cb(struct rpc_context *mount_context, int status, void *data, void *private_data)
1284 {
1285         struct sync_cb_data *cb_data = private_data;
1286         exports export;
1287
1288         assert(mount_context->magic == RPC_CONTEXT_MAGIC);
1289
1290         cb_data->is_finished = 1;
1291         cb_data->status = status;
1292         cb_data->return_data = NULL;
1293
1294         if (status != 0) {
1295                 rpc_set_error(mount_context, "mount/export call failed with \"%s\"", (char *)data);
1296                 return;
1297         }
1298
1299         export = *(exports *)data;
1300         while (export != NULL) {
1301                 exports new_export;
1302
1303                 new_export = malloc(sizeof(*new_export));
1304                 memset(new_export, 0, sizeof(*new_export));
1305                 new_export->ex_dir  = strdup(export->ex_dir);
1306                 new_export->ex_next = cb_data->return_data;
1307
1308                 cb_data->return_data = new_export;
1309
1310                 export = export->ex_next;
1311         }
1312 }
1313
1314 struct exportnode *mount_getexports(const char *server)
1315 {
1316         struct sync_cb_data cb_data;
1317         struct rpc_context *rpc;
1318
1319
1320         cb_data.is_finished = 0;
1321         cb_data.return_data = NULL;
1322
1323         rpc = rpc_init_context();
1324         if (mount_getexports_async(rpc, server, mount_getexports_cb, &cb_data) != 0) {
1325                 rpc_destroy_context(rpc);
1326                 return NULL;
1327         }
1328
1329         wait_for_reply(rpc, &cb_data);
1330         rpc_destroy_context(rpc);
1331
1332         return cb_data.return_data;
1333 }
1334
1335 void mount_free_export_list(struct exportnode *exports)
1336 {
1337         struct exportnode *tmp;
1338
1339         while ((tmp = exports)) {
1340                 exports = exports->ex_next;
1341                 free(tmp->ex_dir);
1342                 free(tmp);
1343         }
1344 }
1345
1346
1347
1348 void free_nfs_srvr_list(struct nfs_server_list *srv)
1349 {
1350         while (srv != NULL) {
1351                 struct nfs_server_list *next = srv->next;
1352
1353                 free(srv->addr);
1354                 free(srv);
1355                 srv = next;
1356         }
1357 }
1358
1359 struct nfs_list_data {
1360        int status;
1361        struct nfs_server_list *srvrs;
1362 };
1363
1364 void callit_cb(struct rpc_context *rpc, int status, void *data _U_, void *private_data)
1365 {
1366         struct nfs_list_data *srv_data = private_data;
1367         struct sockaddr *sin;
1368         char hostdd[16];
1369         struct nfs_server_list *srvr;
1370
1371         assert(rpc->magic == RPC_CONTEXT_MAGIC);
1372
1373         if (status == RPC_STATUS_CANCEL) {
1374                 return;
1375         }
1376         if (status != 0) {
1377                 srv_data->status = -1;
1378                 return;
1379         }
1380
1381         sin = rpc_get_recv_sockaddr(rpc);
1382         if (sin == NULL) {
1383                 rpc_set_error(rpc, "failed to get sockaddr in CALLIT callback");
1384                 srv_data->status = -1;
1385                 return;
1386         }
1387
1388         if (getnameinfo(sin, sizeof(struct sockaddr_in), &hostdd[0], sizeof(hostdd), NULL, 0, NI_NUMERICHOST) < 0) {
1389                 rpc_set_error(rpc, "getnameinfo failed in CALLIT callback");
1390                 srv_data->status = -1;
1391                 return;
1392         }
1393
1394         /* check for dupes */
1395         for (srvr = srv_data->srvrs; srvr; srvr = srvr->next) {
1396                 if (!strcmp(hostdd, srvr->addr)) {
1397                         return;
1398                 }
1399         }
1400
1401         srvr = malloc(sizeof(struct nfs_server_list));
1402         if (srvr == NULL) {
1403                 rpc_set_error(rpc, "Malloc failed when allocating server structure");
1404                 srv_data->status = -1;
1405                 return;
1406         }
1407
1408         srvr->addr = strdup(hostdd);
1409         if (srvr->addr == NULL) {
1410                 rpc_set_error(rpc, "Strdup failed when allocating server structure");
1411                 free(srvr);
1412                 srv_data->status = -1;
1413                 return;
1414         }
1415
1416         srvr->next = srv_data->srvrs;
1417         srv_data->srvrs = srvr;
1418 }
1419
1420 #ifdef WIN32
1421
1422 static int send_nfsd_probes(struct rpc_context *rpc, INTERFACE_INFO *InterfaceList, int numIfs, struct nfs_list_data *data)
1423 {
1424   int i=0;
1425
1426   assert(rpc->magic == RPC_CONTEXT_MAGIC);
1427
1428   for(i = 0; i < numIfs; i++)
1429   {
1430     SOCKADDR *pAddress;
1431     char bcdd[16];
1432     unsigned long nFlags = 0;
1433
1434     pAddress = (SOCKADDR *) & (InterfaceList[i].iiBroadcastAddress);
1435
1436     if(pAddress->sa_family != AF_INET)
1437       continue;
1438
1439     nFlags = InterfaceList[i].iiFlags;
1440
1441     if (!(nFlags & IFF_UP))
1442     {
1443       continue;
1444     }
1445
1446     if (nFlags & IFF_LOOPBACK)
1447     {
1448       continue;
1449     }
1450
1451     if (!(nFlags & IFF_BROADCAST))
1452     {
1453       continue;
1454     }
1455
1456     if (getnameinfo(pAddress, sizeof(struct sockaddr_in), &bcdd[0], sizeof(bcdd), NULL, 0, NI_NUMERICHOST) < 0)
1457     {
1458       continue;
1459     }
1460
1461     if (rpc_set_udp_destination(rpc, bcdd, 111, 1) < 0)
1462     {
1463       return -1;
1464     }
1465
1466     if (rpc_pmap2_callit_async(rpc, MOUNT_PROGRAM, 2, 0, NULL, 0, callit_cb, data) < 0)
1467     {
1468       return -1;
1469     }
1470   }
1471   return 0;
1472 }
1473
1474 struct nfs_server_list *nfs_find_local_servers(void)
1475 {
1476   struct rpc_context *rpc;
1477   struct nfs_list_data data = {0, NULL};
1478   struct timeval tv_start, tv_current;
1479   int loop;
1480   struct pollfd pfd;
1481   INTERFACE_INFO InterfaceList[20];
1482   unsigned long nBytesReturned;
1483   int nNumInterfaces = 0;
1484
1485   rpc = rpc_init_udp_context();
1486   if (rpc == NULL)
1487   {
1488     return NULL;
1489   }
1490
1491   if (rpc_bind_udp(rpc, "0.0.0.0", 0) < 0)
1492   {
1493     rpc_destroy_context(rpc);
1494     return NULL;
1495   }
1496
1497   if (WSAIoctl(rpc_get_fd(rpc), SIO_GET_INTERFACE_LIST, 0, 0, &InterfaceList, sizeof(InterfaceList), &nBytesReturned, 0, 0) == SOCKET_ERROR)
1498   {
1499     return NULL;
1500   }
1501
1502   nNumInterfaces = nBytesReturned / sizeof(INTERFACE_INFO);
1503
1504   for (loop=0; loop<3; loop++)
1505   {
1506     if (send_nfsd_probes(rpc, InterfaceList, nNumInterfaces, &data) != 0)
1507     {
1508       rpc_destroy_context(rpc);
1509       return NULL;
1510     }
1511
1512     win32_gettimeofday(&tv_start, NULL);
1513     for(;;)
1514     {
1515       int mpt;
1516
1517       pfd.fd = rpc_get_fd(rpc);
1518       pfd.events = rpc_which_events(rpc);
1519
1520       win32_gettimeofday(&tv_current, NULL);
1521       mpt = 1000
1522       -    (tv_current.tv_sec *1000 + tv_current.tv_usec / 1000)
1523       +    (tv_start.tv_sec *1000 + tv_start.tv_usec / 1000);
1524
1525       if (poll(&pfd, 1, mpt) < 0)
1526       {
1527         free_nfs_srvr_list(data.srvrs);
1528         rpc_destroy_context(rpc);
1529         return NULL;
1530       }
1531       if (pfd.revents == 0)
1532       {
1533         break;
1534       }
1535
1536       if (rpc_service(rpc, pfd.revents) < 0)
1537       {
1538         break;
1539       }
1540     }
1541   }
1542
1543   rpc_destroy_context(rpc);
1544
1545   if (data.status != 0)
1546   {
1547     free_nfs_srvr_list(data.srvrs);
1548     return NULL;
1549   }
1550   return data.srvrs;
1551 }
1552 #else
1553
1554 static int send_nfsd_probes(struct rpc_context *rpc, struct ifconf *ifc, struct nfs_list_data *data)
1555 {
1556         char *ptr;
1557
1558         assert(rpc->magic == RPC_CONTEXT_MAGIC);
1559
1560         for (ptr =(char *)(ifc->ifc_buf); ptr < (char *)(ifc->ifc_buf) + ifc->ifc_len; ) {
1561                 struct ifreq *ifr;
1562                 char bcdd[16];
1563
1564                 ifr = (struct ifreq *)ptr;
1565 #ifdef HAVE_SOCKADDR_LEN
1566                 if (ifr->ifr_addr.sa_len > sizeof(struct sockaddr)) {
1567                         ptr += sizeof(ifr->ifr_name) + ifr->ifr_addr.sa_len;
1568                 } else {
1569                         ptr += sizeof(ifr->ifr_name) + sizeof(struct sockaddr);
1570                 }
1571 #else
1572                 ptr += sizeof(struct ifreq);
1573 #endif
1574
1575                 if (ifr->ifr_addr.sa_family != AF_INET) {
1576                         continue;
1577                 }
1578                 if (ioctl(rpc_get_fd(rpc), SIOCGIFFLAGS, ifr) < 0) {
1579                         return -1;
1580                 }
1581                 if (!(ifr->ifr_flags & IFF_UP)) {
1582                         continue;
1583                 }
1584                 if (ifr->ifr_flags & IFF_LOOPBACK) {
1585                         continue;
1586                 }
1587                 if (!(ifr->ifr_flags & IFF_BROADCAST)) {
1588                         continue;
1589                 }
1590                 if (ioctl(rpc_get_fd(rpc), SIOCGIFBRDADDR, ifr) < 0) {
1591                         continue;
1592                 }
1593                 if (getnameinfo(&ifr->ifr_broadaddr, sizeof(struct sockaddr_in), &bcdd[0], sizeof(bcdd), NULL, 0, NI_NUMERICHOST) < 0) {
1594                         continue;
1595                 }
1596                 if (rpc_set_udp_destination(rpc, bcdd, 111, 1) < 0) {
1597                         return -1;
1598                 }
1599
1600                 if (rpc_pmap2_callit_async(rpc, MOUNT_PROGRAM, 2, 0, NULL, 0, callit_cb, data) < 0) {
1601                         return -1;
1602                 }
1603         }
1604
1605         return 0;
1606 }
1607
1608 struct nfs_server_list *nfs_find_local_servers(void)
1609 {
1610         struct rpc_context *rpc;
1611         struct nfs_list_data data = {0, NULL};
1612         struct timeval tv_start, tv_current;
1613         struct ifconf ifc;
1614         int size, loop;
1615         struct pollfd pfd;
1616
1617         rpc = rpc_init_udp_context();
1618         if (rpc == NULL) {
1619                 return NULL;
1620         }
1621
1622         if (rpc_bind_udp(rpc, "0.0.0.0", 0) < 0) {
1623                 rpc_destroy_context(rpc);
1624                 return NULL;
1625         }
1626
1627
1628         /* get list of all interfaces */
1629         size = sizeof(struct ifreq);
1630         ifc.ifc_buf = NULL;
1631         ifc.ifc_len = size;
1632
1633         while(ifc.ifc_len > (size - sizeof(struct ifreq))) {
1634                 size *= 2;
1635
1636                 free(ifc.ifc_buf);
1637                 ifc.ifc_len = size;
1638                 ifc.ifc_buf = malloc(size);
1639                 memset(ifc.ifc_buf, 0, size);
1640                 if (ioctl(rpc_get_fd(rpc), SIOCGIFCONF, (caddr_t)&ifc) < 0) {
1641                         rpc_destroy_context(rpc);
1642                         free(ifc.ifc_buf);
1643                         return NULL;
1644                 }
1645         }
1646
1647         for (loop=0; loop<3; loop++) {
1648                 if (send_nfsd_probes(rpc, &ifc, &data) != 0) {
1649                         rpc_destroy_context(rpc);
1650                         free(ifc.ifc_buf);
1651                         return NULL;
1652                 }
1653
1654                 gettimeofday(&tv_start, NULL);
1655                 for(;;) {
1656                         int mpt;
1657
1658                         pfd.fd = rpc_get_fd(rpc);
1659                         pfd.events = rpc_which_events(rpc);
1660
1661                         gettimeofday(&tv_current, NULL);
1662                         mpt = 1000
1663                         -    (tv_current.tv_sec *1000 + tv_current.tv_usec / 1000)
1664                         +    (tv_start.tv_sec *1000 + tv_start.tv_usec / 1000);
1665
1666                         if (poll(&pfd, 1, mpt) < 0) {
1667                                 free_nfs_srvr_list(data.srvrs);
1668                                 rpc_destroy_context(rpc);
1669                                 return NULL;
1670                         }
1671                         if (pfd.revents == 0) {
1672                                 break;
1673                         }
1674
1675                         if (rpc_service(rpc, pfd.revents) < 0) {
1676                                 break;
1677                         }
1678                 }
1679         }
1680
1681         free(ifc.ifc_buf);
1682         rpc_destroy_context(rpc);
1683
1684         if (data.status != 0) {
1685                 free_nfs_srvr_list(data.srvrs);
1686                 return NULL;
1687         }
1688         return data.srvrs;
1689 }
1690 #endif//WIN32