ReactOS  0.4.14-dev-77-gd9e7c48
rpcb_clnt.c File Reference
#include <wintirpc.h>
#include <reentrant.h>
#include <sys/types.h>
#include <rpc/rpc.h>
#include <rpc/rpcb_prot.h>
#include <rpc/nettype.h>
#include <netconfig.h>
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include "rpc_com.h"
Include dependency graph for rpcb_clnt.c:

Go to the source code of this file.

Classes

struct  address_cache
 

Macros

#define RPCB_OWNER_STRING   "libtirpc"
 
#define CACHESIZE   6
 
#define CLCR_GET_RPCB_TIMEOUT   1
 
#define CLCR_SET_RPCB_TIMEOUT   2
 
#define IN4_LOCALHOST_STRING   "127.0.0.1"
 
#define IN6_LOCALHOST_STRING   "::1"
 

Functions

bool_t xdr_wrapstring (XDR *, char **)
 
static struct address_cachecheck_cache (const char *, const char *)
 
static void delete_cache (struct netbuf *)
 
static void add_cache (const char *, const char *, struct netbuf *, char *)
 
static CLIENTgetclnthandle (const char *, const struct netconfig *, char **)
 
static CLIENTlocal_rpcb (void)
 
bool_t __rpc_control (int request, void *info)
 
static struct address_cachecheck_cache (char *host, char *netid) const
 
static void add_cache (char *host, char *netid, struct netbuf *taddr, char *uaddr) const
 
static CLIENTgetclnthandle (char *host, const struct netconfig *nconf, char **targaddr) const
 
bool_t rpcb_set (rpcprog_t program, rpcvers_t version, const struct netconfig *nconf, const struct netbuf *address)
 
bool_t rpcb_unset (rpcprog_t program, rpcvers_t version, const struct netconfig *nconf)
 
bool_t __rpcbind_is_up ()
 
struct netbuf__rpcb_findaddr_timed (rpcprog_t program, rpcvers_t version, const struct netconfig *nconf, const char *host, CLIENT **clpp, struct timeval *tp)
 
int rpcb_getaddr (rpcprog_t program, rpcvers_t version, const struct netconfig *nconf, struct netbuf *address, const char *host)
 
rpcblistrpcb_getmaps (struct netconfig *nconf, const char *host) const
 
enum clnt_stat rpcb_rmtcall (struct netconfig *nconf, const char *host, rpcprog_t prog, rpcvers_t vers, rpcproc_t proc, xdrproc_t xdrargs, caddr_t argsp, xdrproc_t xdrres, caddr_t resp, struct timeval tout, const struct netbuf *addr_ptr) const
 
bool_t rpcb_gettime (char *host, time_t *timep) const
 
charrpcb_taddr2uaddr (struct netconfig *nconf, struct netbuf *taddr)
 
struct netbufrpcb_uaddr2taddr (struct netconfig *nconf, char *uaddr)
 

Variables

static struct timeval tottimeout = { 60, 0 }
 
static const struct timeval rmttimeout = { 3, 0 }
 
static struct timeval rpcbrmttime = { 15, 0 }
 
static const char nullstring [] = "\000"
 
static struct address_cachefront
 
static int cachesize
 
int __rpc_lowvers
 
rwlock_t rpcbaddr_cache_lock
 

Macro Definition Documentation

◆ CACHESIZE

#define CACHESIZE   6

Definition at line 73 of file rpcb_clnt.c.

◆ CLCR_GET_RPCB_TIMEOUT

#define CLCR_GET_RPCB_TIMEOUT   1

Definition at line 86 of file rpcb_clnt.c.

◆ CLCR_SET_RPCB_TIMEOUT

#define CLCR_SET_RPCB_TIMEOUT   2

Definition at line 87 of file rpcb_clnt.c.

◆ IN4_LOCALHOST_STRING

#define IN4_LOCALHOST_STRING   "127.0.0.1"

Definition at line 412 of file rpcb_clnt.c.

◆ IN6_LOCALHOST_STRING

#define IN6_LOCALHOST_STRING   "::1"

Definition at line 413 of file rpcb_clnt.c.

◆ RPCB_OWNER_STRING

#define RPCB_OWNER_STRING   "libtirpc"

Definition at line 71 of file rpcb_clnt.c.

Function Documentation

◆ __rpc_control()

bool_t __rpc_control ( int  request,
void info 
)

Definition at line 108 of file rpcb_clnt.c.

111 {
112  switch (request) {
114  *(struct timeval *)info = tottimeout;
115  break;
117  tottimeout = *(struct timeval *)info;
118  break;
119  case CLCR_SET_LOWVERS:
120  __rpc_lowvers = *(int *)info;
121  break;
122  case CLCR_GET_LOWVERS:
123  *(int *)info = __rpc_lowvers;
124  break;
125  default:
126  return (FALSE);
127  }
128  return (TRUE);
129 }
#define TRUE
Definition: types.h:120
#define CLCR_SET_LOWVERS
Definition: clnt.h:176
#define CLCR_SET_RPCB_TIMEOUT
Definition: rpcb_clnt.c:87
#define CLCR_GET_RPCB_TIMEOUT
Definition: rpcb_clnt.c:86
#define CLCR_GET_LOWVERS
Definition: clnt.h:177
int __rpc_lowvers
static struct timeval tottimeout
Definition: rpcb_clnt.c:63
Definition: tftpd.h:85

◆ __rpcb_findaddr_timed()

struct netbuf* __rpcb_findaddr_timed ( rpcprog_t  program,
rpcvers_t  version,
const struct netconfig nconf,
const char host,
CLIENT **  clpp,
struct timeval tp 
)

Definition at line 709 of file rpcb_clnt.c.

