#define __TIME_T_TYPE __SLONGWORD_TYPE
#define __USECONDS_T_TYPE __U32_TYPE
#define __SUSECONDS_T_TYPE __SLONGWORD_TYPE
-#define __DADDR_T_TYPE __S32_TYPE
#define __KEY_T_TYPE __S32_TYPE
#define __CLOCKID_T_TYPE __S32_TYPE
#define __TIMER_T_TYPE void *
handle the portion of the segment past the end of the file
mapping. */
if (__glibc_unlikely
- (__mprotect ((caddr_t) (l->l_addr + c->mapend),
+ (__mprotect ((void *) (l->l_addr + c->mapend),
loadcmds[nloadcmds - 1].mapstart - c->mapend,
PROT_NONE) < 0))
return DL_MAP_SEGMENTS_ERROR_MPROTECT;
if (__glibc_unlikely ((c->prot & PROT_WRITE) == 0))
{
/* Dag nab it. */
- if (__mprotect ((caddr_t) (zero
- & ~(GLRO(dl_pagesize) - 1)),
- GLRO(dl_pagesize), c->prot|PROT_WRITE) < 0)
- return DL_MAP_SEGMENTS_ERROR_MPROTECT;
+ if (__mprotect ((void *) (zero & ~(GLRO(dl_pagesize) - 1)),
+ GLRO(dl_pagesize), c->prot|PROT_WRITE) < 0)
+ return DL_MAP_SEGMENTS_ERROR_MPROTECT;
}
memset ((void *) zero, '\0', zeropage - zero);
if (__glibc_unlikely ((c->prot & PROT_WRITE) == 0))
- __mprotect ((caddr_t) (zero & ~(GLRO(dl_pagesize) - 1)),
+ __mprotect ((void *) (zero & ~(GLRO(dl_pagesize) - 1)),
GLRO(dl_pagesize), c->prot);
}
if (zeroend > zeropage)
{
/* Map the remaining zero pages in from the zero fill FD. */
- caddr_t mapat;
- mapat = __mmap ((caddr_t) zeropage, zeroend - zeropage,
+ char *mapat;
+ mapat = __mmap ((void *) zeropage, zeroend - zeropage,
c->prot, MAP_ANON|MAP_PRIVATE|MAP_FIXED,
-1, 0);
if (__glibc_unlikely (mapat == MAP_FAILED))
{
/* Insufficient space left; allocate another page plus one extra
page to reduce number of mmap calls. */
- caddr_t page;
+ char *page;
size_t nup = (n + GLRO(dl_pagesize) - 1) & ~(GLRO(dl_pagesize) - 1);
if (__glibc_unlikely (nup == 0 && n != 0))
return NULL;
{
struct textrels
{
- caddr_t start;
+ char *start;
size_t len;
int prot;
struct textrels *next;
newp->len = ALIGN_UP (ph->p_vaddr + ph->p_memsz, GLRO(dl_pagesize))
- ALIGN_DOWN (ph->p_vaddr, GLRO(dl_pagesize));
newp->start = PTR_ALIGN_DOWN (ph->p_vaddr, GLRO(dl_pagesize))
- + (caddr_t) l->l_addr;
+ + (char *) l->l_addr;
newp->prot = 0;
if (ph->p_flags & PF_R)
CFLAGS-RPC_exec_startup_get_info.o = $(no-stack-protector)
\f
# Make generated headers compatible with all support standards
-migheaderpipe := | sed -e 's/\<ino64_t\>/__ino64_t/' -e 's/\<loff_t\>/__loff_t/'
+migheaderpipe := | sed -e 's/\<ino64_t\>/__ino64_t/' -e 's/\<loff_t\>/__off64_t/'
include ../mach/Machrules
include ../Rules
\f
#include <string.h>
error_t
-_hurd_fd_read (struct hurd_fd *fd, void *buf, size_t *nbytes, loff_t offset)
+_hurd_fd_read (struct hurd_fd *fd, void *buf, size_t *nbytes, off64_t offset)
{
error_t err;
char *data;
error_t
_hurd_fd_write (struct hurd_fd *fd,
- const void *buf, size_t *nbytes, loff_t offset)
+ const void *buf, size_t *nbytes, off64_t offset)
{
error_t err;
mach_msg_type_number_t wrote;
If successful, stores the amount actually read or written in *NBYTES. */
extern error_t _hurd_fd_read (struct hurd_fd *fd,
- void *buf, size_t *nbytes, __loff_t offset);
+ void *buf, size_t *nbytes,
+ __off64_t offset);
extern error_t _hurd_fd_write (struct hurd_fd *fd,
- const void *buf, size_t *nbytes, __loff_t offset);
+ const void *buf, size_t *nbytes,
+ __off64_t offset);
/* Call *RPC on PORT and/or CTTY; if a call on CTTY returns EBACKGROUND,
/* The magic number is wrong: not a message catalog file. */
#ifdef HAVE_MMAP
if (use_mmap)
- munmap ((caddr_t) data, size);
+ munmap (data, size);
else
#endif
free (data);
free (domain->malloced);
#ifdef HAVE_MMAP
if (use_mmap)
- munmap ((caddr_t) data, size);
+ munmap (data, size);
else
#endif
free (data);
free (domain->malloced);
+ /* Casts below are necessary because domain->data is const. */
# ifdef _POSIX_MAPPED_FILES
if (domain->use_mmap)
- munmap ((caddr_t) domain->data, domain->mmap_size);
+ munmap ((void *) domain->data, domain->mmap_size);
else
# endif /* _POSIX_MAPPED_FILES */
free ((void *) domain->data);
/* Some systems do not have this flag; it is superfluous. */
# define MAP_FILE 0
# endif
- filedata = __mmap ((caddr_t) 0, st.st_size,
- PROT_READ, MAP_FILE|MAP_COPY, fd, 0);
+ filedata = __mmap (NULL, st.st_size, PROT_READ, MAP_FILE|MAP_COPY, fd, 0);
if (__glibc_unlikely (filedata == MAP_FAILED))
{
filedata = NULL;
{
#ifdef _POSIX_MAPPED_FILES
if (alloc == ld_mapped)
- __munmap ((caddr_t) filedata, st.st_size);
+ __munmap (filedata, st.st_size);
#endif
return;
}
if (locale->private.cleanup)
(*locale->private.cleanup) (locale);
+ /* The casts below are necessary because locale->name and
+ locale->filedata are const. */
switch (__builtin_expect (locale->alloc, ld_mapped))
{
case ld_malloced:
- free ((void *) locale->filedata);
+ free ((char *) locale->filedata);
break;
case ld_mapped:
#ifdef _POSIX_MAPPED_FILES
- __munmap ((caddr_t) locale->filedata, locale->filesize);
+ __munmap ((char *) locale->filedata, locale->filesize);
break;
#endif
case ld_archive: /* Nothing to do. */
# include <unistd.h>
# include <errno.h>
-struct ustat
- {
- __daddr_t f_tfree; /* Number of free blocks. */
- __ino_t f_tinode; /* Number of free inodes. */
- char f_fname[6];
- char f_fpack[6];
-};
+struct ustat;
int
__old_ustat (dev_t dev, struct ustat *ust)
status = __do_niscall (req.ns_object.ns_object_val[0].zo_domain,
NIS_ADD, (xdrproc_t) _xdr_ns_request,
- (caddr_t) &req, (xdrproc_t) _xdr_nis_result,
- (caddr_t) res, MASTER_ONLY, NULL);
+ (char *) &req, (xdrproc_t) _xdr_nis_result,
+ (char *) res, MASTER_ONLY, NULL);
if (status != NIS_SUCCESS)
NIS_RES_STATUS (res) = status;
if (dbp->clnt == NULL)
return NIS_RPCERROR;
- clnt_control (dbp->clnt, CLSET_TIMEOUT, (caddr_t) &RPCTIMEOUT);
+ clnt_control (dbp->clnt, CLSET_TIMEOUT, (char *) &RPCTIMEOUT);
/* If the program exists, close the socket */
if (fcntl (dbp->socket, F_SETFD, 1) == -1)
perror ("fcntl: F_SETFD");
/* __nisbind_connect (dbp) must be run before calling this function !
So we could use the same binding twice */
nis_error
-__do_niscall3 (dir_binding *dbp, u_long prog, xdrproc_t xargs, caddr_t req,
- xdrproc_t xres, caddr_t resp, unsigned int flags, nis_cb *cb)
+__do_niscall3 (dir_binding *dbp, u_long prog, xdrproc_t xargs, char *req,
+ xdrproc_t xres, char *resp, unsigned int flags, nis_cb *cb)
{
enum clnt_stat result;
nis_error retcode;
nis_error
__do_niscall2 (const nis_server *server, u_int server_len, u_long prog,
- xdrproc_t xargs, caddr_t req, xdrproc_t xres, caddr_t resp,
+ xdrproc_t xargs, char *req, xdrproc_t xres, char *resp,
unsigned int flags, nis_cb *cb)
{
dir_binding dbp;
nis_error
__do_niscall (const_nis_name name, u_long prog, xdrproc_t xargs,
- caddr_t req, xdrproc_t xres, caddr_t resp, unsigned int flags,
+ char *req, xdrproc_t xres, char *resp, unsigned int flags,
nis_cb *cb)
{
dir_binding bptr;
xdr_argument = (xdrproc_t) xdr_cback_data;
xdr_result = (xdrproc_t) xdr_bool;
memset (&argument, 0, sizeof (argument));
- if (!svc_getargs (transp, xdr_argument, (caddr_t) & argument))
+ if (!svc_getargs (transp, xdr_argument, (char *) & argument))
{
svcerr_decode (transp);
return;
xdr_argument = (xdrproc_t) xdr_void;
xdr_result = (xdrproc_t) xdr_void;
memset (&argument, 0, sizeof (argument));
- if (!svc_getargs (transp, xdr_argument, (caddr_t) & argument))
+ if (!svc_getargs (transp, xdr_argument, (char *) & argument))
{
svcerr_decode (transp);
return;
xdr_argument = (xdrproc_t) _xdr_nis_error;
xdr_result = (xdrproc_t) xdr_void;
memset (&argument, 0, sizeof (argument));
- if (!svc_getargs (transp, xdr_argument, (caddr_t) & argument))
+ if (!svc_getargs (transp, xdr_argument, (char *) & argument))
{
svcerr_decode (transp);
return;
}
if (result != NULL && !svc_sendreply (transp, xdr_result, result))
svcerr_systemerr (transp);
- if (!svc_freeargs (transp, xdr_argument, (caddr_t) & argument))
+ if (!svc_freeargs (transp, xdr_argument, (char *) & argument))
{
fputs (_ ("unable to free arguments"), stderr);
exit (1);
/* See if callback 'thread' in the server is still alive. */
cb_is_running = FALSE;
if (clnt_call (bptr->clnt, NIS_CALLBACK, (xdrproc_t) xdr_netobj,
- (caddr_t) cookie, (xdrproc_t) xdr_bool,
- (caddr_t) &cb_is_running, TIMEOUT) != RPC_SUCCESS)
+ (char *) cookie, (xdrproc_t) xdr_bool,
+ (char *) &cb_is_running, TIMEOUT) != RPC_SUCCESS)
cb_is_running = FALSE;
if (cb_is_running == FALSE)
memset (&cpres, '\0', sizeof (cp_result));
if (__do_niscall2 (&NIS_RES_OBJECT(res2)->DI_data.do_servers.do_servers_val[i],
1, NIS_CHECKPOINT, (xdrproc_t) _xdr_nis_name,
- (caddr_t) &dirname, (xdrproc_t) _xdr_cp_result,
- (caddr_t) &cpres, 0, NULL) != NIS_SUCCESS)
+ (char *) &dirname, (xdrproc_t) _xdr_cp_result,
+ (char *) &cpres, 0, NULL) != NIS_SUCCESS)
NIS_RES_STATUS (res) = NIS_RPCERROR;
else
{
sizeof (struct sockaddr_in));
/* Transmit to NULLPROC, return immediately. */
clnt_call (clnt, NULLPROC,
- (xdrproc_t) xdr_void, (caddr_t) 0,
- (xdrproc_t) xdr_void, (caddr_t) 0, TIMEOUT00);
+ (xdrproc_t) xdr_void, (char *) 0,
+ (xdrproc_t) xdr_void, (char *) 0, TIMEOUT00);
}
while (found == -1) {
/* Receive reply from NULLPROC asynchronously. Note null inproc. */
int rc = clnt_call (clnt, NULLPROC,
- (xdrproc_t) NULL, (caddr_t) 0,
- (xdrproc_t) xdr_void, (caddr_t) 0,
+ (xdrproc_t) NULL, (char *) 0,
+ (xdrproc_t) xdr_void, (char *) 0,
*timeout);
if (RPC_SUCCESS == rc) {
uint32_t val;
extern unsigned long int inetstr2int (const char *str);
extern long int __nis_findfastest (dir_binding *bind);
extern nis_error __do_niscall2 (const nis_server *serv, u_int serv_len,
- u_long prog, xdrproc_t xargs, caddr_t req,
- xdrproc_t xres, caddr_t resp,
+ u_long prog, xdrproc_t xargs, char *req,
+ xdrproc_t xres, char *resp,
unsigned int flags, nis_cb *cb);
extern nis_error __do_niscall (const_nis_name name, u_long prog,
- xdrproc_t xargs, caddr_t req,
- xdrproc_t xres, caddr_t resp,
+ xdrproc_t xargs, char *req,
+ xdrproc_t xres, char *resp,
unsigned int flags, nis_cb *cb);
extern nis_error __do_niscall3 (dir_binding *dbp, u_long prog,
- xdrproc_t xargs, caddr_t req,
- xdrproc_t xres, caddr_t resp,
+ xdrproc_t xargs, char *req,
+ xdrproc_t xres, char *resp,
unsigned int flags, nis_cb *cb);
libnsl_hidden_proto (__do_niscall3)
again:
result = clnt_call (bptr.clnt, NIS_LOOKUP,
(xdrproc_t) _xdr_ns_request,
- (caddr_t) &req, (xdrproc_t) _xdr_nis_result,
- (caddr_t) res, RPCTIMEOUT);
+ (char *) &req, (xdrproc_t) _xdr_nis_result,
+ (char *) res, RPCTIMEOUT);
if (result != RPC_SUCCESS)
status = NIS_RPCERROR;
if (server == NULL)
res2 = __do_niscall (dir, NIS_MKDIR, (xdrproc_t) _xdr_nis_name,
- (caddr_t) &dir, (xdrproc_t) _xdr_nis_error,
- (caddr_t) &res, 0, NULL);
+ (char *) &dir, (xdrproc_t) _xdr_nis_error,
+ (char *) &res, 0, NULL);
else
res2 = __do_niscall2 (server, 1, NIS_MKDIR,
(xdrproc_t) _xdr_nis_name,
- (caddr_t) &dir, (xdrproc_t) _xdr_nis_error,
- (caddr_t) &res, 0, NULL);
+ (char *) &dir, (xdrproc_t) _xdr_nis_error,
+ (char *) &res, 0, NULL);
if (res2 != NIS_SUCCESS)
return res2;
req.ns_object.ns_object_len = 1;
status = __do_niscall (name, NIS_MODIFY, (xdrproc_t) _xdr_ns_request,
- (caddr_t) & req, (xdrproc_t) _xdr_nis_result,
- (caddr_t) res, MASTER_ONLY,
+ (char *) & req, (xdrproc_t) _xdr_nis_result,
+ (char *) res, MASTER_ONLY,
NULL);
if (status != NIS_SUCCESS)
NIS_RES_STATUS (res) = status;
for (i = 1; i < obj->DI_data.do_servers.do_servers_len; ++i)
__do_niscall2 (&obj->DI_data.do_servers.do_servers_val[i], 1,
NIS_PING, (xdrproc_t) _xdr_ping_args,
- (caddr_t) &args, (xdrproc_t) xdr_void,
- (caddr_t) NULL, 0, NULL);
+ (char *) &args, (xdrproc_t) xdr_void,
+ (char *) NULL, 0, NULL);
nis_freeresult (res);
}
libnsl_hidden_nolink_def (nis_ping, GLIBC_2_1)
}
if ((status = __do_niscall (name, NIS_REMOVE, (xdrproc_t) _xdr_ns_request,
- (caddr_t) &req, (xdrproc_t) _xdr_nis_result,
- (caddr_t) res, MASTER_ONLY,
+ (char *) &req, (xdrproc_t) _xdr_nis_result,
+ (char *) res, MASTER_ONLY,
NULL)) != NIS_SUCCESS)
NIS_RES_STATUS (res) = status;
res2 = __do_niscall2 (server, 1, NIS_RMDIR,
(xdrproc_t) _xdr_nis_name,
- (caddr_t) &dir, (xdrproc_t) _xdr_nis_error,
- (caddr_t) &res, 0, NULL);
+ (char *) &dir, (xdrproc_t) _xdr_nis_error,
+ (char *) &res, 0, NULL);
if (res2 != NIS_SUCCESS)
return res2;
return NIS_BADOBJECT;
if (__do_niscall2 (serv, 1, NIS_SERVSTATE, (xdrproc_t) _xdr_nis_taglist,
- (caddr_t) &taglist, (xdrproc_t) _xdr_nis_taglist,
- (caddr_t) &tagres, 0, NULL) != NIS_SUCCESS)
+ (char *) &taglist, (xdrproc_t) _xdr_nis_taglist,
+ (char *) &tagres, 0, NULL) != NIS_SUCCESS)
return NIS_RPCERROR;
*result = tagres.tags.tags_val;
return NIS_BADOBJECT;
if (__do_niscall2 (serv, 1, NIS_STATUS, (xdrproc_t) _xdr_nis_taglist,
- (caddr_t) &taglist, (xdrproc_t) _xdr_nis_taglist,
- (caddr_t) &tagres, 0, NULL) != NIS_SUCCESS)
+ (char *) &taglist, (xdrproc_t) _xdr_nis_taglist,
+ (char *) &tagres, 0, NULL) != NIS_SUCCESS)
return NIS_RPCERROR;
*result = tagres.tags.tags_val;
req.ns_object.ns_object_val = NULL;
result = clnt_call (bptr->clnt, NIS_LOOKUP, (xdrproc_t) _xdr_ns_request,
- (caddr_t) &req, (xdrproc_t) _xdr_nis_result,
- (caddr_t) &res, RPCTIMEOUT);
+ (char *) &req, (xdrproc_t) _xdr_nis_result,
+ (char *) &res, RPCTIMEOUT);
const char *cptr;
if (result == RPC_SUCCESS && NIS_RES_STATUS (&res) == NIS_SUCCESS
again:
clnt_status = clnt_call (bptr.clnt, NIS_IBLIST,
- (xdrproc_t) _xdr_ib_request, (caddr_t) ibreq,
+ (xdrproc_t) _xdr_ib_request, (char *) ibreq,
(xdrproc_t) _xdr_nis_result,
- (caddr_t) res, RPCTIMEOUT);
+ (char *) res, RPCTIMEOUT);
if (__glibc_unlikely (clnt_status != RPC_SUCCESS))
NIS_RES_STATUS (res) = NIS_RPCERROR;
nis_error status = __do_niscall (ibreq->ibr_name, NIS_IBADD,
(xdrproc_t) _xdr_ib_request,
- (caddr_t) ibreq,
+ (char *) ibreq,
(xdrproc_t) _xdr_nis_result,
- (caddr_t) res, 0, NULL);
+ (char *) res, 0, NULL);
if (__glibc_unlikely (status != NIS_SUCCESS))
NIS_RES_STATUS (res) = status;
status = __do_niscall (ibreq->ibr_name, NIS_IBMODIFY,
(xdrproc_t) _xdr_ib_request,
- (caddr_t) ibreq, (xdrproc_t) _xdr_nis_result,
- (caddr_t) res, 0, NULL);
+ (char *) ibreq, (xdrproc_t) _xdr_nis_result,
+ (char *) res, 0, NULL);
if (__glibc_unlikely (status != NIS_SUCCESS))
NIS_RES_STATUS (res) = status;
if ((status = __do_niscall (ibreq->ibr_name, NIS_IBREMOVE,
(xdrproc_t) _xdr_ib_request,
- (caddr_t) ibreq, (xdrproc_t) _xdr_nis_result,
- (caddr_t) res, 0, NULL)) != NIS_SUCCESS)
+ (char *) ibreq, (xdrproc_t) _xdr_nis_result,
+ (char *) res, 0, NULL)) != NIS_SUCCESS)
NIS_RES_STATUS (res) = status;
nis_free_request (ibreq);
status = __do_niscall (ibreq->ibr_name, NIS_IBFIRST,
(xdrproc_t) _xdr_ib_request,
- (caddr_t) ibreq, (xdrproc_t) _xdr_nis_result,
- (caddr_t) res, 0, NULL);
+ (char *) ibreq, (xdrproc_t) _xdr_nis_result,
+ (char *) res, 0, NULL);
if (__glibc_unlikely (status != NIS_SUCCESS))
NIS_RES_STATUS (res) = status;
status = __do_niscall (ibreq->ibr_name, NIS_IBNEXT,
(xdrproc_t) _xdr_ib_request,
- (caddr_t) ibreq, (xdrproc_t) _xdr_nis_result,
- (caddr_t) res, 0, NULL);
+ (char *) ibreq, (xdrproc_t) _xdr_nis_result,
+ (char *) res, 0, NULL);
if (__glibc_unlikely (status != NIS_SUCCESS))
NIS_RES_STATUS (res) = status;
status = __do_niscall2 (dir->do_servers.do_servers_val,
dir->do_servers.do_servers_len,
NIS_FINDDIRECTORY, (xdrproc_t) _xdr_fd_args,
- (caddr_t) &fd_args, (xdrproc_t) _xdr_fd_result,
- (caddr_t) fd_res, NO_AUTHINFO|USE_DGRAM, NULL);
+ (char *) &fd_args, (xdrproc_t) _xdr_fd_result,
+ (char *) fd_res, NO_AUTHINFO|USE_DGRAM, NULL);
if (status != NIS_SUCCESS)
fd_res->status = status;
status = __do_niscall3 (&bptr, NIS_IBFIRST,
(xdrproc_t) _xdr_ib_request,
- (caddr_t) ibreq,
+ (char *) ibreq,
(xdrproc_t) _xdr_nis_result,
- (caddr_t) &result,
+ (char *) &result,
0, NULL);
}
else
status = __do_niscall3 (&bptr, NIS_IBNEXT,
(xdrproc_t) _xdr_ib_request,
- (caddr_t) ibreq,
+ (char *) ibreq,
(xdrproc_t) _xdr_nis_result,
- (caddr_t) &result,
+ (char *) &result,
0, NULL);
ibreq->ibr_cookie.n_bytes = NULL;
status = __do_niscall3 (&bptr, NIS_IBFIRST,
(xdrproc_t) _xdr_ib_request,
- (caddr_t) ibreq,
+ (char *) ibreq,
(xdrproc_t) _xdr_nis_result,
- (caddr_t) &result,
+ (char *) &result,
0, NULL);
}
else
status = __do_niscall3 (&bptr, NIS_IBNEXT,
(xdrproc_t) _xdr_ib_request,
- (caddr_t) ibreq,
+ (char *) ibreq,
(xdrproc_t) _xdr_nis_result,
- (caddr_t) &result,
+ (char *) &result,
0, NULL);
ibreq->ibr_cookie.n_bytes = NULL;
#define CBPROC_ERROR 3
extern void * cbproc_error_1 (nis_error *, CLIENT *) __THROW;
extern void * cbproc_error_1_svc (nis_error *, struct svc_req *) __THROW;
-extern int cb_prog_1_freeresult (SVCXPRT *, xdrproc_t, caddr_t) __THROW;
+extern int cb_prog_1_freeresult (SVCXPRT *, xdrproc_t, char *) __THROW;
/* the xdr functions */
#define YPPROC_MAPLIST 11
extern ypresp_maplist *ypproc_maplist_2 (domainname *, CLIENT *);
extern ypresp_maplist *ypproc_maplist_2_svc (domainname *, struct svc_req *);
-extern int ypprog_2_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
+extern int ypprog_2_freeresult (SVCXPRT *, xdrproc_t, char *);
#define YPPUSH_XFRRESPPROG (0x40000000)
#define YPPUSHPROC_XFRRESP 1
extern void *yppushproc_xfrresp_1 (yppushresp_xfr *, CLIENT *);
extern void *yppushproc_xfrresp_1_svc (yppushresp_xfr *, struct svc_req *);
-extern int yppush_xfrrespprog_1_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
+extern int yppush_xfrrespprog_1_freeresult (SVCXPRT *, xdrproc_t, char *);
#define YPBINDPROG 100007
#define YPBINDPROC_SETDOM 2
extern void *ypbindproc_setdom_2 (ypbind_setdom *, CLIENT *);
extern void *ypbindproc_setdom_2_svc (ypbind_setdom *, struct svc_req *);
-extern int ypbindprog_2_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
+extern int ypbindprog_2_freeresult (SVCXPRT *, xdrproc_t, char *);
extern bool_t xdr_ypstat (XDR *, ypstat*);
}
if (clnt_call (client, YPBINDPROC_DOMAIN,
- (xdrproc_t) xdr_domainname, (caddr_t) &domain,
+ (xdrproc_t) xdr_domainname, (char *) &domain,
(xdrproc_t) xdr_ypbind_resp,
- (caddr_t) &ypbr, RPCTIMEOUT) != RPC_SUCCESS)
+ (char *) &ypbr, RPCTIMEOUT) != RPC_SUCCESS)
{
clnt_destroy (client);
return YPERR_YPBIND;
static int
__ypclnt_call (const char *domain, u_long prog, xdrproc_t xargs,
- caddr_t req, xdrproc_t xres, caddr_t resp, dom_binding **ydb,
+ char *req, xdrproc_t xres, char *resp, dom_binding **ydb,
int print_error)
{
enum clnt_stat result;
static int
do_ypcall (const char *domain, u_long prog, xdrproc_t xargs,
- caddr_t req, xdrproc_t xres, caddr_t resp)
+ char *req, xdrproc_t xres, char *resp)
{
dom_binding *ydb;
int status;
/* Like do_ypcall, but translate the status value if necessary. */
static int
do_ypcall_tr (const char *domain, u_long prog, xdrproc_t xargs,
- caddr_t req, xdrproc_t xres, caddr_t resp)
+ char *req, xdrproc_t xres, char *resp)
{
int status = do_ypcall (domain, prog, xargs, req, xres, resp);
if (status == YPERR_SUCCESS)
memset (&resp, '\0', sizeof (resp));
result = do_ypcall_tr (indomain, YPPROC_MATCH, (xdrproc_t) xdr_ypreq_key,
- (caddr_t) &req, (xdrproc_t) xdr_ypresp_val,
- (caddr_t) &resp);
+ (char *) &req, (xdrproc_t) xdr_ypresp_val,
+ (char *) &resp);
if (result != YPERR_SUCCESS)
return result;
memset (&resp, '\0', sizeof (resp));
result = do_ypcall (indomain, YPPROC_FIRST, (xdrproc_t) xdr_ypreq_nokey,
- (caddr_t) &req, (xdrproc_t) xdr_ypresp_key_val,
- (caddr_t) &resp);
+ (char *) &req, (xdrproc_t) xdr_ypresp_key_val,
+ (char *) &resp);
if (result != RPC_SUCCESS)
return YPERR_RPC;
memset (&resp, '\0', sizeof (resp));
result = do_ypcall_tr (indomain, YPPROC_NEXT, (xdrproc_t) xdr_ypreq_key,
- (caddr_t) &req, (xdrproc_t) xdr_ypresp_key_val,
- (caddr_t) &resp);
+ (char *) &req, (xdrproc_t) xdr_ypresp_key_val,
+ (char *) &resp);
if (result != YPERR_SUCCESS)
return result;
memset (&resp, '\0', sizeof (ypresp_master));
result = do_ypcall_tr (indomain, YPPROC_MASTER, (xdrproc_t) xdr_ypreq_nokey,
- (caddr_t) &req, (xdrproc_t) xdr_ypresp_master,
- (caddr_t) &resp);
+ (char *) &req, (xdrproc_t) xdr_ypresp_master,
+ (char *) &resp);
if (result != YPERR_SUCCESS)
return result;
memset (&resp, '\0', sizeof (resp));
result = do_ypcall_tr (indomain, YPPROC_ORDER, (xdrproc_t) xdr_ypreq_nokey,
- (caddr_t) &req, (xdrproc_t) xdr_ypresp_order,
- (caddr_t) &resp);
+ (char *) &req, (xdrproc_t) xdr_ypresp_order,
+ (char *) &resp);
if (result != YPERR_SUCCESS)
return result;
data.data = (void *) incallback->data;
result = clnt_call (clnt, YPPROC_ALL, (xdrproc_t) xdr_ypreq_nokey,
- (caddr_t) &req, (xdrproc_t) __xdr_ypresp_all,
- (caddr_t) &data, RPCTIMEOUT);
+ (char *) &req, (xdrproc_t) __xdr_ypresp_all,
+ (char *) &data, RPCTIMEOUT);
if (__glibc_unlikely (result != RPC_SUCCESS))
{
memset (&resp, '\0', sizeof (resp));
result = do_ypcall_tr (indomain, YPPROC_MAPLIST, (xdrproc_t) xdr_domainname,
- (caddr_t) &indomain, (xdrproc_t) xdr_ypresp_maplist,
- (caddr_t) &resp);
+ (char *) &indomain, (xdrproc_t) xdr_ypresp_maplist,
+ (char *) &resp);
if (__glibc_likely (result == YPERR_SUCCESS))
{
clnt->cl_auth = authunix_create_default ();
again:
- r = clnt_call (clnt, ypop, xdr_argument, (caddr_t) &args,
- (xdrproc_t) xdr_u_int, (caddr_t) &res, RPCTIMEOUT);
+ r = clnt_call (clnt, ypop, xdr_argument, (char *) &args,
+ (xdrproc_t) xdr_u_int, (char *) &res, RPCTIMEOUT);
if (r == RPC_AUTHERROR)
{
__STD_TYPE __USECONDS_T_TYPE __useconds_t; /* Count of microseconds. */
__STD_TYPE __SUSECONDS_T_TYPE __suseconds_t; /* Signed count of microseconds. */
-__STD_TYPE __DADDR_T_TYPE __daddr_t; /* The type of a disk address. */
__STD_TYPE __KEY_T_TYPE __key_t; /* Type of an IPC key. */
/* Clock ID used in clock and timer functions. */
/* These few don't really vary by system, they always correspond
to one of the other defined types. */
typedef __off64_t __loff_t; /* Type of file sizes and offsets (LFS). */
-typedef char *__caddr_t;
+typedef char *__caddr_t; /* Type of a memory address (BSD). */
+__STD_TYPE __S32_TYPE __daddr_t; /* Type of a disk address (BSD). */
/* Duplicates info from stdint.h but this is used in unistd.h. */
__STD_TYPE __SWORD_TYPE __intptr_t;
"""Verifies that installed headers do not use any obsolete constructs:
* legacy BSD typedefs superseded by <stdint.h>:
- ushort uint ulong u_char u_short u_int u_long u_intNN_t quad_t u_quad_t
+ ushort uint ulong
+ u_char u_short u_int u_long
+ u_intNN_t quad_t u_quad_t
+ caddr_t daddr_t loff_t register_t
(sys/types.h is allowed to _define_ these types, but not to use them
to define anything else).
"""
OBSOLETE_TYPE_RE_ = re.compile(r"""\A
(__)?
( quad_t
+ | [cd]addr_t
+ | loff_t
| register_t
| u(?: short | int | long
| _(?: char | short | int(?:[0-9]+_t)? | long | quad_t )))
auth->ah_cred.oa_flavor = AUTH_DES;
auth->ah_verf.oa_flavor = AUTH_DES;
auth->ah_ops = (struct auth_ops *) &authdes_ops;
- auth->ah_private = (caddr_t) ad;
+ auth->ah_private = (char *) ad;
if (!authdes_refresh (auth))
goto failed;
return NULL;
}
auth->ah_ops = (struct auth_ops *) &auth_unix_ops;
- auth->ah_private = (caddr_t) au;
+ auth->ah_private = (char *) au;
auth->ah_verf = au->au_shcred = _null_auth;
au->au_shfaults = 0;
if (auth->ah_verf.oa_base != NULL)
mem_free (auth->ah_verf.oa_base, auth->ah_verf.oa_length);
- mem_free ((caddr_t) auth, sizeof (*auth));
+ mem_free ((char *) auth, sizeof (*auth));
}
/*
{
case ADN_FULLNAME:
ATTEMPT (xdr_string (xdrs, &cred->adc_fullname.name, MAXNETNAMELEN));
- ATTEMPT (xdr_opaque (xdrs, (caddr_t) & cred->adc_fullname.key,
+ ATTEMPT (xdr_opaque (xdrs, (char *) & cred->adc_fullname.key,
sizeof (des_block)));
- ATTEMPT (xdr_opaque (xdrs, (caddr_t) & cred->adc_fullname.window,
+ ATTEMPT (xdr_opaque (xdrs, (char *) & cred->adc_fullname.window,
sizeof (cred->adc_fullname.window)));
return (TRUE);
case ADN_NICKNAME:
- ATTEMPT (xdr_opaque (xdrs, (caddr_t) & cred->adc_nickname,
+ ATTEMPT (xdr_opaque (xdrs, (char *) & cred->adc_nickname,
sizeof (cred->adc_nickname)));
return TRUE;
default:
/*
* Unrolled xdr
*/
- ATTEMPT (xdr_opaque (xdrs, (caddr_t) & verf->adv_xtimestamp,
+ ATTEMPT (xdr_opaque (xdrs, (char *) & verf->adv_xtimestamp,
sizeof (des_block)));
- ATTEMPT (xdr_opaque (xdrs, (caddr_t) & verf->adv_int_u,
+ ATTEMPT (xdr_opaque (xdrs, (char *) & verf->adv_int_u,
sizeof (verf->adv_int_u)));
return TRUE;
}
&& (sizeof (gid_t) == sizeof (short int)
? xdr_u_short (xdrs, (u_short *) & (p->aup_gid))
: xdr_u_int (xdrs, (u_int *) & (p->aup_gid)))
- && xdr_array (xdrs, (caddr_t *) & (p->aup_gids),
+ && xdr_array (xdrs, (char **) & (p->aup_gids),
& (p->aup_len), NGRPS, sizeof (gid_t),
(sizeof (gid_t) == sizeof (short int)
? (xdrproc_t) xdr_u_short
};
#define clntraw_private RPC_THREAD_VARIABLE(clntraw_private_s)
-static enum clnt_stat clntraw_call (CLIENT *, u_long, xdrproc_t, caddr_t,
- xdrproc_t, caddr_t, struct timeval);
+static enum clnt_stat clntraw_call (CLIENT *, u_long, xdrproc_t, char *,
+ xdrproc_t, char *, struct timeval);
static void clntraw_abort (void);
static void clntraw_geterr (CLIENT *, struct rpc_err *);
-static bool_t clntraw_freeres (CLIENT *, xdrproc_t, caddr_t);
+static bool_t clntraw_freeres (CLIENT *, xdrproc_t, char *);
static bool_t clntraw_control (CLIENT *, int, char *);
static void clntraw_destroy (CLIENT *);
libc_hidden_nolink_sunrpc (clntraw_create, GLIBC_2_0)
static enum clnt_stat
-clntraw_call (CLIENT *h, u_long proc, xdrproc_t xargs, caddr_t argsp,
- xdrproc_t xresults, caddr_t resultsp, struct timeval timeout)
+clntraw_call (CLIENT *h, u_long proc, xdrproc_t xargs, char *argsp,
+ xdrproc_t xresults, char *resultsp, struct timeval timeout)
{
struct clntraw_private_s *clp = clntraw_private;
XDR *xdrs = &clp->xdr_stream;
static bool_t
-clntraw_freeres (CLIENT *cl, xdrproc_t xdr_res, caddr_t res_ptr)
+clntraw_freeres (CLIENT *cl, xdrproc_t xdr_res, char *res_ptr)
{
struct clntraw_private_s *clp = clntraw_private;
XDR *xdrs = &clp->xdr_stream;
static int readtcp (char *, char *, int);
static int writetcp (char *, char *, int);
-static enum clnt_stat clnttcp_call (CLIENT *, u_long, xdrproc_t, caddr_t,
- xdrproc_t, caddr_t, struct timeval);
+static enum clnt_stat clnttcp_call (CLIENT *, u_long, xdrproc_t, char *,
+ xdrproc_t, char *, struct timeval);
static void clnttcp_abort (void);
static void clnttcp_geterr (CLIENT *, struct rpc_err *);
-static bool_t clnttcp_freeres (CLIENT *, xdrproc_t, caddr_t);
+static bool_t clnttcp_freeres (CLIENT *, xdrproc_t, char *);
static bool_t clnttcp_control (CLIENT *, int, char *);
static void clnttcp_destroy (CLIENT *);
u_short port;
if ((port = pmap_getport (raddr, prog, vers, IPPROTO_TCP)) == 0)
{
- mem_free ((caddr_t) ct, sizeof (struct ct_data));
- mem_free ((caddr_t) h, sizeof (CLIENT));
+ mem_free ((char *) ct, sizeof (struct ct_data));
+ mem_free ((char *) h, sizeof (CLIENT));
return ((CLIENT *) NULL);
}
raddr->sin_port = htons (port);
* and authnone for authentication.
*/
xdrrec_create (&(ct->ct_xdrs), sendsz, recvsz,
- (caddr_t) ct, readtcp, writetcp);
+ (char *) ct, readtcp, writetcp);
h->cl_ops = (struct clnt_ops *) &tcp_ops;
- h->cl_private = (caddr_t) ct;
+ h->cl_private = (char *) ct;
h->cl_auth = authnone_create ();
return h;
/*
* Something goofed, free stuff and barf
*/
- mem_free ((caddr_t) ct, sizeof (struct ct_data));
- mem_free ((caddr_t) h, sizeof (CLIENT));
+ mem_free ((char *) ct, sizeof (struct ct_data));
+ mem_free ((char *) h, sizeof (CLIENT));
return ((CLIENT *) NULL);
}
#ifdef EXPORT_RPC_SYMBOLS
#endif
static enum clnt_stat
-clnttcp_call (CLIENT *h, u_long proc, xdrproc_t xdr_args, caddr_t args_ptr,
- xdrproc_t xdr_results, caddr_t results_ptr,
+clnttcp_call (CLIENT *h, u_long proc, xdrproc_t xdr_args, char *args_ptr,
+ xdrproc_t xdr_results, char *results_ptr,
struct timeval timeout)
{
struct ct_data *ct = (struct ct_data *) h->cl_private;
}
static bool_t
-clnttcp_freeres (CLIENT *cl, xdrproc_t xdr_res, caddr_t res_ptr)
+clnttcp_freeres (CLIENT *cl, xdrproc_t xdr_res, char *res_ptr)
{
struct ct_data *ct = (struct ct_data *) cl->cl_private;
XDR *xdrs = &(ct->ct_xdrs);
(void) __close (ct->ct_sock);
}
XDR_DESTROY (&(ct->ct_xdrs));
- mem_free ((caddr_t) ct, sizeof (struct ct_data));
- mem_free ((caddr_t) h, sizeof (CLIENT));
+ mem_free ((char *) ct, sizeof (struct ct_data));
+ mem_free ((char *) h, sizeof (CLIENT));
}
/*
/*
* UDP bases client side rpc operations
*/
-static enum clnt_stat clntudp_call (CLIENT *, u_long, xdrproc_t, caddr_t,
- xdrproc_t, caddr_t, struct timeval);
+static enum clnt_stat clntudp_call (CLIENT *, u_long, xdrproc_t, char *,
+ xdrproc_t, char *, struct timeval);
static void clntudp_abort (void);
static void clntudp_geterr (CLIENT *, struct rpc_err *);
-static bool_t clntudp_freeres (CLIENT *, xdrproc_t, caddr_t);
+static bool_t clntudp_freeres (CLIENT *, xdrproc_t, char *);
static bool_t clntudp_control (CLIENT *, int, char *);
static void clntudp_destroy (CLIENT *);
raddr->sin_port = htons (port);
}
cl->cl_ops = (struct clnt_ops *) &udp_ops;
- cl->cl_private = (caddr_t) cu;
+ cl->cl_private = (char *) cu;
cu->cu_raddr = *raddr;
cu->cu_rlen = sizeof (cu->cu_raddr);
cu->cu_wait = wait;
return cl;
fooy:
if (cu)
- mem_free ((caddr_t) cu, sizeof (*cu) + sendsz + recvsz);
+ mem_free ((char *) cu, sizeof (*cu) + sendsz + recvsz);
if (cl)
- mem_free ((caddr_t) cl, sizeof (CLIENT));
+ mem_free ((char *) cl, sizeof (CLIENT));
return (CLIENT *) NULL;
}
#ifdef EXPORT_RPC_SYMBOLS
/* xdr routine for args */
xdrproc_t xargs,
/* pointer to args */
- caddr_t argsp,
+ char *argsp,
/* xdr routine for results */
xdrproc_t xresults,
/* pointer to results */
- caddr_t resultsp,
+ char *resultsp,
/* seconds to wait before giving up */
struct timeval utimeout)
{
static bool_t
-clntudp_freeres (CLIENT *cl, xdrproc_t xdr_res, caddr_t res_ptr)
+clntudp_freeres (CLIENT *cl, xdrproc_t xdr_res, char *res_ptr)
{
struct cu_data *cu = (struct cu_data *) cl->cl_private;
XDR *xdrs = &(cu->cu_outxdrs);
(void) __close (cu->cu_sock);
}
XDR_DESTROY (&(cu->cu_outxdrs));
- mem_free ((caddr_t) cu, (sizeof (*cu) + cu->cu_sendsz + cu->cu_recvsz));
- mem_free ((caddr_t) cl, sizeof (CLIENT));
+ mem_free ((char *) cu, (sizeof (*cu) + cu->cu_sendsz + cu->cu_recvsz));
+ mem_free ((char *) cl, sizeof (CLIENT));
}
static int readunix (char *, char *, int);
static int writeunix (char *, char *, int);
-static enum clnt_stat clntunix_call (CLIENT *, u_long, xdrproc_t, caddr_t,
- xdrproc_t, caddr_t, struct timeval);
+static enum clnt_stat clntunix_call (CLIENT *, u_long, xdrproc_t, char *,
+ xdrproc_t, char *, struct timeval);
static void clntunix_abort (void);
static void clntunix_geterr (CLIENT *, struct rpc_err *);
-static bool_t clntunix_freeres (CLIENT *, xdrproc_t, caddr_t);
+static bool_t clntunix_freeres (CLIENT *, xdrproc_t, char *);
static bool_t clntunix_control (CLIENT *, int, char *);
static void clntunix_destroy (CLIENT *);
* and authnone for authentication.
*/
xdrrec_create (&(ct->ct_xdrs), sendsz, recvsz,
- (caddr_t) ct, readunix, writeunix);
+ (char *) ct, readunix, writeunix);
h->cl_ops = (struct clnt_ops *) &unix_ops;
- h->cl_private = (caddr_t) ct;
+ h->cl_private = (char *) ct;
h->cl_auth = authnone_create ();
return h;
/*
* Something goofed, free stuff and barf
*/
- mem_free ((caddr_t) ct, sizeof (struct ct_data));
- mem_free ((caddr_t) h, sizeof (CLIENT));
+ mem_free ((char *) ct, sizeof (struct ct_data));
+ mem_free ((char *) h, sizeof (CLIENT));
return (CLIENT *) NULL;
}
libc_hidden_nolink_sunrpc (clntunix_create, GLIBC_2_1)
static enum clnt_stat
-clntunix_call (CLIENT *h, u_long proc, xdrproc_t xdr_args, caddr_t args_ptr,
- xdrproc_t xdr_results, caddr_t results_ptr,
+clntunix_call (CLIENT *h, u_long proc, xdrproc_t xdr_args, char *args_ptr,
+ xdrproc_t xdr_results, char *results_ptr,
struct timeval timeout)
{
struct ct_data *ct = (struct ct_data *) h->cl_private;
}
static bool_t
-clntunix_freeres (CLIENT *cl, xdrproc_t xdr_res, caddr_t res_ptr)
+clntunix_freeres (CLIENT *cl, xdrproc_t xdr_res, char *res_ptr)
{
struct ct_data *ct = (struct ct_data *) cl->cl_private;
XDR *xdrs = &(ct->ct_xdrs);
(void) __close (ct->ct_sock);
}
XDR_DESTROY (&(ct->ct_xdrs));
- mem_free ((caddr_t) ct, sizeof (struct ct_data));
- mem_free ((caddr_t) h, sizeof (CLIENT));
+ mem_free ((char *) ct, sizeof (struct ct_data));
+ mem_free ((char *) h, sizeof (CLIENT));
}
static int
msg.msg_name = NULL;
msg.msg_namelen = 0;
#ifdef SCM_CREDENTIALS
- msg.msg_control = (caddr_t) &cm;
+ msg.msg_control = (char *) &cm;
msg.msg_controllen = CMSG_SPACE(sizeof (struct ucred));
#endif
msg.msg_flags = 0;
return -1;
stat = clnt_call (client, KEY_GEN, (xdrproc_t) xdr_void, NULL,
- (xdrproc_t) xdr_des_block, (caddr_t) key,
+ (xdrproc_t) xdr_des_block, (char *) key,
tottimeout);
clnt_destroy (client);
__close (socket);
if (client != (CLIENT *) NULL)
{
if (CLNT_CALL (client, PMAPPROC_DUMP, (xdrproc_t)xdr_void, NULL,
- (xdrproc_t)xdr_pmaplist, (caddr_t)&head,
+ (xdrproc_t)xdr_pmaplist, (char *)&head,
minutetimeout) != RPC_SUCCESS)
{
clnt_perror (client, _("pmap_getmaps.c: rpc problem"));
parms.pm_prot = protocol;
parms.pm_port = 0; /* not needed or used */
if (CLNT_CALL (client, PMAPPROC_GETPORT, (xdrproc_t)xdr_pmap,
- (caddr_t)&parms, (xdrproc_t)xdr_u_short,
- (caddr_t)&port, tottimeout) != RPC_SUCCESS)
+ (char *)&parms, (xdrproc_t)xdr_u_short,
+ (char *)&port, tottimeout) != RPC_SUCCESS)
{
ce->cf_stat = RPC_PMAPFAILURE;
clnt_geterr (client, &ce->cf_error);
parms.pm_prot = protocol;
parms.pm_port = port;
if (CLNT_CALL (client, PMAPPROC_SET, (xdrproc_t)xdr_pmap,
- (caddr_t)&parms, (xdrproc_t)xdr_bool, (caddr_t)&rslt,
+ (char *)&parms, (xdrproc_t)xdr_bool, (char *)&rslt,
tottimeout) != RPC_SUCCESS)
{
clnt_perror (client, _("Cannot register service"));
parms.pm_vers = version;
parms.pm_port = parms.pm_prot = 0;
CLNT_CALL (client, PMAPPROC_UNSET, (xdrproc_t)xdr_pmap,
- (caddr_t)&parms, (xdrproc_t)xdr_bool, (caddr_t)&rslt,
+ (char *)&parms, (xdrproc_t)xdr_bool, (char *)&rslt,
tottimeout);
CLNT_DESTROY (client);
/* (void)close(socket); CLNT_DESTROY already closed it */
*/
if (freeing)
next = (*rp)->pml_next;
- if (!xdr_reference (xdrs, (caddr_t *) rp,
+ if (!xdr_reference (xdrs, (char **) rp,
(u_int) sizeof (struct pmaplist),
(xdrproc_t) xdr_pmap))
return FALSE;
*/
enum clnt_stat
pmap_rmtcall (struct sockaddr_in *addr, u_long prog, u_long vers, u_long proc,
- xdrproc_t xdrargs, caddr_t argsp, xdrproc_t xdrres, caddr_t resp,
+ xdrproc_t xdrargs, char *argsp, xdrproc_t xdrres, char *resp,
struct timeval tout, u_long *port_ptr)
{
int socket = -1;
r.xdr_results = xdrres;
stat = CLNT_CALL (client, PMAPPROC_CALLIT,
(xdrproc_t)xdr_rmtcall_args,
- (caddr_t)&a, (xdrproc_t)xdr_rmtcallres,
- (caddr_t)&r, tout);
+ (char *)&a, (xdrproc_t)xdr_rmtcallres,
+ (char *)&r, tout);
CLNT_DESTROY (client);
}
else
bool_t
xdr_rmtcallres (XDR *xdrs, struct rmtcallres *crp)
{
- caddr_t port_ptr;
+ char *port_ptr;
- port_ptr = (caddr_t) crp->port_ptr;
+ port_ptr = (char *) crp->port_ptr;
if (xdr_reference (xdrs, &port_ptr, sizeof (u_long),
(xdrproc_t) xdr_u_long)
&& xdr_u_long (xdrs, &crp->resultslen))
/* xdr routine for args */
xdrproc_t xargs,
/* pointer to args */
- caddr_t argsp,
+ char *argsp,
/* xdr routine for results */
xdrproc_t xresults,
/* pointer to results */
- caddr_t resultsp,
+ char *resultsp,
/* call with each result obtained */
resultproc_t eachresult)
{
}
recv_again:
msg.acpted_rply.ar_verf = _null_auth;
- msg.acpted_rply.ar_results.where = (caddr_t) & r;
+ msg.acpted_rply.ar_results.where = (char *) & r;
msg.acpted_rply.ar_results.proc = (xdrproc_t) xdr_rmtcallres;
milliseconds = t.tv_sec * 1000 + t.tv_usec / 1000;
switch (__poll(&fd, 1, milliseconds))
const char *addargtype, int server_p, int mode);
void pdeclaration(const char *name, declaration *dec, int tab,
const char *separator);
-void print_xdr_func_def (char* name, int pointerp, int i);
+void print_xdr_func_def (char *name, int pointerp, int i);
/****** rpc_main.c ******/
/* nil */
*/
struct opaque_auth {
enum_t oa_flavor; /* flavor of auth */
- caddr_t oa_base; /* address of more auth stuff */
+ char * oa_base; /* address of more auth stuff */
u_int oa_length; /* not to exceed MAX_AUTH_BYTES */
};
int (*ah_refresh) (AUTH *); /* refresh credentials */
void (*ah_destroy) (AUTH *); /* destroy this structure */
} *ah_ops;
- caddr_t ah_private;
+ char *ah_private;
};
struct CLIENT {
AUTH *cl_auth; /* authenticator */
struct clnt_ops {
- enum clnt_stat (*cl_call) (CLIENT *, u_long, xdrproc_t, caddr_t, xdrproc_t,
- caddr_t, struct timeval);
+ enum clnt_stat (*cl_call) (CLIENT *, u_long, xdrproc_t, char *, xdrproc_t,
+ char *, struct timeval);
/* call remote procedure */
void (*cl_abort) (void); /* abort a call */
void (*cl_geterr) (CLIENT *, struct rpc_err *);
/* get specific error code */
- bool_t (*cl_freeres) (CLIENT *, xdrproc_t, caddr_t);
+ bool_t (*cl_freeres) (CLIENT *, xdrproc_t, char *);
/* frees results */
void (*cl_destroy) (CLIENT *); /* destroy this structure */
bool_t (*cl_control) (CLIENT *, int, char *);
/* the ioctl() of rpc */
} *cl_ops;
- caddr_t cl_private; /* private stuff */
+ char *cl_private; /* private stuff */
};
* CLIENT *rh;
* u_long proc;
* xdrproc_t xargs;
- * caddr_t argsp;
+ * char *argsp;
* xdrproc_t xres;
- * caddr_t resp;
+ * char *resp;
* struct timeval timeout;
*/
#define CLNT_CALL(rh, proc, xargs, argsp, xres, resp, secs) \
* CLNT_FREERES(rh, xres, resp);
* CLIENT *rh;
* xdrproc_t xres;
- * caddr_t resp;
+ * char *resp;
*/
#define CLNT_FREERES(rh,xres,resp) ((*(rh)->cl_ops->cl_freeres)(rh,xres,resp))
#define clnt_freeres(rh,xres,resp) ((*(rh)->cl_ops->cl_freeres)(rh,xres,resp))
/*
* get the port number on the host for the rpc program,version and proto
*/
-extern int getrpcport (const char * __host, u_long __prognum,
+extern int getrpcport (const char *__host, u_long __prognum,
u_long __versnum, u_int __proto) __THROW;
/*
__BEGIN_DECLS
-typedef bool_t (*resultproc_t) (caddr_t __resp, struct sockaddr_in *__raddr);
+typedef bool_t (*resultproc_t) (char *__resp, struct sockaddr_in *__raddr);
/*
* Usage:
* the procedure eachresult is called. Its form is:
* done = eachresult(resp, raddr)
* bool_t done;
- * caddr_t resp;
+ * char *resp;
* struct sockaddr_in raddr;
* where resp points to the results of the call and raddr is the
* address if the responder to the broadcast.
const u_long __vers,
const u_long __proc,
xdrproc_t __xdrargs,
- caddr_t __argsp, xdrproc_t __xdrres,
- caddr_t __resp, struct timeval __tout,
+ char *__argsp, xdrproc_t __xdrres,
+ char *__resp, struct timeval __tout,
u_long *__port_ptr) __THROW;
extern enum clnt_stat clnt_broadcast (const u_long __prog,
const u_long __vers,
const u_long __proc, xdrproc_t __xargs,
- caddr_t __argsp, xdrproc_t __xresults,
- caddr_t __resultsp,
+ char *__argsp, xdrproc_t __xresults,
+ char *__resultsp,
resultproc_t __eachresult) __THROW;
extern u_short pmap_getport (struct sockaddr_in *__address,
const u_long __program,
struct rmtcallargs {
u_long prog, vers, proc, arglen;
- caddr_t args_ptr;
+ char *args_ptr;
xdrproc_t xdr_args;
};
struct rmtcallres {
u_long *port_ptr;
u_long resultslen;
- caddr_t results_ptr;
+ char *results_ptr;
xdrproc_t xdr_results;
};
u_long high;
} AR_versions;
struct {
- caddr_t where;
+ char * where;
xdrproc_t proc;
} AR_results;
/* and many other null cases */
enum xprt_stat (*xp_stat) (SVCXPRT *__xprt);
/* get transport status */
bool_t (*xp_getargs) (SVCXPRT *__xprt, xdrproc_t __xdr_args,
- caddr_t __args_ptr); /* get arguments */
+ char *__args_ptr); /* get arguments */
bool_t (*xp_reply) (SVCXPRT *__xprt, struct rpc_msg *__msg);
/* send reply */
bool_t (*xp_freeargs) (SVCXPRT *__xprt, xdrproc_t __xdr_args,
- caddr_t __args_ptr);
+ char *__args_ptr);
/* free mem allocated for args */
void (*xp_destroy) (SVCXPRT *__xprt);
/* destroy this struct */
int xp_addrlen; /* length of remote address */
struct sockaddr_in xp_raddr; /* remote address */
struct opaque_auth xp_verf; /* raw response verifier */
- caddr_t xp_p1; /* private */
- caddr_t xp_p2; /* private */
+ char * xp_p1; /* private */
+ char * xp_p2; /* private */
char xp_pad [256]; /* padding, internal use */
};
* SVCXPRT *xprt;
* struct rpc_msg *msg;
* xdrproc_t xargs;
- * caddr_t argsp;
+ * char * argsp;
*/
#define SVC_RECV(xprt, msg) \
(*(xprt)->xp_ops->xp_recv)((xprt), (msg))
rpcvers_t rq_vers; /* service protocol version */
rpcproc_t rq_proc; /* the desired procedure */
struct opaque_auth rq_cred; /* raw creds from the wire */
- caddr_t rq_clntcred; /* read only cooked cred */
+ char *rq_clntcred; /* read only cooked cred */
SVCXPRT *rq_xprt; /* associated transport */
};
*/
extern bool_t svc_sendreply (SVCXPRT *__xprt, xdrproc_t __xdr_results,
- caddr_t __xdr_location) __THROW;
+ char *__xdr_location) __THROW;
extern void svcerr_decode (SVCXPRT *__xprt) __THROW;
/* get a long from underlying stream */
bool_t (*x_putlong) (XDR *__xdrs, const long *__lp);
/* put a long to " */
- bool_t (*x_getbytes) (XDR *__xdrs, caddr_t __addr, u_int __len);
+ bool_t (*x_getbytes) (XDR *__xdrs, char *__addr, u_int __len);
/* get some bytes from " */
bool_t (*x_putbytes) (XDR *__xdrs, const char *__addr, u_int __len);
/* put some bytes to " */
/* put a int to " */
}
*x_ops;
- caddr_t x_public; /* users' data */
- caddr_t x_private; /* pointer to private data */
- caddr_t x_base; /* private used for position info */
+ char *x_public; /* users' data */
+ char *x_private; /* pointer to private data */
+ char *x_base; /* private used for position info */
u_int x_handy; /* extra private word */
};
* The opaque pointer generally points to a structure of the data type
* to be decoded. If this pointer is 0, then the type routines should
* allocate dynamic storage of the appropriate size and return it.
- * bool_t (*xdrproc_t)(XDR *, caddr_t *);
+ * bool_t (*xdrproc_t)(XDR *, char **);
*/
typedef bool_t (*xdrproc_t) (XDR *, void *,...);
* XDR *xdrs;
* int32_t *int32p;
* long *longp;
- * caddr_t addr;
+ * char *addr;
* u_int len;
* u_int pos;
*/
extern bool_t xdr_u_quad_t (XDR *__xdrs, u_quad_t *__up) __THROW;
extern bool_t xdr_bool (XDR *__xdrs, bool_t *__bp) __THROW;
extern bool_t xdr_enum (XDR *__xdrs, enum_t *__ep) __THROW;
-extern bool_t xdr_array (XDR * _xdrs, caddr_t *__addrp, u_int *__sizep,
+extern bool_t xdr_array (XDR * _xdrs, char **__addrp, u_int *__sizep,
u_int __maxsize, u_int __elsize, xdrproc_t __elproc)
__THROW;
extern bool_t xdr_bytes (XDR *__xdrs, char **__cpp, u_int *__sizep,
u_int __maxsize) __THROW;
-extern bool_t xdr_opaque (XDR *__xdrs, caddr_t __cp, u_int __cnt) __THROW;
+extern bool_t xdr_opaque (XDR *__xdrs, char *__cp, u_int __cnt) __THROW;
extern bool_t xdr_string (XDR *__xdrs, char **__cpp, u_int __maxsize) __THROW;
extern bool_t xdr_union (XDR *__xdrs, enum_t *__dscmp, char *__unp,
const struct xdr_discrim *__choices,
u_int __elemsize, xdrproc_t __xdr_elem) __THROW;
extern bool_t xdr_float (XDR *__xdrs, float *__fp) __THROW;
extern bool_t xdr_double (XDR *__xdrs, double *__dp) __THROW;
-extern bool_t xdr_reference (XDR *__xdrs, caddr_t *__xpp, u_int __size,
+extern bool_t xdr_reference (XDR *__xdrs, char **__xpp, u_int __size,
xdrproc_t __proc) __THROW;
extern bool_t xdr_pointer (XDR *__xdrs, char **__objpp,
u_int __obj_size, xdrproc_t __xdr_obj) __THROW;
*/
/* XDR using memory buffers */
-extern void xdrmem_create (XDR *__xdrs, const caddr_t __addr,
+extern void xdrmem_create (XDR *__xdrs, const char *__addr,
u_int __size, enum xdr_op __xop) __THROW;
/* XDR using stdio library */
/* XDR pseudo records for tcp */
extern void xdrrec_create (XDR *__xdrs, u_int __sendsize,
- u_int __recvsize, caddr_t __tcp_handle,
+ u_int __recvsize, char *__tcp_handle,
int (*__readit) (char *, char *, int),
int (*__writeit) (char *, char *, int)) __THROW;
"(clnt_call (clnt, %s, (xdrproc_t) xdr_void, ", proc->proc_name);
fprintf (fout,
- "(caddr_t) NULL,\n\t\t(xdrproc_t) xdr_%s, (caddr_t) %s%s,",
+ "(char *) NULL,\n\t\t(xdrproc_t) xdr_%s, (char *) %s%s,",
stringfix(proc->res_type), (mtflag)?"":ampr(proc->res_type),
RESULT);
if (mtflag)
"(clnt_call (clnt, %s, (xdrproc_t) xdr_%s", proc->proc_name,
proc->args.argname);
fprintf (fout,
- ", (caddr_t) &arg,\n\t\t(xdrproc_t) xdr_%s, (caddr_t) %s%s,",
+ ", (char *) &arg,\n\t\t(xdrproc_t) xdr_%s, (char *) %s%s,",
stringfix(proc->res_type), (mtflag)?"":ampr(proc->res_type),
RESULT);
if (mtflag)
{ /* single argument, new or old style */
if (!mtflag)
fprintf (fout,
- "\tif (clnt_call (clnt, %s,\n\t\t(xdrproc_t) xdr_%s, (caddr_t) %s%s,\n\t\t(xdrproc_t) xdr_%s, (caddr_t) %s%s,\n\t\tTIMEOUT) != RPC_SUCCESS) {\n",
+ "\tif (clnt_call (clnt, %s,\n\t\t(xdrproc_t) xdr_%s, (char *) %s%s,\n\t\t(xdrproc_t) xdr_%s, (char *) %s%s,\n\t\tTIMEOUT) != RPC_SUCCESS) {\n",
proc->proc_name,
stringfix (proc->args.decls->decl.type),
(newstyle ? "&" : ""),
RESULT);
else
fprintf(fout,
- "\treturn (clnt_call(clnt, %s,\n\t\t(xdrproc_t) xdr_%s, (caddr_t) %s%s,\n\t\t(xdrproc_t) xdr_%s, (caddr_t) %s%s,\n\t\tTIMEOUT));\n",
+ "\treturn (clnt_call(clnt, %s,\n\t\t(xdrproc_t) xdr_%s, (char *) %s%s,\n\t\t(xdrproc_t) xdr_%s, (char *) %s%s,\n\t\tTIMEOUT));\n",
proc->proc_name,
stringfix (proc->args.decls->decl.type),
(newstyle ? "&" : ""),
(void) IXDR_PUT_INT32 (buf, oa->oa_length);
if (oa->oa_length)
{
- memcpy ((caddr_t) buf, oa->oa_base, oa->oa_length);
+ memcpy ((char *) buf, oa->oa_base, oa->oa_length);
buf = (int32_t *) ((char *) buf + RNDUP (oa->oa_length));
}
oa = &cmsg->rm_call.cb_verf;
(void) IXDR_PUT_INT32 (buf, oa->oa_length);
if (oa->oa_length)
{
- memcpy ((caddr_t) buf, oa->oa_base, oa->oa_length);
+ memcpy ((char *) buf, oa->oa_base, oa->oa_length);
/* no real need....
buf = (long *) ((char *) buf + RNDUP(oa->oa_length));
*/
return FALSE;
if (oa->oa_base == NULL)
{
- oa->oa_base = (caddr_t)
+ oa->oa_base = (char *)
mem_alloc (oa->oa_length);
}
buf = XDR_INLINE (xdrs, RNDUP (oa->oa_length));
}
else
{
- memcpy (oa->oa_base, (caddr_t) buf, oa->oa_length);
+ memcpy (oa->oa_base, (char *) buf, oa->oa_length);
/* no real need....
buf = (long *) ((char *) buf
+ RNDUP(oa->oa_length));
return FALSE;
if (oa->oa_base == NULL)
{
- oa->oa_base = (caddr_t)
+ oa->oa_base = (char *)
mem_alloc (oa->oa_length);
}
buf = XDR_INLINE (xdrs, RNDUP (oa->oa_length));
}
else
{
- memcpy (oa->oa_base, (caddr_t) buf, oa->oa_length);
+ memcpy (oa->oa_base, (char *) buf, oa->oa_length);
/* no real need...
buf = (long *) ((char *) buf
+ RNDUP(oa->oa_length));
f_print (fout, "extern int ");
pvname (name, vers);
if (mode == 1)
- f_print (fout,"_freeresult (SVCXPRT *, xdrproc_t, caddr_t);\n");
+ f_print (fout,"_freeresult (SVCXPRT *, xdrproc_t, char *);\n");
else
f_print (fout,"_freeresult ();\n");
}
bool_t
xdr_des_block (XDR *xdrs, des_block *blkp)
{
- return xdr_opaque (xdrs, (caddr_t) blkp, sizeof (des_block));
+ return xdr_opaque (xdrs, (char *) blkp, sizeof (des_block));
}
libc_hidden_nolink_sunrpc (xdr_des_block, GLIBC_2_0)
xdr_enum (xdrs, (enum_t *) & (rmsg->rm_direction)) &&
(rmsg->rm_direction == REPLY))
return xdr_union (xdrs, (enum_t *) & (rmsg->rm_reply.rp_stat),
- (caddr_t) & (rmsg->rm_reply.ru), reply_dscrm,
+ (char *) & (rmsg->rm_reply.ru), reply_dscrm,
NULL_xdrproc_t);
return FALSE;
}
f_print(fout, "\nint\n");
pvname(def->def_name, vp->vers_num);
if (Cflag)
- f_print(fout,"_freeresult (SVCXPRT *transp, xdrproc_t xdr_result, caddr_t result)\n");
+ f_print(fout,"_freeresult (SVCXPRT *transp, xdrproc_t xdr_result, char *result)\n");
else
{
f_print(fout,"_freeresult (transp, xdr_result, result)\n");
f_print(fout,"\tSVCXPRT *transp;\n");
f_print(fout,"\txdrproc_t xdr_result;\n");
- f_print(fout,"\tcaddr_t result;\n");
+ f_print(fout,"\tchar *result;\n");
}
f_print(fout, "{\n");
f_print(fout, "\txdr_free (xdr_result, result);\n");
{
f_print(fout,"\tif (!");
pvname(def->def_name, vp->vers_num);
- f_print(fout,"_freeresult (%s, _xdr_%s, (caddr_t) &%s))\n",
+ f_print(fout,"_freeresult (%s, _xdr_%s, (char *) &%s))\n",
TRANSP, RESULT, RESULT);
(void) sprintf(_errbuf, "unable to free results");
print_err_message("\t\t");
static void
printif (const char *proc, const char *transp, const char *arg)
{
- f_print (fout, "\tif (!svc_%s (%s, (xdrproc_t) _xdr_%s, (caddr_t) &%s)) {\n",
+ f_print (fout, "\tif (!svc_%s (%s, (xdrproc_t) _xdr_%s, (char *) &%s)) {\n",
proc, transp, arg, arg);
}
}
else
{
- f_print (fout, "void _msgout (char* msg)\n");
+ f_print (fout, "void _msgout (char *msg)\n");
}
f_print (fout, "{\n");
f_print (fout, "#ifdef RPC_SVC_FG\n");
/* Send a reply to an rpc request */
bool_t
svc_sendreply (register SVCXPRT *xprt, xdrproc_t xdr_results,
- caddr_t xdr_location)
+ char *xdr_location)
{
struct rpc_msg rply;
stat = AUTH_BADCRED;
goto done;
}
- memcpy (aup->aup_machname, (caddr_t) buf, (u_int) str_len);
+ memcpy (aup->aup_machname, (char *) buf, (u_int) str_len);
aup->aup_machname[str_len] = 0;
str_len = RNDUP (str_len);
buf = (int32_t *) ((char *) buf + str_len);
static bool_t svcraw_recv (SVCXPRT *, struct rpc_msg *);
static enum xprt_stat svcraw_stat (SVCXPRT *);
-static bool_t svcraw_getargs (SVCXPRT *, xdrproc_t, caddr_t);
+static bool_t svcraw_getargs (SVCXPRT *, xdrproc_t, char *);
static bool_t svcraw_reply (SVCXPRT *, struct rpc_msg *);
-static bool_t svcraw_freeargs (SVCXPRT *, xdrproc_t, caddr_t);
+static bool_t svcraw_freeargs (SVCXPRT *, xdrproc_t, char *);
static void svcraw_destroy (SVCXPRT *);
static const struct xp_ops server_ops =
}
static bool_t
-svcraw_getargs (SVCXPRT *xprt, xdrproc_t xdr_args, caddr_t args_ptr)
+svcraw_getargs (SVCXPRT *xprt, xdrproc_t xdr_args, char *args_ptr)
{
struct svcraw_private_s *srp = svcraw_private;
}
static bool_t
-svcraw_freeargs (SVCXPRT *xprt, xdrproc_t xdr_args, caddr_t args_ptr)
+svcraw_freeargs (SVCXPRT *xprt, xdrproc_t xdr_args, char *args_ptr)
{
struct svcraw_private_s *srp = svcraw_private;
XDR *xdrs;
*/
static bool_t svctcp_recv (SVCXPRT *, struct rpc_msg *);
static enum xprt_stat svctcp_stat (SVCXPRT *);
-static bool_t svctcp_getargs (SVCXPRT *, xdrproc_t, caddr_t);
+static bool_t svctcp_getargs (SVCXPRT *, xdrproc_t, char *);
static bool_t svctcp_reply (SVCXPRT *, struct rpc_msg *);
-static bool_t svctcp_freeargs (SVCXPRT *, xdrproc_t, caddr_t);
+static bool_t svctcp_freeargs (SVCXPRT *, xdrproc_t, char *);
static void svctcp_destroy (SVCXPRT *);
static const struct xp_ops svctcp_op =
{
rendezvous_request,
rendezvous_stat,
- (bool_t (*) (SVCXPRT *, xdrproc_t, caddr_t)) svctcp_rendezvous_abort,
+ (bool_t (*) (SVCXPRT *, xdrproc_t, char *)) svctcp_rendezvous_abort,
(bool_t (*) (SVCXPRT *, struct rpc_msg *)) svctcp_rendezvous_abort,
- (bool_t (*) (SVCXPRT *, xdrproc_t, caddr_t)) svctcp_rendezvous_abort,
+ (bool_t (*) (SVCXPRT *, xdrproc_t, char *)) svctcp_rendezvous_abort,
svctcp_destroy
};
r->sendsize = sendsize;
r->recvsize = recvsize;
xprt->xp_p2 = NULL;
- xprt->xp_p1 = (caddr_t) r;
+ xprt->xp_p1 = (char *) r;
xprt->xp_verf = _null_auth;
xprt->xp_ops = &svctcp_rendezvous_op;
xprt->xp_port = ntohs (addr.sin_port);
}
cd->strm_stat = XPRT_IDLE;
xdrrec_create (&(cd->xdrs), sendsize, recvsize,
- (caddr_t) xprt, readtcp, writetcp);
+ (char *) xprt, readtcp, writetcp);
xprt->xp_p2 = NULL;
- xprt->xp_p1 = (caddr_t) cd;
+ xprt->xp_p1 = (char *) cd;
xprt->xp_verf.oa_base = cd->verf_body;
xprt->xp_addrlen = 0;
xprt->xp_ops = &svctcp_op; /* truly deals with calls */
/* an actual connection socket */
XDR_DESTROY (&(cd->xdrs));
}
- mem_free ((caddr_t) cd, sizeof (struct tcp_conn));
- mem_free ((caddr_t) xprt, sizeof (SVCXPRT));
+ mem_free ((char *) cd, sizeof (struct tcp_conn));
+ mem_free ((char *) xprt, sizeof (SVCXPRT));
}
* Any error is fatal and the connection is closed.
*/
static int
-writetcp (char *xprtptr, char * buf, int len)
+writetcp (char *xprtptr, char *buf, int len)
{
SVCXPRT *xprt = (SVCXPRT *)xprtptr;
int i, cnt;
}
static bool_t
-svctcp_getargs (SVCXPRT *xprt, xdrproc_t xdr_args, caddr_t args_ptr)
+svctcp_getargs (SVCXPRT *xprt, xdrproc_t xdr_args, char *args_ptr)
{
return ((*xdr_args) (&(((struct tcp_conn *)
(xprt->xp_p1))->xdrs), args_ptr));
}
static bool_t
-svctcp_freeargs (SVCXPRT *xprt, xdrproc_t xdr_args, caddr_t args_ptr)
+svctcp_freeargs (SVCXPRT *xprt, xdrproc_t xdr_args, char *args_ptr)
{
XDR *xdrs = &(((struct tcp_conn *) (xprt->xp_p1))->xdrs);
static bool_t svcudp_recv (SVCXPRT *, struct rpc_msg *);
static bool_t svcudp_reply (SVCXPRT *, struct rpc_msg *);
static enum xprt_stat svcudp_stat (SVCXPRT *);
-static bool_t svcudp_getargs (SVCXPRT *, xdrproc_t, caddr_t);
-static bool_t svcudp_freeargs (SVCXPRT *, xdrproc_t, caddr_t);
+static bool_t svcudp_getargs (SVCXPRT *, xdrproc_t, char *);
+static bool_t svcudp_freeargs (SVCXPRT *, xdrproc_t, char *);
static void svcudp_destroy (SVCXPRT *);
static const struct xp_ops svcudp_op =
rpc_buffer (xprt) = buf;
xdrmem_create (&(su->su_xdrs), rpc_buffer (xprt), su->su_iosz, XDR_DECODE);
su->su_cache = NULL;
- xprt->xp_p2 = (caddr_t) su;
+ xprt->xp_p2 = (char *) su;
xprt->xp_verf.oa_base = su->su_verfbody;
xprt->xp_ops = &svcudp_op;
xprt->xp_port = ntohs (addr.sin_port);
}
static bool_t
-svcudp_getargs (SVCXPRT *xprt, xdrproc_t xdr_args, caddr_t args_ptr)
+svcudp_getargs (SVCXPRT *xprt, xdrproc_t xdr_args, char *args_ptr)
{
return (*xdr_args) (&(su_data (xprt)->su_xdrs), args_ptr);
}
static bool_t
-svcudp_freeargs (SVCXPRT *xprt, xdrproc_t xdr_args, caddr_t args_ptr)
+svcudp_freeargs (SVCXPRT *xprt, xdrproc_t xdr_args, char *args_ptr)
{
XDR *xdrs = &(su_data (xprt)->su_xdrs);
(void) __close (xprt->xp_sock);
XDR_DESTROY (&(su->su_xdrs));
mem_free (rpc_buffer (xprt), su->su_iosz);
- mem_free ((caddr_t) su, sizeof (struct svcudp_data));
- mem_free ((caddr_t) xprt, sizeof (SVCXPRT));
+ mem_free ((char *) su, sizeof (struct svcudp_data));
+ mem_free ((char *) xprt, sizeof (SVCXPRT));
}
*/
static bool_t svcunix_recv (SVCXPRT *, struct rpc_msg *);
static enum xprt_stat svcunix_stat (SVCXPRT *);
-static bool_t svcunix_getargs (SVCXPRT *, xdrproc_t, caddr_t);
+static bool_t svcunix_getargs (SVCXPRT *, xdrproc_t, char *);
static bool_t svcunix_reply (SVCXPRT *, struct rpc_msg *);
-static bool_t svcunix_freeargs (SVCXPRT *, xdrproc_t, caddr_t);
+static bool_t svcunix_freeargs (SVCXPRT *, xdrproc_t, char *);
static void svcunix_destroy (SVCXPRT *);
static const struct xp_ops svcunix_op =
{
rendezvous_request,
rendezvous_stat,
- (bool_t (*) (SVCXPRT *, xdrproc_t, caddr_t)) svcunix_rendezvous_abort,
+ (bool_t (*) (SVCXPRT *, xdrproc_t, char *)) svcunix_rendezvous_abort,
(bool_t (*) (SVCXPRT *, struct rpc_msg *)) svcunix_rendezvous_abort,
- (bool_t (*) (SVCXPRT *, xdrproc_t, caddr_t)) svcunix_rendezvous_abort,
+ (bool_t (*) (SVCXPRT *, xdrproc_t, char *)) svcunix_rendezvous_abort,
svcunix_destroy
};
r->sendsize = sendsize;
r->recvsize = recvsize;
xprt->xp_p2 = NULL;
- xprt->xp_p1 = (caddr_t) r;
+ xprt->xp_p1 = (char *) r;
xprt->xp_verf = _null_auth;
xprt->xp_ops = &svcunix_rendezvous_op;
xprt->xp_port = -1;
}
cd->strm_stat = XPRT_IDLE;
xdrrec_create (&(cd->xdrs), sendsize, recvsize,
- (caddr_t) xprt, readunix, writeunix);
+ (char *) xprt, readunix, writeunix);
xprt->xp_p2 = NULL;
- xprt->xp_p1 = (caddr_t) cd;
+ xprt->xp_p1 = (char *) cd;
xprt->xp_verf.oa_base = cd->verf_body;
xprt->xp_addrlen = 0;
xprt->xp_ops = &svcunix_op; /* truly deals with calls */
/* an actual connection socket */
XDR_DESTROY (&(cd->xdrs));
}
- mem_free ((caddr_t) cd, sizeof (struct unix_conn));
- mem_free ((caddr_t) xprt, sizeof (SVCXPRT));
+ mem_free ((char *) cd, sizeof (struct unix_conn));
+ mem_free ((char *) xprt, sizeof (SVCXPRT));
}
#ifdef SCM_CREDENTIALS
msg.msg_name = NULL;
msg.msg_namelen = 0;
#ifdef SCM_CREDENTIALS
- msg.msg_control = (caddr_t) &cm;
+ msg.msg_control = (char *) &cm;
msg.msg_controllen = sizeof (struct cmessage);
#endif
msg.msg_flags = 0;
* Any error is fatal and the connection is closed.
*/
static int
-writeunix (char *xprtptr, char * buf, int len)
+writeunix (char *xprtptr, char *buf, int len)
{
SVCXPRT *xprt = (SVCXPRT *) xprtptr;
int i, cnt;
/* set up verifiers */
#ifdef SCM_CREDENTIALS
msg->rm_call.cb_verf.oa_flavor = AUTH_UNIX;
- msg->rm_call.cb_verf.oa_base = (caddr_t) &cm;
+ msg->rm_call.cb_verf.oa_base = (char *) &cm;
msg->rm_call.cb_verf.oa_length = sizeof (cm);
#endif
return TRUE;
}
static bool_t
-svcunix_getargs (SVCXPRT *xprt, xdrproc_t xdr_args, caddr_t args_ptr)
+svcunix_getargs (SVCXPRT *xprt, xdrproc_t xdr_args, char *args_ptr)
{
return (*xdr_args) (&(((struct unix_conn *) (xprt->xp_p1))->xdrs),
args_ptr);
}
static bool_t
-svcunix_freeargs (SVCXPRT *xprt, xdrproc_t xdr_args, caddr_t args_ptr)
+svcunix_freeargs (SVCXPRT *xprt, xdrproc_t xdr_args, char *args_ptr)
{
XDR *xdrs = &(((struct unix_conn *) (xprt->xp_p1))->xdrs);
* cp points to the opaque object and cnt gives the byte length.
*/
bool_t
-xdr_opaque (XDR *xdrs, caddr_t cp, u_int cnt)
+xdr_opaque (XDR *xdrs, char *cp, u_int cnt)
{
u_int rndup;
static char crud[BYTES_PER_XDR_UNIT];
}
if (rndup == 0)
return TRUE;
- return XDR_GETBYTES (xdrs, (caddr_t)crud, rndup);
+ return XDR_GETBYTES (xdrs, (char *)crud, rndup);
case XDR_ENCODE:
if (!XDR_PUTBYTES (xdrs, cp, cnt))
bool_t
xdr_array (XDR *xdrs,
/* array pointer */
- caddr_t *addrp,
+ char **addrp,
/* number of elements */
u_int *sizep,
/* max numberof elements */
xdrproc_t elproc)
{
u_int i;
- caddr_t target = *addrp;
+ char *target = *addrp;
u_int c; /* the actual element count */
bool_t stat = TRUE;
static bool_t xdrmem_getlong (XDR *, long *);
static bool_t xdrmem_putlong (XDR *, const long *);
-static bool_t xdrmem_getbytes (XDR *, caddr_t, u_int);
+static bool_t xdrmem_getbytes (XDR *, char *, u_int);
static bool_t xdrmem_putbytes (XDR *, const char *, u_int);
static u_int xdrmem_getpos (const XDR *);
static bool_t xdrmem_setpos (XDR *, u_int);
* memory buffer.
*/
void
-xdrmem_create (XDR *xdrs, const caddr_t addr, u_int size, enum xdr_op op)
+xdrmem_create (XDR *xdrs, const char *addr, u_int size, enum xdr_op op)
{
xdrs->x_op = op;
/* We have to add the const since the `struct xdr_ops' in `struct XDR'
is not `const'. */
xdrs->x_ops = (struct xdr_ops *) &xdrmem_ops;
- xdrs->x_private = xdrs->x_base = addr;
+ xdrs->x_private = xdrs->x_base = (char *)addr;
xdrs->x_handy = size;
}
#ifdef EXPORT_RPC_SYMBOLS
* a good idea. None of the things pointed to are const.
*/
static bool_t
-xdrmem_getbytes (XDR *xdrs, caddr_t addr, u_int len)
+xdrmem_getbytes (XDR *xdrs, char *addr, u_int len)
{
if (xdrs->x_handy < len)
return FALSE;
static bool_t
xdrmem_setpos (XDR *xdrs, u_int pos)
{
- caddr_t newaddr = xdrs->x_base + pos;
- caddr_t lastaddr = xdrs->x_private + xdrs->x_handy;
+ char *newaddr = xdrs->x_base + pos;
+ char *lastaddr = xdrs->x_private + xdrs->x_handy;
size_t handy = lastaddr - newaddr;
if (newaddr > lastaddr
static bool_t xdrrec_getlong (XDR *, long *);
static bool_t xdrrec_putlong (XDR *, const long *);
-static bool_t xdrrec_getbytes (XDR *, caddr_t, u_int);
+static bool_t xdrrec_getbytes (XDR *, char *, u_int);
static bool_t xdrrec_putbytes (XDR *, const char *, u_int);
static u_int xdrrec_getpos (const XDR *);
static bool_t xdrrec_setpos (XDR *, u_int);
typedef struct rec_strm
{
- caddr_t tcp_handle;
- caddr_t the_buffer;
+ char *tcp_handle;
+ char *the_buffer;
/*
* out-going bits
*/
int (*writeit) (char *, char *, int);
- caddr_t out_base; /* output buffer (points to frag header) */
- caddr_t out_finger; /* next output position */
- caddr_t out_boundry; /* data cannot up to this address */
+ char *out_base; /* output buffer (points to frag header) */
+ char *out_finger; /* next output position */
+ char *out_boundry; /* data cannot up to this address */
uint32_t *frag_header; /* beginning of curren fragment */
bool_t frag_sent; /* true if buffer sent in middle of record */
/*
*/
int (*readit) (char *, char *, int);
u_long in_size; /* fixed size of the input buffer */
- caddr_t in_base;
- caddr_t in_finger; /* location of next byte to be had */
- caddr_t in_boundry; /* can read up to this location */
+ char *in_base;
+ char *in_finger; /* location of next byte to be had */
+ char *in_boundry; /* can read up to this location */
long fbtbc; /* fragment bytes to be consumed */
bool_t last_frag;
u_int sendsize;
static bool_t skip_input_bytes (RECSTREAM *, long);
static bool_t flush_out (RECSTREAM *, bool_t);
static bool_t set_input_fragment (RECSTREAM *);
-static bool_t get_input_bytes (RECSTREAM *, caddr_t, int);
+static bool_t get_input_bytes (RECSTREAM *, char *, int);
/*
* Create an xdr handle for xdrrec
*/
void
xdrrec_create (XDR *xdrs, u_int sendsize,
- u_int recvsize, caddr_t tcp_handle,
+ u_int recvsize, char *tcp_handle,
int (*readit) (char *, char *, int),
int (*writeit) (char *, char *, int))
{
RECSTREAM *rstrm = (RECSTREAM *) mem_alloc (sizeof (RECSTREAM));
- caddr_t tmp;
+ char *tmp;
char *buf;
sendsize = fix_buf_size (sendsize);
/* We have to add the cast since the `struct xdr_ops' in `struct XDR'
is not `const'. */
xdrs->x_ops = (struct xdr_ops *) &xdrrec_ops;
- xdrs->x_private = (caddr_t) rstrm;
+ xdrs->x_private = (char *) rstrm;
rstrm->tcp_handle = tcp_handle;
rstrm->readit = readit;
rstrm->writeit = writeit;
}
else
{
- if (!xdrrec_getbytes (xdrs, (caddr_t) & mylong,
+ if (!xdrrec_getbytes (xdrs, (char *) & mylong,
BYTES_PER_XDR_UNIT))
return FALSE;
*lp = (int32_t) ntohl (mylong);
}
static bool_t /* must manage buffers, fragments, and records */
-xdrrec_getbytes (XDR *xdrs, caddr_t addr, u_int len)
+xdrrec_getbytes (XDR *xdrs, char *addr, u_int len)
{
RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private;
u_int current;
RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private;
u_int currpos = xdrrec_getpos (xdrs);
int delta = currpos - pos;
- caddr_t newpos;
+ char *newpos;
if ((int) currpos != -1)
switch (xdrs->x_op)
case XDR_ENCODE:
newpos = rstrm->out_finger - delta;
- if (newpos > (caddr_t) rstrm->frag_header &&
+ if (newpos > (char *) rstrm->frag_header &&
newpos < rstrm->out_boundry)
{
rstrm->out_finger = newpos;
mem_free (rstrm->the_buffer,
rstrm->sendsize + rstrm->recvsize + BYTES_PER_XDR_UNIT);
- mem_free ((caddr_t) rstrm, sizeof (RECSTREAM));
+ mem_free ((char *) rstrm, sizeof (RECSTREAM));
}
static bool_t
}
else
{
- if (!xdrrec_getbytes (xdrs, (caddr_t) &mylong,
+ if (!xdrrec_getbytes (xdrs, (char *) &mylong,
BYTES_PER_XDR_UNIT))
return FALSE;
*ip = ntohl (mylong);
!= (int) len)
return FALSE;
rstrm->frag_header = (uint32_t *) rstrm->out_base;
- rstrm->out_finger = (caddr_t) rstrm->out_base + BYTES_PER_XDR_UNIT;
+ rstrm->out_finger = (char *) rstrm->out_base + BYTES_PER_XDR_UNIT;
return TRUE;
}
static bool_t /* knows nothing about records! Only about input buffers */
fill_input_buf (RECSTREAM *rstrm)
{
- caddr_t where;
+ char *where;
size_t i;
int len;
}
static bool_t /* knows nothing about records! Only about input buffers */
-get_input_bytes (RECSTREAM *rstrm, caddr_t addr, int len)
+get_input_bytes (RECSTREAM *rstrm, char *addr, int len)
{
int current;
{
uint32_t header;
- if (! get_input_bytes (rstrm, (caddr_t)&header, BYTES_PER_XDR_UNIT))
+ if (! get_input_bytes (rstrm, (char *)&header, BYTES_PER_XDR_UNIT))
return FALSE;
header = ntohl (header);
rstrm->last_frag = ((header & LAST_FRAG) == 0) ? FALSE : TRUE;
bool_t
xdr_reference (XDR *xdrs,
/* the pointer to work on */
- caddr_t *pp,
+ char **pp,
/* size of the object pointed to */
u_int size,
/* xdr routine to handle the object */
xdrproc_t proc)
{
- caddr_t loc = *pp;
+ char *loc = *pp;
bool_t stat;
if (loc == NULL)
return TRUE;
case XDR_DECODE:
- *pp = loc = (caddr_t) calloc (1, size);
+ *pp = loc = (char *) calloc (1, size);
if (loc == NULL)
{
(void) __fxprintf (NULL, "%s: %s", __func__, _("out of memory\n"));
{
/* Free the earlier space and allocate new area */
free (xdrs->x_private);
- if ((xdrs->x_private = (caddr_t) malloc (len)) == NULL)
+ if ((xdrs->x_private = (char *) malloc (len)) == NULL)
{
xdrs->x_base = 0;
return NULL;
bool_t stat;
/* to stop ANSI-C compiler from complaining */
typedef bool_t (*dummyfunc1) (XDR *, long *);
- typedef bool_t (*dummyfunc2) (XDR *, caddr_t, u_int);
+ typedef bool_t (*dummyfunc2) (XDR *, char *, u_int);
typedef bool_t (*dummyfunc3) (XDR *, int32_t *);
ops.x_putlong = x_putlong;
x.x_op = XDR_ENCODE;
x.x_ops = &ops;
x.x_handy = 0;
- x.x_private = (caddr_t) NULL;
- x.x_base = (caddr_t) 0;
+ x.x_private = (char *) NULL;
+ x.x_base = (char *) 0;
stat = func (&x, data);
free (x.x_private);
static bool_t xdrstdio_getlong (XDR *, long *);
static bool_t xdrstdio_putlong (XDR *, const long *);
-static bool_t xdrstdio_getbytes (XDR *, caddr_t, u_int);
+static bool_t xdrstdio_getbytes (XDR *, char *, u_int);
static bool_t xdrstdio_putbytes (XDR *, const char *, u_int);
static u_int xdrstdio_getpos (const XDR *);
static bool_t xdrstdio_setpos (XDR *, u_int);
/* We have to add the const since the `struct xdr_ops' in `struct XDR'
is not `const'. */
xdrs->x_ops = (struct xdr_ops *) &xdrstdio_ops;
- xdrs->x_private = (caddr_t) file;
+ xdrs->x_private = (char *) file;
xdrs->x_handy = 0;
xdrs->x_base = 0;
}
{
uint32_t mycopy;
- if (fread ((caddr_t) &mycopy, 4, 1, (FILE *) xdrs->x_private) != 1)
+ if (fread ((char *) &mycopy, 4, 1, (FILE *) xdrs->x_private) != 1)
return FALSE;
*lp = (long) ntohl (mycopy);
return TRUE;
{
int32_t mycopy = htonl ((uint32_t) *lp);
- if (fwrite ((caddr_t) &mycopy, 4, 1, (FILE *) xdrs->x_private) != 1)
+ if (fwrite ((char *) &mycopy, 4, 1, (FILE *) xdrs->x_private) != 1)
return FALSE;
return TRUE;
}
static bool_t
-xdrstdio_getbytes (XDR *xdrs, const caddr_t addr, u_int len)
+xdrstdio_getbytes (XDR *xdrs, char *addr, u_int len)
{
if ((len != 0) && (fread (addr, (int) len, 1,
(FILE *) xdrs->x_private) != 1))
{
int32_t mycopy;
- if (fread ((caddr_t) &mycopy, 4, 1, (FILE *) xdrs->x_private) != 1)
+ if (fread ((char *) &mycopy, 4, 1, (FILE *) xdrs->x_private) != 1)
return FALSE;
*ip = ntohl (mycopy);
return TRUE;
int32_t mycopy = htonl (*ip);
ip = &mycopy;
- if (fwrite ((caddr_t) ip, 4, 1, (FILE *) xdrs->x_private) != 1)
+ if (fwrite ((char *) ip, 4, 1, (FILE *) xdrs->x_private) != 1)
return FALSE;
return TRUE;
}
void xmprotect (void *addr, size_t length, int prot);
void xmunmap (void *addr, size_t length);
-ssize_t xcopy_file_range(int fd_in, loff_t *off_in, int fd_out,
- loff_t *off_out, size_t len, unsigned int flags);
+ssize_t xcopy_file_range(int fd_in, off64_t *off_in, int fd_out,
+ off64_t *off_out, size_t len, unsigned int flags);
__END_DECLS
struct ifmap ifru_map;
char ifru_slave[IFNAMSIZ]; /* Just fits the size */
char ifru_newname[IFNAMSIZ];
- __caddr_t ifru_data;
+ char *ifru_data;
} ifr_ifru;
};
# define ifr_name ifr_ifrn.ifrn_name /* interface name */
int ifc_len; /* Size of buffer. */
union
{
- __caddr_t ifcu_buf;
+ char *ifcu_buf;
struct ifreq *ifcu_req;
} ifc_ifcu;
};
long int mt_gstat; /* Generic (device independent) status. */
long int mt_erreg; /* Error register. */
/* The next two fields are not always used. */
- __daddr_t mt_fileno; /* Number of current file on tape. */
- __daddr_t mt_blkno; /* Current block number. */
+ int mt_fileno; /* Number of current file on tape. */
+ int mt_blkno; /* Current block number. */
};
#define _IOT_mtget /* Hurd ioctl type field. */ \
_IOT (_IOTS (long), 7, 0, 0, 0, 0)
#define __TIME_T_TYPE __SLONGWORD_TYPE
#define __USECONDS_T_TYPE __U32_TYPE
#define __SUSECONDS_T_TYPE __SLONGWORD_TYPE
-#define __DADDR_T_TYPE __S32_TYPE
#define __KEY_T_TYPE __S32_TYPE
#define __CLOCKID_T_TYPE __S32_TYPE
#define __TIMER_T_TYPE __S32_TYPE
#define __TIME_T_TYPE __SLONGWORD_TYPE
#define __USECONDS_T_TYPE __U32_TYPE
#define __SUSECONDS_T_TYPE __S64_TYPE
-#define __DADDR_T_TYPE __S32_TYPE
#define __KEY_T_TYPE __S32_TYPE
#define __CLOCKID_T_TYPE __S32_TYPE
#define __TIMER_T_TYPE void *
#define __TIME_T_TYPE __SLONGWORD_TYPE
#define __USECONDS_T_TYPE __U32_TYPE
#define __SUSECONDS_T_TYPE __SLONGWORD_TYPE
-#define __DADDR_T_TYPE __S32_TYPE
#define __KEY_T_TYPE __S32_TYPE
#define __CLOCKID_T_TYPE __S32_TYPE
#define __TIMER_T_TYPE void *
in with standard 64-bit syscalls but return them through APIs that
only expose the low 32 bits of some fields. */
-static inline off_t lseek_overflow (loff_t res)
+static inline off_t lseek_overflow (off64_t res)
{
off_t retval = (off_t) res;
if (retval == res)
in with standard 64-bit syscalls but return them through APIs that
only expose the low 32 bits of some fields. */
-static inline off_t lseek_overflow (loff_t res)
+static inline off_t lseek_overflow (off64_t res)
{
off_t retval = (off_t) res;
if (retval == res)
__lseek (int fd, off_t offset, int whence)
{
# ifdef __NR__llseek
- loff_t res;
+ off64_t res;
int rc = INLINE_SYSCALL_CALL (_llseek, fd,
(long) (((uint64_t) (offset)) >> 32),
(long) offset, &res, whence);
__lseek64 (int fd, off64_t offset, int whence)
{
#ifdef __NR__llseek
- loff_t res;
+ off64_t res;
int rc = INLINE_SYSCALL_CALL (_llseek, fd,
(long) (((uint64_t) (offset)) >> 32),
(long) offset, &res, whence);
#define __TIME_T_TYPE __SLONGWORD_TYPE
#define __USECONDS_T_TYPE __U32_TYPE
#define __SUSECONDS_T_TYPE __SLONGWORD_TYPE
-#define __DADDR_T_TYPE __S32_TYPE
#define __KEY_T_TYPE __S32_TYPE
#define __CLOCKID_T_TYPE __S32_TYPE
#define __TIMER_T_TYPE void *
#define __TIME_T_TYPE __SLONGWORD_TYPE
#define __USECONDS_T_TYPE __U32_TYPE
#define __SUSECONDS_T_TYPE __SLONGWORD_TYPE
-#define __DADDR_T_TYPE __S32_TYPE
#define __KEY_T_TYPE __S32_TYPE
#define __CLOCKID_T_TYPE __S32_TYPE
#define __TIMER_T_TYPE void *
#define __TIME_T_TYPE __SLONGWORD_TYPE
#define __USECONDS_T_TYPE __U32_TYPE
#define __SUSECONDS_T_TYPE __S32_TYPE
-#define __DADDR_T_TYPE __S32_TYPE
#define __KEY_T_TYPE __S32_TYPE
#define __CLOCKID_T_TYPE __S32_TYPE
#define __TIMER_T_TYPE void *
#include <sysdep-cancel.h>
ssize_t
-splice (int fd_in, loff_t *off_in, int fd_out, loff_t *off_out, size_t len,
+splice (int fd_in, off64_t *off_in, int fd_out, off64_t *off_out, size_t len,
unsigned int flags)
{
return SYSCALL_CANCEL (splice, fd_in, off_in, fd_out, off_out, len, flags);
#define dq_btime dq_dqb.dqb_btime
#define dq_itime dq_dqb.dqb_itime
-#define dqoff(UID) ((__loff_t)((UID) * sizeof (struct dqblk)))
+#define dqoff(UID) ((__off64_t)((UID) * sizeof (struct dqblk)))
/* Old name for struct if_dqinfo. */
struct dqinfo
__BEGIN_DECLS
extern int quotactl (int __cmd, const char *__special, int __id,
- __caddr_t __addr) __THROW;
+ char *__addr) __THROW;
__END_DECLS
of containers. Linux 5.4 added additional argument validation
and can return EINVAL. */
fails |= test_wrp2 (LIST (ENODEV, ENOSYS, EPERM, EINVAL),
- quotactl, Q_GETINFO, NULL, -1, (caddr_t) &dqblk);
+ quotactl, Q_GETINFO, NULL, -1, (char *) &dqblk);
fails |= test_wrp (EINVAL, sched_getparam, -1, &sch_param);
fails |= test_wrp (EINVAL, sched_getscheduler, -1);
fails |= test_wrp (EINVAL, sched_get_priority_max, -1);
})
# endif
+/* INLINE_SYSCALL_CALL requires all pointer arguments to point to
+ complete types, but we do not need to access any of the fields of
+ this structure. It was formerly 20, 24, or 32 bytes, depending on
+ architecture and _FILE_OFFSET_BITS. */
struct ustat
{
- __daddr_t f_tfree; /* Number of free blocks. */
- __ino_t f_tinode; /* Number of free inodes. */
- char f_fname[6];
- char f_fpack[6];
+ char dummy[32];
};
int
#define __TIME_T_TYPE __SYSCALL_SLONG_TYPE
#define __USECONDS_T_TYPE __U32_TYPE
#define __SUSECONDS_T_TYPE __SYSCALL_SLONG_TYPE
-#define __DADDR_T_TYPE __S32_TYPE
#define __KEY_T_TYPE __S32_TYPE
#define __CLOCKID_T_TYPE __S32_TYPE
#define __TIMER_T_TYPE void *
projects / thirdparty / glibc.git / commitdiff