716 {
717 #ifdef NOTUSED
718  static bool_t check_rpcbind = TRUE;
719 #endif
720  CLIENT *client = NULL;
721  RPCB parms;
722  enum clnt_stat clnt_st;
723  char *ua = NULL;
724  rpcvers_t vers;
725  struct netbuf *address = NULL;
726  rpcvers_t start_vers = RPCBVERS4;
727  struct netbuf servaddr;
728 
729  /* parameter checking */
730  if (nconf == NULL) {
732  return (NULL);
733  }
734 
735  parms.r_addr = NULL;
736 
737  /*
738  * Use default total timeout if no timeout is specified.
739  */
740  if (tp == NULL)
741  tp = &tottimeout;
742 
743 #ifdef PORTMAP
744  /* Try version 2 for TCP or UDP */
745  if (strcmp(nconf->nc_protofmly, NC_INET) == 0) {
746  u_short port = 0;
747  struct netbuf remote;
748  rpcvers_t pmapvers = 2;
749  struct pmap pmapparms;
750 
751  /*
752  * Try UDP only - there are some portmappers out
753  * there that use UDP only.
754  */
755  if (strcmp(nconf->nc_proto, NC_TCP) == 0) {
756  struct netconfig *newnconf;
757 
758  if ((newnconf = getnetconfigent("udp")) == NULL) {
760  return (NULL);
761  }
762  client = getclnthandle(host, newnconf, &parms.r_addr);
763  freenetconfigent(newnconf);
764  } else if (strcmp(nconf->nc_proto, NC_UDP) == 0)
765  client = getclnthandle(host, nconf, &parms.r_addr);
766  else
767  goto try_rpcbind;
768  if (client == NULL)
769  return (NULL);
770 
771  /*
772  * Set version and retry timeout.
773  */
775  CLNT_CONTROL(client, CLSET_VERS, (char *)&pmapvers);
776 
777  pmapparms.pm_prog = program;
778  pmapparms.pm_vers = version;
779  pmapparms.pm_prot = strcmp(nconf->nc_proto, NC_TCP) ?
781  pmapparms.pm_port = 0; /* not needed */
783  (xdrproc_t) xdr_pmap, (caddr_t)(void *)&pmapparms,
784  (xdrproc_t) xdr_u_short, (caddr_t)(void *)&port,
785  *tp);
786  if (clnt_st != RPC_SUCCESS) {
787  if ((clnt_st == RPC_PROGVERSMISMATCH) ||
788  (clnt_st == RPC_PROGUNAVAIL))
789  goto try_rpcbind;
792  goto error;
793  } else if (port == 0) {
794  address = NULL;
796  goto error;
797  }
798  port = htons(port);
799  CLNT_CONTROL(client, CLGET_SVC_ADDR, (char *)&remote);
800  if (((address = (struct netbuf *)
801  malloc(sizeof (struct netbuf))) == NULL) ||
802  ((address->buf = (char *)
803  malloc(remote.len)) == NULL)) {
806  if (address) {
807  free(address);
808  address = NULL;
809  }
810  goto error;
811  }
812  memcpy(address->buf, remote.buf, remote.len);
813  memcpy(&((char *)address->buf)[sizeof (short)],
814  (char *)(void *)&port, sizeof (short));
815  address->len = address->maxlen = remote.len;
816  goto done;
817  }
818 
819 try_rpcbind:
820 #endif /* PORTMAP */
821 
822  parms.r_prog = program;
823  parms.r_vers = version;
824  parms.r_netid = nconf->nc_netid;
825 
826  /*
827  * rpcbind ignores the r_owner field in GETADDR requests, but we
828  * need to give xdr_rpcb something to gnaw on. Might as well make
829  * it something human readable for when we see these in captures.
830  */
831  parms.r_owner = RPCB_OWNER_STRING;
832 
833  /* Now the same transport is to be used to get the address */
834  if (client && ((nconf->nc_semantics == NC_TPI_COTS_ORD) ||
835  (nconf->nc_semantics == NC_TPI_COTS))) {
836  /* A CLTS type of client - destroy it */
838  client = NULL;
839  free(parms.r_addr);
840  parms.r_addr = NULL;
841  }
842 
843  if (client == NULL) {
844  client = getclnthandle(host, nconf, &parms.r_addr);
845  if (client == NULL) {
846  goto error;
847  }
848  }
849  if (parms.r_addr == NULL) {
850  /*LINTED const castaway*/
851  parms.r_addr = (char *) &nullstring[0];
852  }
853 
854  /* First try from start_vers(4) and then version 3 (RPCBVERS) */
855 
857  for (vers = start_vers; vers >= RPCBVERS; vers--) {
858  /* Set the version */
859  CLNT_CONTROL(client, CLSET_VERS, (char *)(void *)&vers);
861  (xdrproc_t) xdr_rpcb, (char *)(void *)&parms,
862  (xdrproc_t) xdr_wrapstring, (char *)(void *) &ua, *tp);
863  if (clnt_st == RPC_SUCCESS) {
864  if ((ua == NULL) || (ua[0] == 0)) {
865  /* address unknown */
867  goto error;
868  }
869  address = uaddr2taddr(nconf, ua);
870 #ifdef ND_DEBUG
871  fprintf(stderr, "\tRemote address is [%s]\n", ua);
872  if (!address)
873  fprintf(stderr,
874  "\tCouldn't resolve remote address!\n");
875 #endif
877  (char *)(void *)&ua);
878 
879  if (! address) {
880  /* We don't know about your universal address */
882  goto error;
883  }
885  (char *)(void *)&servaddr);
886  __rpc_fixup_addr(address, &servaddr);
887  goto done;
888  } else if (clnt_st == RPC_PROGVERSMISMATCH) {
889  struct rpc_err rpcerr;
890  clnt_geterr(client, &rpcerr);
891  if (rpcerr.re_vers.low > RPCBVERS4)
892  goto error; /* a new version, can't handle */
893  } else if (clnt_st != RPC_PROGUNAVAIL) {
894  /* Cant handle this error */
895  rpc_createerr.cf_stat = clnt_st;
897  goto error;
898  }
899  }
900 
901  if ((address == NULL) || (address->len == 0)) {
904  }
905 
906 error:
907  if (client) {
909  client = NULL;
910  }
911 done:
912  if (nconf->nc_semantics != NC_TPI_CLTS) {
913  /* This client is the connectionless one */
914  if (client) {
916  client = NULL;
917  }
918  }
919  if (clpp) {
920  *clpp = client;
921  } else if (client) {
923  }
924  if (parms.r_addr != NULL && parms.r_addr != nullstring)
925  free(parms.r_addr);
926  return (address);
927 }
int __rpc_fixup_addr(struct netbuf *, const struct netbuf *)
Definition: rpc_generic.c:883
static CLIENT * getclnthandle(const char *, const struct netconfig *, char **)
#define RPC_PMAPFAILURE
Definition: clnt_stat.h:57
bool_t xdr_wrapstring(XDR *, char **)
Definition: xdr.c:772
u_int32_t rpcproc_t
Definition: types.h:106
#define RPCB_OWNER_STRING
Definition: rpcb_clnt.c:71
#define clnt_geterr(rh, errp)
Definition: clnt.h:220
bool_t xdr_pmap(XDR *xdrs, struct pmap *regs)
Definition: pmap_prot.c:45
#define TRUE
Definition: types.h:120
u_int32_t rpcvers_t
Definition: types.h:105
#define CLSET_RETRY_TIMEOUT
Definition: clnt.h:265
#define error(str)
Definition: mkdosfs.c:1605
ActualNumberDriverObjects * sizeof(PDRIVER_OBJECT)) PDRIVER_OBJECT *DriverObjectList
int32_t bool_t
Definition: types.h:101
#define NC_TPI_CLTS
Definition: netconfig.h:30
#define free
Definition: debug_ros.c:5
char * host
Definition: whois.c:55
void xdr_free(xdrproc_t proc, void *objp)
Definition: xdr.c:78
#define NC_TCP
Definition: netconfig.h:74
char * r_netid
Definition: rpcb_prot.h:143
char * caddr_t
Definition: rosdhcp.h:36
bool_t(* xdrproc_t)(XDR *,...)
Definition: xdr.h:144
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
#define CLNT_CALL(rh, proc, xargs, argsp, xres, resp, secs)
Definition: clnt.h:199
#define NC_TPI_COTS_ORD
Definition: netconfig.h:32
char * nc_protofmly
Definition: netconfig.h:14
void freenetconfigent(struct netconfig *netconfigp)
Definition: getnetconfig.c:530
smooth NULL
Definition: ftsmooth.c:416
struct netconfig * getnetconfigent(char *netid) const
Definition: getnetconfig.c:432
static const WCHAR version[]
Definition: asmname.c:64
struct netbuf * uaddr2taddr(const struct netconfig *nconf, const char *uaddr)
Definition: rpc_generic.c:619
#define RPCBPROC_GETADDR
Definition: rpcb_prot.h:688
char * nc_proto
Definition: netconfig.h:15
rpcprog_t r_prog
Definition: rpcb_prot.h:141
_In_ uint64_t _In_ uint64_t _In_ uint64_t _In_opt_ traverse_ptr * tp
Definition: btrfs.c:2883
#define PMAPPROC_GETPORT
Definition: pmap_prot.h:84
char * r_addr
Definition: rpcb_prot.h:144
enum clnt_stat cf_stat
Definition: clnt.h:496
static FILE * client
Definition: client.c:41
GLuint address
Definition: glext.h:9393
char * r_owner
Definition: rpcb_prot.h:145
char * nc_netid
Definition: netconfig.h:11
unsigned short u_short
Definition: types.h:81
rpcvers_t r_vers
Definition: rpcb_prot.h:142
#define NC_UDP
Definition: netconfig.h:75
#define NC_INET
Definition: netconfig.h:47
#define NC_TPI_COTS
Definition: netconfig.h:31
static struct timeval rpcbrmttime
Definition: rpcb_clnt.c:65
static const char nullstring[]
Definition: rpcb_clnt.c:69
#define RPCBVERS
Definition: rpcb_prot.h:627
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
Definition: clnt.h:95
bool_t xdr_u_short(XDR *xdrs, u_short *usp)
Definition: xdr.c:300
#define CLNT_DESTROY(rh)
Definition: clnt.h:275
static struct timeval tottimeout
Definition: rpcb_clnt.c:63
#define CLGET_SVC_ADDR
Definition: clnt.h:250
GLuint program
Definition: glext.h:6723
#define RPCBVERS4
Definition: rpcb_prot.h:707
bool_t xdr_rpcb(XDR *xdrs, RPCB *objp)
Definition: rpcb_prot.c:50
#define CLSET_VERS
Definition: clnt.h:256
Definition: types.h:144
struct rpc_err cf_error
Definition: clnt.h:497
FILE * stderr
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
#define malloc
Definition: debug_ros.c:4
unsigned long nc_semantics
Definition: netconfig.h:12
#define htons(x)
Definition: module.h:213
#define CLNT_CONTROL(cl, rq, in)
Definition: clnt.h:240
USHORT port
Definition: uri.c:227
clnt_stat
Definition: clnt_stat.h:21
Definition: pmap_prot.h:88

Referenced by clnt_tp_create_timed(), and rpcb_getaddr().

◆ __rpcbind_is_up()

bool_t __rpcbind_is_up ( )

Definition at line 655 of file rpcb_clnt.c.

656 {
657  struct netconfig *nconf;
658  struct sockaddr_un sun;
659  void *localhandle;
660  SOCKET sock;
661 
662  nconf = NULL;
663  localhandle = setnetconfig();
664  while ((nconf = getnetconfig(localhandle)) != NULL) {
665  if (nconf->nc_protofmly != NULL &&
666  strcmp(nconf->nc_protofmly, NC_LOOPBACK) == 0)
667  break;
668  }
669  if (nconf == NULL)
670  return (FALSE);
671 
672  endnetconfig(localhandle);
673 
674  memset(&sun, 0, sizeof sun);
676  if (sock == INVALID_SOCKET)
677  return (FALSE);
678  sun.sun_family = AF_UNIX;
679  strncpy(sun.sun_path, _PATH_RPCBINDSOCK, sizeof(sun.sun_path));
680 
681  if (connect(sock, (struct sockaddr *)&sun, sizeof(sun)) == SOCKET_ERROR) {
682  closesocket(sock);
683  return (FALSE);
684  }
685 
686  closesocket(sock);
687  return (TRUE);
688 }
#define SOCKET_ERROR
Definition: winsock.h:333
#define TRUE
Definition: types.h:120
static SOCKET sock
Definition: syslog.c:45
SOCKET WSAAPI socket(IN INT af, IN INT type, IN INT protocol)
Definition: socklife.c:143
char * strncpy(char *DstString, const char *SrcString, ACPI_SIZE Count)
Definition: utclib.c:427
INT WSAAPI connect(IN SOCKET s, IN CONST struct sockaddr *name, IN INT namelen)
Definition: sockctrl.c:23
struct netconfig * getnetconfig(void *handlep)
Definition: getnetconfig.c:253
#define closesocket
Definition: main.c:39
char * nc_protofmly
Definition: netconfig.h:14
smooth NULL
Definition: ftsmooth.c:416
#define INVALID_SOCKET
Definition: winsock.h:332
#define _PATH_RPCBINDSOCK
Definition: rpcb_prot.h:485
int endnetconfig(void *handlep)
Definition: getnetconfig.c:373
Definition: tcpcore.h:1455
#define AF_UNIX
Definition: winsock.h:345
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
UINT_PTR SOCKET
Definition: winsock.h:47
#define SOCK_STREAM
Definition: tcpip.h:118
void * setnetconfig()
Definition: getnetconfig.c:217
#define memset(x, y, z)
Definition: compat.h:39
#define NC_LOOPBACK
Definition: netconfig.h:46

◆ add_cache() [1/2]

static void add_cache ( const char ,
const char ,
struct netbuf ,
char  
)
static

Referenced by getclnthandle().

◆ add_cache() [2/2]

static void add_cache ( char host,
char netid,
struct netbuf taddr,
char uaddr 
) const
static

Definition at line 198 of file rpcb_clnt.c.

202 {
203  struct address_cache *ad_cache, *cptr, *prevptr;
204 
205  ad_cache = (struct address_cache *)
206  malloc(sizeof (struct address_cache));
207  if (!ad_cache) {
208  return;
209  }
210  ad_cache->ac_host = strdup(host);
211  ad_cache->ac_netid = strdup(netid);
212  ad_cache->ac_uaddr = uaddr ? strdup(uaddr) : NULL;
213  ad_cache->ac_taddr = (struct netbuf *)malloc(sizeof (struct netbuf));
214  if (!ad_cache->ac_host || !ad_cache->ac_netid || !ad_cache->ac_taddr ||
215  (uaddr && !ad_cache->ac_uaddr)) {
216  return;
217  }
218  ad_cache->ac_taddr->len = ad_cache->ac_taddr->maxlen = taddr->len;
219  ad_cache->ac_taddr->buf = (char *) malloc(taddr->len);
220  if (ad_cache->ac_taddr->buf == NULL) {
221  return;
222  }
223  memcpy(ad_cache->ac_taddr->buf, taddr->buf, taddr->len);
224 #ifdef ND_DEBUG
225  fprintf(stderr, "Added to cache: %s : %s\n", host, netid);
226 #endif
227 
228 /* VARIABLES PROTECTED BY rpcbaddr_cache_lock: cptr */
229 
231  if (cachesize < CACHESIZE) {
232  ad_cache->ac_next = front;
233  front = ad_cache;
234  cachesize++;
235  } else {
236  /* Free the last entry */
237  cptr = front;
238  prevptr = NULL;
239  while (cptr->ac_next) {
240  prevptr = cptr;
241  cptr = cptr->ac_next;
242  }
243 
244 #ifdef ND_DEBUG
245  fprintf(stderr, "Deleted from cache: %s : %s\n",
246  cptr->ac_host, cptr->ac_netid);
247 #endif
248  free(cptr->ac_host);
249  free(cptr->ac_netid);
250  free(cptr->ac_taddr->buf);
251  free(cptr->ac_taddr);
252  if (cptr->ac_uaddr)
253  free(cptr->ac_uaddr);
254 
255  if (prevptr) {
256  prevptr->ac_next = NULL;
257  ad_cache->ac_next = front;
258  front = ad_cache;
259  } else {
260  front = ad_cache;
261  ad_cache->ac_next = NULL;
262  }
263  free(cptr);
264  }
266 }
#define CACHESIZE
Definition: rpcb_clnt.c:73
#define rwlock_wrlock(l)
Definition: reentrant.h:140
#define free
Definition: debug_ros.c:5
char * host
Definition: whois.c:55
void * buf
Definition: types.h:147
struct address_cache * ac_next
Definition: rpcb_clnt.c:80
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
#define rwlock_unlock(l)
Definition: reentrant.h:142
_Check_return_ _CRTIMP char *__cdecl strdup(_In_opt_z_ const char *_Src)
smooth NULL
Definition: ftsmooth.c:416
static struct address_cache * front
Definition: rpcb_clnt.c:83
char * ac_host
Definition: rpcb_clnt.c:76
unsigned int len
Definition: types.h:146
rwlock_t rpcbaddr_cache_lock
Definition: mt_misc.c:25
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
char * ac_netid
Definition: rpcb_clnt.c:77
Definition: types.h:144
char * ac_uaddr
Definition: rpcb_clnt.c:78
FILE * stderr
#define malloc
Definition: debug_ros.c:4
struct netbuf * ac_taddr
Definition: rpcb_clnt.c:79
static int cachesize
Definition: rpcb_clnt.c:84

◆ check_cache() [1/2]

static struct address_cache* check_cache ( const char ,
const char  
)
static

Referenced by getclnthandle().

◆ check_cache() [2/2]

static struct address_cache* check_cache ( char host,
char netid 
) const
static

Definition at line 150 of file rpcb_clnt.c.

152 {
153  struct address_cache *cptr;
154 
155  /* READ LOCK HELD ON ENTRY: rpcbaddr_cache_lock */
156 
157  for (cptr = front; cptr != NULL; cptr = cptr->ac_next) {
158  if (!strcmp(cptr->ac_host, host) &&
159  !strcmp(cptr->ac_netid, netid)) {
160 #ifdef ND_DEBUG
161  fprintf(stderr, "Found cache entry for %s: %s\n",
162  host, netid);
163 #endif
164  return (cptr);
165  }
166  }
167  return ((struct address_cache *) NULL);
168 }
char * host
Definition: whois.c:55
struct address_cache * ac_next
Definition: rpcb_clnt.c:80
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
smooth NULL
Definition: ftsmooth.c:416
static struct address_cache * front
Definition: rpcb_clnt.c:83
char * ac_host
Definition: rpcb_clnt.c:76
char * ac_netid
Definition: rpcb_clnt.c:77
FILE * stderr
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469

◆ delete_cache()

static void delete_cache ( struct netbuf addr)
static

Definition at line 171 of file rpcb_clnt.c.

173 {
174  struct address_cache *cptr, *prevptr = NULL;
175 
176  /* WRITE LOCK HELD ON ENTRY: rpcbaddr_cache_lock */
177  for (cptr = front; cptr != NULL; cptr = cptr->ac_next) {
178  if (!memcmp(cptr->ac_taddr->buf, addr->buf, addr->len)) {
179  free(cptr->ac_host);
180  free(cptr->ac_netid);
181  free(cptr->ac_taddr->buf);
182  free(cptr->ac_taddr);
183  if (cptr->ac_uaddr)
184  free(cptr->ac_uaddr);
185  if (prevptr)
186  prevptr->ac_next = cptr->ac_next;
187  else
188  front = cptr->ac_next;
189  free(cptr);
190  cachesize--;
191  break;
192  }
193  prevptr = cptr;
194  }
195 }
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
#define free
Definition: debug_ros.c:5
struct address_cache * ac_next
Definition: rpcb_clnt.c:80
smooth NULL
Definition: ftsmooth.c:416
static struct address_cache * front
Definition: rpcb_clnt.c:83
char * ac_host
Definition: rpcb_clnt.c:76
GLenum const GLvoid * addr
Definition: glext.h:9621
char * ac_netid
Definition: rpcb_clnt.c:77
char * ac_uaddr
Definition: rpcb_clnt.c:78
struct netbuf * ac_taddr
Definition: rpcb_clnt.c:79
static int cachesize
Definition: rpcb_clnt.c:84

Referenced by getclnthandle(), and FindProgramDlg::Refresh().

◆ getclnthandle() [1/2]

static CLIENT* getclnthandle ( const char ,
const struct netconfig ,
char **   
)
static

◆ getclnthandle() [2/2]

static CLIENT* getclnthandle ( char host,
const struct netconfig nconf,
char **  targaddr 
) const
static

Definition at line 276 of file rpcb_clnt.c.

280 {
281  CLIENT *client;
282  struct netbuf *addr, taddr;
283  struct netbuf addr_to_delete;
284  struct __rpc_sockinfo si;
285  struct addrinfo hints, *res, *tres;
286  struct address_cache *ad_cache;
287  char *tmpaddr;
288 
289 /* VARIABLES PROTECTED BY rpcbaddr_cache_lock: ad_cache */
290 
291  /* Get the address of the rpcbind. Check cache first */
292  client = NULL;
293  addr_to_delete.len = 0;
295  ad_cache = NULL;
296  if (host != NULL)
297  ad_cache = check_cache(host, nconf->nc_netid);
298  if (ad_cache != NULL) {
299  addr = ad_cache->ac_taddr;
302  if (client != NULL) {
303  if (targaddr)
304  *targaddr = strdup(ad_cache->ac_uaddr);
306  return (client);
307  }
308  addr_to_delete.len = addr->len;
309  addr_to_delete.buf = (char *)malloc(addr->len);
310  if (addr_to_delete.buf == NULL) {
311  addr_to_delete.len = 0;
312  } else {
313  memcpy(addr_to_delete.buf, addr->buf, addr->len);
314  }
315  }
317  if (addr_to_delete.len != 0) {
318  /*
319  * Assume this may be due to cache data being
320  * outdated
321  */
323  delete_cache(&addr_to_delete);
325  free(addr_to_delete.buf);
326  }
327  if (!__rpc_nconf2sockinfo(nconf, &si)) {
329  return NULL;
330  }
331 
332  memset(&hints, 0, sizeof hints);
333  hints.ai_family = si.si_af;
334  hints.ai_socktype = si.si_socktype;
335  hints.ai_protocol = si.si_proto;
336 
337 #ifdef CLNT_DEBUG
338  printf("trying netid %s family %d proto %d socktype %d\n",
339  nconf->nc_netid, si.si_af, si.si_proto, si.si_socktype);
340 #endif
341 
342  if (nconf->nc_protofmly != NULL && strcmp(nconf->nc_protofmly, NC_LOOPBACK) == 0) {
343  client = local_rpcb();
344  if (! client) {
345 #ifdef ND_DEBUG
346  clnt_pcreateerror("rpcbind clnt interface");
347 #endif
348  return (NULL);
349  } else {
350  struct sockaddr_un sun;
351 
352  *targaddr = malloc(sizeof(sun.sun_path));
353  strncpy(*targaddr, _PATH_RPCBINDSOCK,
354  sizeof(sun.sun_path));
355  return (client);
356  }
357  } else {
358  if (getaddrinfo(host, "sunrpc", &hints, &res) != 0) {
360  return NULL;
361  }
362  }
363 
364  for (tres = res; tres != NULL; tres = tres->ai_next) {
365  taddr.buf = tres->ai_addr;
366  taddr.len = taddr.maxlen = tres->ai_addrlen;
367 
368 #ifdef ND_DEBUG
369  {
370  char *ua;
371 
372  ua = taddr2uaddr(nconf, &taddr);
373  fprintf(stderr, "Got it [%s]\n", ua);
374  free(ua);
375  }
376 #endif
377 
378 #ifdef ND_DEBUG
379  {
380  int i;
381 
382  fprintf(stderr, "\tnetbuf len = %d, maxlen = %d\n",
383  taddr.len, taddr.maxlen);
384  fprintf(stderr, "\tAddress is ");
385  for (i = 0; i < taddr.len; i++)
386  fprintf(stderr, "%u.", ((char *)(taddr.buf))[i]);
387  fprintf(stderr, "\n");
388  }
389 #endif
390  client = clnt_tli_create(RPC_ANYFD, nconf, &taddr,
392 #ifdef ND_DEBUG
393  if (! client) {
394  clnt_pcreateerror("rpcbind clnt interface");
395  }
396 #endif
397 
398  if (client) {
399  tmpaddr = targaddr ? taddr2uaddr(nconf, &taddr) : NULL;
400  add_cache(host, nconf->nc_netid, &taddr, tmpaddr);
401  if (targaddr)
402  *targaddr = tmpaddr;
403  break;
404  }
405  }
406  if (res)
407  freeaddrinfo(res);
408  return (client);
409 }
namespace GUID const ADDRINFOEXW * hints
Definition: sock.c:80
#define freeaddrinfo
Definition: wspiapi.h:46
u_int32_t rpcvers_t
Definition: types.h:105
#define rwlock_wrlock(l)
Definition: reentrant.h:140
#define RPC_ANYFD
Definition: svc.h:328
char * strncpy(char *DstString, const char *SrcString, ACPI_SIZE Count)
Definition: utclib.c:427
#define free
Definition: debug_ros.c:5
char * host
Definition: whois.c:55
void * buf
Definition: types.h:147
static void delete_cache(struct netbuf *)
Definition: rpcb_clnt.c:171
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
#define rwlock_unlock(l)
Definition: reentrant.h:142
_Check_return_ _CRTIMP char *__cdecl strdup(_In_opt_z_ const char *_Src)
#define RPCBPROG
Definition: rpcb_prot.h:626
char * nc_protofmly
Definition: netconfig.h:14
smooth NULL
Definition: ftsmooth.c:416
static void add_cache(const char *, const char *, struct netbuf *, char *)
#define _PATH_RPCBINDSOCK
Definition: rpcb_prot.h:485
enum clnt_stat cf_stat
Definition: clnt.h:496
static FILE * client
Definition: client.c:41
u_int32_t rpcprog_t
Definition: types.h:104
unsigned int maxlen
Definition: types.h:145
char * nc_netid
Definition: netconfig.h:11
unsigned int len
Definition: types.h:146
static CLIENT * local_rpcb(void)
Definition: rpcb_clnt.c:420
GLenum const GLvoid * addr
Definition: glext.h:9621
void clnt_pcreateerror(char *s) const
Definition: clnt_perror.c:307
rwlock_t rpcbaddr_cache_lock
Definition: mt_misc.c:25
CLIENT * clnt_tli_create(const SOCKET fd_in, const struct netconfig *nconf, struct netbuf *svcaddr, const rpcprog_t prog, const rpcvers_t vers, const uint sendsz, const uint recvsz, int(*callback_xdr)(void *, void *), int(*callback_function)(void *, void *, void **), void *callback_args)
Definition: clnt_generic.c:347
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
static struct address_cache * check_cache(const char *, const char *)
#define RPCBVERS4
Definition: rpcb_prot.h:707
#define rwlock_rdlock(l)
Definition: reentrant.h:139
Definition: types.h:144
struct addrinfo * ai_next
Definition: ws2def.h:672
char * ac_uaddr
Definition: rpcb_clnt.c:78
GLuint res
Definition: glext.h:9613
FILE * stderr
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
#define malloc
Definition: debug_ros.c:4
int __rpc_nconf2sockinfo(const struct netconfig *nconf, struct __rpc_sockinfo *sip)
Definition: rpc_generic.c:540
size_t ai_addrlen
Definition: ws2def.h:669
char * taddr2uaddr(const struct netconfig *nconf, const struct netbuf *nbuf)
Definition: rpc_generic.c:609
struct netbuf * ac_taddr
Definition: rpcb_clnt.c:79
#define memset(x, y, z)
Definition: compat.h:39
#define NC_LOOPBACK
Definition: netconfig.h:46
struct sockaddr * ai_addr
Definition: ws2def.h:671
#define printf
Definition: config.h:203
#define getaddrinfo
Definition: wspiapi.h:44

◆ local_rpcb()

static CLIENT * local_rpcb ( void  )
static

Definition at line 420 of file rpcb_clnt.c.

421 {
422  CLIENT *client;
423  static struct netconfig *loopnconf;
424  static char *hostname;
425  extern mutex_t loopnconf_lock;
426  SOCKET sock;
427  size_t tsize;
428  struct netbuf nbuf;
429  struct sockaddr_un sun;
430 
431  /*
432  * Try connecting to the local rpcbind through a local socket
433  * first. If this doesn't work, try all transports defined in
434  * the netconfig file.
435  */
436  memset(&sun, 0, sizeof sun);
438  if (sock == INVALID_SOCKET)
439  goto try_nconf;
440  sun.sun_family = AF_UNIX;
441  strcpy(sun.sun_path, _PATH_RPCBINDSOCK);
442  nbuf.len = SUN_LEN(&sun);
443  nbuf.maxlen = sizeof (struct sockaddr_un);
444  nbuf.buf = &sun;
445 
446  tsize = __rpc_get_t_size(AF_UNIX, 0, 0);
448  (rpcvers_t)RPCBVERS, (u_int)tsize, (u_int)tsize,
449  NULL, NULL, NULL);
450 
451  if (client != NULL) {
452  /* Mark the socket to be closed in destructor */
454  return client;
455  }
456 
457  /* Nobody needs this socket anymore; free the descriptor. */
458  closesocket(sock);
459 
460 try_nconf:
461 
462 /* VARIABLES PROTECTED BY loopnconf_lock: loopnconf */
464  if (loopnconf == NULL) {
465  struct netconfig *nconf, *tmpnconf = NULL;
466  void *nc_handle;
467  SOCKET fd;
468 
469  nc_handle = setnetconfig();
470  if (nc_handle == NULL) {
471  /* fails to open netconfig file */
472  //syslog (LOG_ERR, "rpc: failed to open " NETCONFIG);
475  return (NULL);
476  }
477  while ((nconf = getnetconfig(nc_handle)) != NULL) {
478 #ifdef INET6
479  if ((strcmp(nconf->nc_protofmly, NC_INET6) == 0 ||
480 #else
481  if ((
482 #endif
483  strcmp(nconf->nc_protofmly, NC_INET) == 0) &&
484  (nconf->nc_semantics == NC_TPI_COTS ||
485  nconf->nc_semantics == NC_TPI_COTS_ORD)) {
486  fd = __rpc_nconf2fd(nconf);
487  /*
488  * Can't create a socket, assume that
489  * this family isn't configured in the kernel.
490  */
491  if (fd == SOCKET_ERROR)
492  continue;
493  closesocket(fd);
494  tmpnconf = nconf;
495  if (!strcmp(nconf->nc_protofmly, NC_INET))
496  hostname = IN4_LOCALHOST_STRING;
497  else
498  hostname = IN6_LOCALHOST_STRING;
499  }
500  }
501  if (tmpnconf == NULL) {
504  return (NULL);
505  }
506  loopnconf = getnetconfigent(tmpnconf->nc_netid);
507  /* loopnconf is never freed */
508  endnetconfig(nc_handle);
509  }
511  client = getclnthandle(hostname, loopnconf, NULL);
512  return (client);
513 }
static CLIENT * getclnthandle(const char *, const struct netconfig *, char **)
u_int __rpc_get_t_size(int af, int proto, int size)
Definition: rpc_generic.c:139
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
static SOCKET sock
Definition: syslog.c:45
SOCKET WSAAPI socket(IN INT af, IN INT type, IN INT protocol)
Definition: socklife.c:143
u_int32_t rpcvers_t
Definition: types.h:105
static int fd
Definition: io.c:51
#define CLSET_FD_CLOSE
Definition: clnt.h:251
#define mutex_lock(m)
Definition: reentrant.h:128
char * hostname
Definition: ftp.c:88
struct netconfig * getnetconfig(void *handlep)
Definition: getnetconfig.c:253
#define mutex_unlock(m)
Definition: reentrant.h:129
#define closesocket
Definition: main.c:39
#define NC_TPI_COTS_ORD
Definition: netconfig.h:32
#define RPCBPROG
Definition: rpcb_prot.h:626
char * nc_protofmly
Definition: netconfig.h:14
smooth NULL
Definition: ftsmooth.c:416
struct netconfig * getnetconfigent(char *netid) const
Definition: getnetconfig.c:432
#define SUN_LEN(ptr)
Definition: wintirpc.h:94
#define INVALID_SOCKET
Definition: winsock.h:332
#define _PATH_RPCBINDSOCK
Definition: rpcb_prot.h:485
if(!(yy_init))
Definition: macro.lex.yy.c:714
enum clnt_stat cf_stat
Definition: clnt.h:496
static FILE * client
Definition: client.c:41
u_int32_t rpcprog_t
Definition: types.h:104
char * nc_netid
Definition: netconfig.h:11
#define NC_INET
Definition: netconfig.h:47
#define NC_TPI_COTS
Definition: netconfig.h:31
#define RPCBVERS
Definition: rpcb_prot.h:627
CLIENT * clnt_vc_create(int fd, const struct netbuf *raddr, const rpcprog_t prog, const rpcvers_t vers, u_int sendsz, u_int recvsz, int *cb_xdr, int *cb_fn, void *cb_args)
Definition: clnt_vc.c:324
int endnetconfig(void *handlep)
Definition: getnetconfig.c:373
#define NC_INET6
Definition: netconfig.h:48
UINT32 u_int
Definition: types.h:82
Definition: types.h:144
Definition: tcpcore.h:1455
#define AF_UNIX
Definition: winsock.h:345
char * strcpy(char *DstString, const char *SrcString)
Definition: utclib.c:388
mutex_t loopnconf_lock
Definition: mt_misc.c:68
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
UINT_PTR SOCKET
Definition: winsock.h:47
unsigned long nc_semantics
Definition: netconfig.h:12
#define SOCK_STREAM
Definition: tcpip.h:118
#define CLNT_CONTROL(cl, rq, in)
Definition: clnt.h:240
Definition: module.h:446
void * setnetconfig()
Definition: getnetconfig.c:217
#define memset(x, y, z)
Definition: compat.h:39

Referenced by getclnthandle(), rpcb_set(), rpcb_taddr2uaddr(), rpcb_uaddr2taddr(), and rpcb_unset().

◆ rpcb_getaddr()

int rpcb_getaddr ( rpcprog_t  program,
rpcvers_t  version,
const struct netconfig nconf,
struct netbuf address,
const char host 
)

Definition at line 939 of file rpcb_clnt.c.

945 {
946  struct netbuf *na;
947 
949  (struct netconfig *) nconf, (char *) host,
950  (CLIENT **) NULL, (struct timeval *) NULL)) == NULL)
951  return (FALSE);
952 
953  if (na->len > address->maxlen) {
954  /* Too long address */
955  free(na->buf);
956  free(na);
958  return (FALSE);
959  }
960  memcpy(address->buf, na->buf, (size_t)na->len);
961  address->len = na->len;
962  free(na->buf);
963  free(na);
964  return (TRUE);
965 }
#define TRUE
Definition: types.h:120
#define free
Definition: debug_ros.c:5
char * host
Definition: whois.c:55
void * buf
Definition: types.h:147
smooth NULL
Definition: ftsmooth.c:416
static const WCHAR version[]
Definition: asmname.c:64
enum clnt_stat cf_stat
Definition: clnt.h:496
GLuint address
Definition: glext.h:9393
unsigned int len
Definition: types.h:146
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
GLuint program
Definition: glext.h:6723
Definition: types.h:144
struct netbuf * __rpcb_findaddr_timed(rpcprog_t program, rpcvers_t version, const struct netconfig *nconf, const char *host, CLIENT **clpp, struct timeval *tp)
Definition: rpcb_clnt.c:709

◆ rpcb_getmaps()

rpcblist* rpcb_getmaps ( struct netconfig nconf,
const char host 
) const

Definition at line 975 of file rpcb_clnt.c.

978 {
980  CLIENT *client;
981  enum clnt_stat clnt_st;
982  rpcvers_t vers = 0;
983 
984  client = getclnthandle(host, nconf, NULL);
985  if (client == NULL) {
986  return (head);
987  }
990  (char *)(void *)&head, tottimeout);
991  if (clnt_st == RPC_SUCCESS)
992  goto done;
993 
994  if ((clnt_st != RPC_PROGVERSMISMATCH) &&
995  (clnt_st != RPC_PROGUNAVAIL)) {
998  goto done;
999  }
1000 
1001  /* fall back to earlier version */
1002  CLNT_CONTROL(client, CLGET_VERS, (char *)(void *)&vers);
1003  if (vers == RPCBVERS4) {
1004  vers = RPCBVERS;
1005  CLNT_CONTROL(client, CLSET_VERS, (char *)(void *)&vers);
1008  (char *)(void *)&head, tottimeout) == RPC_SUCCESS)
1009  goto done;
1010  }
1013 
1014 done:
1016  return (head);
1017 }
static CLIENT * getclnthandle(const char *, const struct netconfig *, char **)
u_int32_t rpcproc_t
Definition: types.h:106
#define clnt_geterr(rh, errp)
Definition: clnt.h:220
u_int32_t rpcvers_t
Definition: types.h:105
struct outqueuenode * head
Definition: adnsresfilter.c:66
bool_t xdr_rpcblist_ptr(XDR *xdrs, rpcblist_ptr *rp)
Definition: rpcb_prot.c:108
char * host
Definition: whois.c:55
#define RPCBPROC_DUMP
Definition: rpcb_prot.h:691
#define CLGET_VERS
Definition: clnt.h:255
bool_t(* xdrproc_t)(XDR *,...)
Definition: xdr.h:144
#define CLNT_CALL(rh, proc, xargs, argsp, xres, resp, secs)
Definition: clnt.h:199
smooth NULL
Definition: ftsmooth.c:416
enum clnt_stat cf_stat
Definition: clnt.h:496
static FILE * client
Definition: client.c:41
#define RPCBVERS
Definition: rpcb_prot.h:627
bool_t xdr_void(void)
Definition: xdr.c:92
#define CLNT_DESTROY(rh)
Definition: clnt.h:275
static struct timeval tottimeout
Definition: rpcb_clnt.c:63
#define RPCBVERS4
Definition: rpcb_prot.h:707
#define CLSET_VERS
Definition: clnt.h:256
struct rpc_err cf_error
Definition: clnt.h:497
#define CLNT_CONTROL(cl, rq, in)
Definition: clnt.h:240
clnt_stat
Definition: clnt_stat.h:21

◆ rpcb_gettime()

bool_t rpcb_gettime ( char host,
time_t timep 
) const

Definition at line 1109 of file rpcb_clnt.c.

1112 {
1113  CLIENT *client = NULL;
1114  void *handle;
1115  struct netconfig *nconf;
1116  rpcvers_t vers;
1117  enum clnt_stat st;
1118 
1119  if ((host == NULL) || (host[0] == 0)) {
1120  time(timep);
1121  return (TRUE);
1122  }
1123 
1124  if ((handle = __rpc_setconf("netpath")) == NULL) {
1126  return (FALSE);
1127  }
1129  while (client == NULL) {
1130  if ((nconf = __rpc_getconf(handle)) == NULL) {
1133  break;
1134  }
1135  client = getclnthandle(host, nconf, NULL);
1136  if (client)
1137  break;
1138  }
1140  if (client == (CLIENT *) NULL) {
1141  return (FALSE);
1142  }
1143 
1145  (xdrproc_t) xdr_void, NULL,
1146  (xdrproc_t) xdr_int, (char *)(void *)timep, tottimeout);
1147 
1148  if ((st == RPC_PROGVERSMISMATCH) || (st == RPC_PROGUNAVAIL)) {
1149  CLNT_CONTROL(client, CLGET_VERS, (char *)(void *)&vers);
1150  if (vers == RPCBVERS4) {
1151  /* fall back to earlier version */
1152  vers = RPCBVERS;
1153  CLNT_CONTROL(client, CLSET_VERS, (char *)(void *)&vers);
1155  (xdrproc_t) xdr_void, NULL,
1156  (xdrproc_t) xdr_int, (char *)(void *)timep,
1157  tottimeout);
1158  }
1159  }
1161  return (st == RPC_SUCCESS? TRUE: FALSE);
1162 }
static CLIENT * getclnthandle(const char *, const struct netconfig *, char **)
u_int32_t rpcproc_t
Definition: types.h:106
namespace GUID const ADDRINFOEXW ADDRINFOEXW struct timeval OVERLAPPED LPLOOKUPSERVICE_COMPLETION_ROUTINE HANDLE * handle
Definition: sock.c:82
#define TRUE
Definition: types.h:120
u_int32_t rpcvers_t
Definition: types.h:105
char * host
Definition: whois.c:55
struct netconfig * __rpc_getconf(void *vhandle)
Definition: rpc_generic.c:348
__u16 time
Definition: mkdosfs.c:366
#define CLGET_VERS
Definition: clnt.h:255
#define RPCBPROC_GETTIME
Definition: rpcb_prot.h:697
bool_t(* xdrproc_t)(XDR *,...)
Definition: xdr.h:144
#define CLNT_CALL(rh, proc, xargs, argsp, xres, resp, secs)
Definition: clnt.h:199
smooth NULL
Definition: ftsmooth.c:416
bool_t xdr_int(XDR *xdrs, int *ip)
Definition: xdr.c:103
enum clnt_stat cf_stat
Definition: clnt.h:496
static FILE * client
Definition: client.c:41
#define RPCBVERS
Definition: rpcb_prot.h:627
bool_t xdr_void(void)
Definition: xdr.c:92
#define CLNT_DESTROY(rh)
Definition: clnt.h:275
static struct timeval tottimeout
Definition: rpcb_clnt.c:63
void * __rpc_setconf(char *nettype) const
Definition: rpc_generic.c:305
#define RPCBVERS4
Definition: rpcb_prot.h:707
#define CLSET_VERS
Definition: clnt.h:256
void __rpc_endconf(void *vhandle)
Definition: rpc_generic.c:425
#define CLNT_CONTROL(cl, rq, in)
Definition: clnt.h:240
clnt_stat
Definition: clnt_stat.h:21

◆ rpcb_rmtcall()

enum clnt_stat rpcb_rmtcall ( struct netconfig nconf,
const char host,
rpcprog_t  prog,
rpcvers_t  vers,
rpcproc_t  proc,
xdrproc_t  xdrargs,
caddr_t  argsp,
xdrproc_t  xdrres,
caddr_t  resp,
struct timeval  tout,
const struct netbuf addr_ptr 
) const

Definition at line 1027 of file rpcb_clnt.c.

1038 {
1039  CLIENT *client;
1040  enum clnt_stat stat;
1041  struct r_rpcb_rmtcallargs a;
1042  struct r_rpcb_rmtcallres r;
1043  rpcvers_t rpcb_vers;
1044 
1045  stat = 0;
1046  client = getclnthandle(host, nconf, NULL);
1047  if (client == NULL) {
1048  return (RPC_FAILED);
1049  }
1050  /*LINTED const castaway*/
1051  CLNT_CONTROL(client, CLSET_RETRY_TIMEOUT, (char *)(void *)&rmttimeout);
1052  a.prog = prog;
1053  a.vers = vers;
1054  a.proc = proc;
1055  a.args.args_val = argsp;
1056  a.xdr_args = xdrargs;
1057  r.addr = NULL;
1058  r.results.results_val = resp;
1059  r.xdr_res = xdrres;
1060 
1061  for (rpcb_vers = RPCBVERS4; rpcb_vers >= RPCBVERS; rpcb_vers--) {
1062  CLNT_CONTROL(client, CLSET_VERS, (char *)(void *)&rpcb_vers);
1064  (xdrproc_t) xdr_rpcb_rmtcallargs, (char *)(void *)&a,
1065  (xdrproc_t) xdr_rpcb_rmtcallres, (char *)(void *)&r, tout);
1066  if ((stat == RPC_SUCCESS) && (addr_ptr != NULL)) {
1067  struct netbuf *na;
1068  /*LINTED const castaway*/
1069  na = uaddr2taddr((struct netconfig *) nconf, r.addr);
1070  if (!na) {
1072  /*LINTED const castaway*/
1073  ((struct netbuf *) addr_ptr)->len = 0;
1074  goto error;
1075  }
1076  if (na->len > addr_ptr->maxlen) {
1077  /* Too long address */
1078  stat = RPC_FAILED; /* XXX A better error no */
1079  free(na->buf);
1080  free(na);
1081  /*LINTED const castaway*/
1082  ((struct netbuf *) addr_ptr)->len = 0;
1083  goto error;
1084  }
1085  memcpy(addr_ptr->buf, na->buf, (size_t)na->len);
1086  /*LINTED const castaway*/
1087  ((struct netbuf *)addr_ptr)->len = na->len;
1088  free(na->buf);
1089  free(na);
1090  break;
1091  } else if ((stat != RPC_PROGVERSMISMATCH) &&
1092  (stat != RPC_PROGUNAVAIL)) {
1093  goto error;
1094  }
1095  }
1096 error:
1098  if (r.addr)
1099  xdr_free((xdrproc_t) xdr_wrapstring, (char *)(void *)&r.addr);
1100  return (stat);
1101 }
static CLIENT * getclnthandle(const char *, const struct netconfig *, char **)
bool_t xdr_wrapstring(XDR *, char **)
Definition: xdr.c:772
u_int32_t rpcproc_t
Definition: types.h:106
u_int32_t rpcvers_t
Definition: types.h:105
#define CLSET_RETRY_TIMEOUT
Definition: clnt.h:265
#define error(str)
Definition: mkdosfs.c:1605
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
char * prog
Definition: isohybrid.c:47
#define free
Definition: debug_ros.c:5
char * host
Definition: whois.c:55
void xdr_free(xdrproc_t proc, void *objp)
Definition: xdr.c:78
void * buf
Definition: types.h:147
static HANDLE proc()
Definition: pdb.c:32
bool_t(* xdrproc_t)(XDR *,...)
Definition: xdr.h:144
#define CLNT_CALL(rh, proc, xargs, argsp, xres, resp, secs)
Definition: clnt.h:199
smooth NULL
Definition: ftsmooth.c:416
struct netbuf * uaddr2taddr(const struct netconfig *nconf, const char *uaddr)
Definition: rpc_generic.c:619
bool_t xdr_rpcb_rmtcallres(XDR *xdrs, struct rpcb_rmtcallres *p)
Definition: rpcb_prot.c:322
static FILE * client
Definition: client.c:41
unsigned int maxlen
Definition: types.h:145
bool_t xdr_rpcb_rmtcallargs(XDR *xdrs, struct rpcb_rmtcallargs *p)
Definition: rpcb_prot.c:270
unsigned int len
Definition: types.h:146
#define RPCBVERS
Definition: rpcb_prot.h:627
Definition: stat.h:55
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
static const struct timeval rmttimeout
Definition: rpcb_clnt.c:64
_CRTIMP int __cdecl stat(const char *_Filename, struct stat *_Stat)
Definition: stat.h:345
#define CLNT_DESTROY(rh)
Definition: clnt.h:275
#define RPCBVERS4
Definition: rpcb_prot.h:707
#define CLSET_VERS
Definition: clnt.h:256
Definition: types.h:144
GLboolean GLboolean GLboolean GLboolean a
Definition: glext.h:6204
#define CLNT_CONTROL(cl, rq, in)
Definition: clnt.h:240
clnt_stat
Definition: clnt_stat.h:21
#define RPCBPROC_CALLIT
Definition: rpcb_prot.h:694

◆ rpcb_set()

bool_t rpcb_set ( rpcprog_t  program,
rpcvers_t  version,
const struct netconfig nconf,
const struct netbuf address 
)

Definition at line 520 of file rpcb_clnt.c.

525 {
526  CLIENT *client;
527  bool_t rslt = FALSE;
528  RPCB parms;
529  char uidbuf[32];
530 
531  /* parameter checking */
532  if (nconf == NULL) {
534  return (FALSE);
535  }
536  if (address == NULL) {
538  return (FALSE);
539  }
540  client = local_rpcb();
541  if (! client) {
542  return (FALSE);
543  }
544 
545  /* convert to universal */
546  /*LINTED const castaway*/
547  parms.r_addr = taddr2uaddr((struct netconfig *) nconf,
548  (struct netbuf *)address);
549  if (!parms.r_addr) {
552  return (FALSE); /* no universal address */
553  }
554  parms.r_prog = program;
555  parms.r_vers = version;
556  parms.r_netid = nconf->nc_netid;
557  /*
558  * Though uid is not being used directly, we still send it for
559  * completeness. For non-unix platforms, perhaps some other
560  * string or an empty string can be sent.
561  */
562  (void) snprintf(uidbuf, sizeof uidbuf, "%d", 20010 /*geteuid()*/);
563  parms.r_owner = uidbuf;
564 
566  (char *)&parms, (xdrproc_t) xdr_bool,
567  (char *)&rslt, tottimeout);
568 
570  free(parms.r_addr);
571  return (rslt);
572 }
u_int32_t rpcproc_t
Definition: types.h:106
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
int32_t bool_t
Definition: types.h:101
#define free
Definition: debug_ros.c:5
#define snprintf
Definition: wintirpc.h:48
char * r_netid
Definition: rpcb_prot.h:143
bool_t(* xdrproc_t)(XDR *,...)
Definition: xdr.h:144
#define CLNT_CALL(rh, proc, xargs, argsp, xres, resp, secs)
Definition: clnt.h:199
smooth NULL
Definition: ftsmooth.c:416
static const WCHAR version[]
Definition: asmname.c:64
rpcprog_t r_prog
Definition: rpcb_prot.h:141
char * r_addr
Definition: rpcb_prot.h:144
enum clnt_stat cf_stat
Definition: clnt.h:496
static FILE * client
Definition: client.c:41
GLuint address
Definition: glext.h:9393
char * r_owner
Definition: rpcb_prot.h:145
char * nc_netid
Definition: netconfig.h:11
static CLIENT * local_rpcb(void)
Definition: rpcb_clnt.c:420
rpcvers_t r_vers
Definition: rpcb_prot.h:142
#define RPCBPROC_SET
Definition: rpcb_prot.h:682
#define CLNT_DESTROY(rh)
Definition: clnt.h:275
static struct timeval tottimeout
Definition: rpcb_clnt.c:63
GLuint program
Definition: glext.h:6723
bool_t xdr_bool(XDR *xdrs, bool_t *bp)
Definition: xdr.c:428
bool_t xdr_rpcb(XDR *xdrs, RPCB *objp)
Definition: rpcb_prot.c:50
Definition: types.h:144
char * taddr2uaddr(const struct netconfig *nconf, const struct netbuf *nbuf)
Definition: rpc_generic.c:609

Referenced by pmap_set(), and svc_reg().

◆ rpcb_taddr2uaddr()

char* rpcb_taddr2uaddr ( struct netconfig nconf,
struct netbuf taddr 
)

Definition at line 1170 of file rpcb_clnt.c.

1173 {
1174  CLIENT *client;
1175  char *uaddr = NULL;
1176 
1177 
1178  /* parameter checking */
1179  if (nconf == NULL) {
1181  return (NULL);
1182  }
1183  if (taddr == NULL) {
1185  return (NULL);
1186  }
1187  client = local_rpcb();
1188  if (! client) {
1189  return (NULL);
1190  }
1191 
1193  (xdrproc_t) xdr_netbuf, (char *)(void *)taddr,
1194  (xdrproc_t) xdr_wrapstring, (char *)(void *)&uaddr, tottimeout);
1196  return (uaddr);
1197 }
bool_t xdr_wrapstring(XDR *, char **)
Definition: xdr.c:772
u_int32_t rpcproc_t
Definition: types.h:106
#define RPCBPROC_TADDR2UADDR
Definition: rpcb_prot.h:703
bool_t xdr_netbuf(XDR *xdrs, struct netbuf *objp)
Definition: rpcb_prot.c:344
bool_t(* xdrproc_t)(XDR *,...)
Definition: xdr.h:144
#define CLNT_CALL(rh, proc, xargs, argsp, xres, resp, secs)
Definition: clnt.h:199
smooth NULL
Definition: ftsmooth.c:416
enum clnt_stat cf_stat
Definition: clnt.h:496
static FILE * client
Definition: client.c:41
static CLIENT * local_rpcb(void)
Definition: rpcb_clnt.c:420
#define CLNT_DESTROY(rh)
Definition: clnt.h:275
static struct timeval tottimeout
Definition: rpcb_clnt.c:63

◆ rpcb_uaddr2taddr()

struct netbuf* rpcb_uaddr2taddr ( struct netconfig nconf,
char uaddr 
)

Definition at line 1204 of file rpcb_clnt.c.

1207 {
1208  CLIENT *client;
1209  struct netbuf *taddr;
1210 
1211 
1212  /* parameter checking */
1213  if (nconf == NULL) {
1215  return (NULL);
1216  }
1217  if (uaddr == NULL) {
1219  return (NULL);
1220  }
1221  client = local_rpcb();
1222  if (! client) {
1223  return (NULL);
1224  }
1225 
1226  taddr = (struct netbuf *)calloc(1, sizeof (struct netbuf));
1227  if (taddr == NULL) {
1229  return (NULL);
1230  }
1232  (xdrproc_t) xdr_wrapstring, (char *)(void *)&uaddr,
1233  (xdrproc_t) xdr_netbuf, (char *)(void *)taddr,
1234  tottimeout) != RPC_SUCCESS) {
1235  free(taddr);
1236  taddr = NULL;
1237  }
1239  return (taddr);
1240 }
bool_t xdr_wrapstring(XDR *, char **)
Definition: xdr.c:772
u_int32_t rpcproc_t
Definition: types.h:106
#define free
Definition: debug_ros.c:5
bool_t xdr_netbuf(XDR *xdrs, struct netbuf *objp)
Definition: rpcb_prot.c:344
bool_t(* xdrproc_t)(XDR *,...)
Definition: xdr.h:144
#define CLNT_CALL(rh, proc, xargs, argsp, xres, resp, secs)
Definition: clnt.h:199
smooth NULL
Definition: ftsmooth.c:416
enum clnt_stat cf_stat
Definition: clnt.h:496
static FILE * client
Definition: client.c:41
static CLIENT * local_rpcb(void)
Definition: rpcb_clnt.c:420
#define RPCBPROC_UADDR2TADDR
Definition: rpcb_prot.h:700
#define CLNT_DESTROY(rh)
Definition: clnt.h:275
static struct timeval tottimeout
Definition: rpcb_clnt.c:63
Definition: types.h:144
#define calloc
Definition: rosglue.h:14

◆ rpcb_unset()

bool_t rpcb_unset ( rpcprog_t  program,
rpcvers_t  version,
const struct netconfig nconf 
)

Definition at line 581 of file rpcb_clnt.c.

585 {
586  CLIENT *client;
587  bool_t rslt = FALSE;
588  RPCB parms;
589  char uidbuf[32];
590 
591  client = local_rpcb();
592  if (! client) {
593  return (FALSE);
594  }
595 
596  parms.r_prog = program;
597  parms.r_vers = version;
598  if (nconf)
599  parms.r_netid = nconf->nc_netid;
600  else {
601  /*LINTED const castaway*/
602  parms.r_netid = (char *) &nullstring[0]; /* unsets all */
603  }
604  /*LINTED const castaway*/
605  parms.r_addr = (char *) &nullstring[0];
606  (void) snprintf(uidbuf, sizeof uidbuf, "%d", 20010 /*geteuid()*/);
607  parms.r_owner = uidbuf;
608 
610  (char *)(void *)&parms, (xdrproc_t) xdr_bool,
611  (char *)(void *)&rslt, tottimeout);
612 
614  return (rslt);
615 }
u_int32_t rpcproc_t
Definition: types.h:106
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
int32_t bool_t
Definition: types.h:101
#define snprintf
Definition: wintirpc.h:48
char * r_netid
Definition: rpcb_prot.h:143
bool_t(* xdrproc_t)(XDR *,...)
Definition: xdr.h:144
#define CLNT_CALL(rh, proc, xargs, argsp, xres, resp, secs)
Definition: clnt.h:199
static const WCHAR version[]
Definition: asmname.c:64
#define RPCBPROC_UNSET
Definition: rpcb_prot.h:685
rpcprog_t r_prog
Definition: rpcb_prot.h:141
char * r_addr
Definition: rpcb_prot.h:144
static FILE * client
Definition: client.c:41
char * r_owner
Definition: rpcb_prot.h:145
char * nc_netid
Definition: netconfig.h:11
static CLIENT * local_rpcb(void)
Definition: rpcb_clnt.c:420
rpcvers_t r_vers
Definition: rpcb_prot.h:142
static const char nullstring[]
Definition: rpcb_clnt.c:69
#define CLNT_DESTROY(rh)
Definition: clnt.h:275
static struct timeval tottimeout
Definition: rpcb_clnt.c:63
GLuint program
Definition: glext.h:6723
bool_t xdr_bool(XDR *xdrs, bool_t *bp)
Definition: xdr.c:428
bool_t xdr_rpcb(XDR *xdrs, RPCB *objp)
Definition: rpcb_prot.c:50

Referenced by pmap_unset(), rpc_reg(), svc_create(), svc_tp_create(), and svc_unreg().

◆ xdr_wrapstring()

bool_t xdr_wrapstring ( XDR ,
char **   
)

Definition at line 772 of file xdr.c.

775 {
776 #ifdef __REACTOS__ // CVE-2017-8779
777  return xdr_string(xdrs, cpp, RPC_MAXDATASIZE);
778 #else
779  return xdr_string(xdrs, cpp, LASTUNSIGNED);
780 #endif
781 }
bool_t xdr_string(XDR *xdrs, char **cpp, u_int maxsize)
Definition: xdr.c:678
#define LASTUNSIGNED
Definition: xdr.c:65
#define RPC_MAXDATASIZE
Definition: rpc_com.h:51

Referenced by __rpcb_findaddr_timed(), rpcb_taddr2uaddr(), and rpcb_uaddr2taddr().

Variable Documentation

◆ __rpc_lowvers

int __rpc_lowvers

Referenced by __rpc_control(), and rpc_broadcast_exp().

◆ cachesize

int cachesize
static

Definition at line 84 of file rpcb_clnt.c.

Referenced by add_cache(), and delete_cache().

◆ front

◆ nullstring

const char nullstring[] = "\000"
static

Definition at line 69 of file rpcb_clnt.c.

Referenced by __rpcb_findaddr_timed(), and rpcb_unset().

◆ rmttimeout

const struct timeval rmttimeout = { 3, 0 }
static

Definition at line 64 of file rpcb_clnt.c.

◆ rpcbaddr_cache_lock

rwlock_t rpcbaddr_cache_lock

Definition at line 25 of file mt_misc.c.

Referenced by add_cache(), and getclnthandle().

◆ rpcbrmttime

struct timeval rpcbrmttime = { 15, 0 }
static

Definition at line 65 of file rpcb_clnt.c.

Referenced by __rpcb_findaddr_timed().

◆ tottimeout