git.sur5r.net Git - openldap/blob - libraries/liblutil/getpeereid.c

   1 /* getpeereid.c */
   2 /* $OpenLDAP$ */
   3 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
   4  *
   5  * Copyright 2000-2005 The OpenLDAP Foundation.
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted only as authorized by the OpenLDAP
  10  * Public License.
  11  *
  12  * A copy of this license is available in the file LICENSE in the
  13  * top-level directory of the distribution or, alternatively, at
  14  * <http://www.OpenLDAP.org/license.html>.
  15  */
  16
  17 #include "portable.h"
  18
  19 #ifndef HAVE_GETPEEREID
  20
  21 #include <sys/types.h>
  22 #include <ac/unistd.h>
  23
  24 #include <ac/socket.h>
  25 #include <ac/errno.h>
  26
  27 #if HAVE_SYS_UCRED_H
  28 #if HAVE_GRP_H
  29 #include <grp.h>        /* for NGROUPS on Tru64 5.1 */
  30 #endif
  31 #include <sys/ucred.h>
  32 #endif
  33
  34 #if !defined(SO_PEERCRED) && !defined(LOCAL_PEERCRED) && \
  35         defined(HAVE_SENDMSG) && (defined(HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS) || \
  36                                   defined(HAVE_STRUCT_MSGHDR_MSG_CONTROL))
  37 #define DO_SENDMSG
  38 #ifdef HAVE_SYS_UIO_H
  39 #include <sys/uio.h>
  40 #endif
  41 #include <sys/stat.h>
  42 #endif
  43
  44 #include <stdlib.h>
  45
  46
  47 int getpeereid( int s, uid_t *euid, gid_t *egid )
  48 {
  49 #ifdef LDAP_PF_LOCAL
  50 #if defined( SO_PEERCRED )
  51         struct ucred peercred;
  52         socklen_t peercredlen = sizeof peercred;
  53
  54         if(( getsockopt( s, SOL_SOCKET, SO_PEERCRED,
  55                 (void *)&peercred, &peercredlen ) == 0 )
  56                 && ( peercredlen == sizeof peercred ))
  57         {
  58                 *euid = peercred.uid;
  59                 *egid = peercred.gid;
  60                 return 0;
  61         }
  62
  63 #elif defined( LOCAL_PEERCRED )
  64         struct xucred peercred;
  65         socklen_t peercredlen = sizeof peercred;
  66
  67         if(( getsockopt( s, LOCAL_PEERCRED, 1,
  68                 (void *)&peercred, &peercredlen ) == 0 )
  69                 && ( peercred.cr_version == XUCRED_VERSION ))
  70         {
  71                 *euid = peercred.cr_uid;
  72                 *egid = peercred.cr_gid;
  73                 return 0;
  74         }
  75 #elif defined( DO_SENDMSG )
  76         char dummy[8];
  77         int err, fd[2];
  78         struct iovec iov;
  79         struct msghdr msg = {0};
  80 # ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
  81 # ifndef CMSG_SPACE
  82 # define CMSG_SPACE(len)        (_CMSG_ALIGN(sizeof(struct cmsghdr)) + _CMSG_ALIGN(len))
  83 # endif
  84 # ifndef CMSG_LEN
  85 # define CMSG_LEN(len)          (_CMSG_ALIGN(sizeof(struct cmsghdr)) + (len))
  86 # endif
  87         union {
  88                 struct cmsghdr cm;
  89                 unsigned char control[CMSG_SPACE(sizeof(int))];
  90         } control_un;
  91         struct cmsghdr *cmsg;
  92 # endif /* HAVE_STRUCT_MSGHDR_MSG_CONTROL */
  93         struct stat st;
  94
  95         msg.msg_name = NULL;
  96         msg.msg_namelen = 0;
  97
  98         iov.iov_base = dummy;
  99         iov.iov_len = sizeof dummy;
 100         msg.msg_iov = &iov;
 101         msg.msg_iovlen = 1;
 102 # ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
 103         msg.msg_control = control_un.control;
 104         msg.msg_controllen = sizeof( control_un.control );
 105
 106         cmsg = CMSG_FIRSTHDR( &msg );
 107
 108         /*
 109          * AIX returns a bogus file descriptor if recvmsg() is
 110          * called with MSG_PEEK (is this a bug?). Hence we need
 111          * to receive the Abandon PDU.
 112          */
 113         if( recvmsg( s, &msg, MSG_WAITALL ) >= 0 &&
 114             cmsg->cmsg_len == CMSG_LEN( sizeof(int) ) &&
 115             cmsg->cmsg_level == SOL_SOCKET &&
 116             cmsg->cmsg_type == SCM_RIGHTS )
 117 # else
 118         msg.msg_accrights = (char *)fd;
 119         msg.msg_accrightslen = sizeof(fd);
 120         if( recvmsg( s, &msg, MSG_PEEK) >= 0 && msg.msg_accrightslen == sizeof(int) )
 121 # endif /* HAVE_STRUCT_MSGHDR_MSG_CONTROL*/
 122         {
 123                 /* We must receive a valid descriptor, it must be a pipe,
 124                  * and it must only be accessible by its owner.
 125                  */
 126 # ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
 127                 fd[0] = (*(int *)CMSG_DATA( cmsg ));
 128 # endif
 129                 err = fstat( fd[0], &st );
 130                 close(fd[0]);
 131                 if( err == 0 && S_ISFIFO(st.st_mode) &&
 132                         ((st.st_mode & (S_IRWXG|S_IRWXO)) == 0))
 133                 {
 134                         *euid = st.st_uid;
 135                         *egid = st.st_gid;
 136                         return 0;
 137                 }
 138         }
 139 #elif defined(SOCKCREDSIZE)
 140         struct msghdr msg;
 141         socklen_t crmsgsize;
 142         void *crmsg;
 143         struct cmsghdr *cmp;
 144         struct sockcred *sc;
 145
 146         memset(&msg, 0, sizeof msg);
 147         crmsgsize = CMSG_SPACE(SOCKCREDSIZE(NGROUPS));
 148         if (crmsgsize == 0) goto sc_err;
 149         crmsg = malloc(crmsgsize);
 150         if (crmsg == NULL) goto sc_err;
 151         memset(crmsg, 0, crmsgsize);
 152
 153         msg.msg_control = crmsg;
 154         msg.msg_controllen = crmsgsize;
 155
 156         if (recvmsg(s, &msg, 0) < 0) {
 157                 free(crmsg);
 158                 goto sc_err;
 159         }
 160
 161         if (msg.msg_controllen == 0 || (msg.msg_flags & MSG_CTRUNC) != 0) {
 162                 free(crmsg);
 163                 goto sc_err;
 164         }
 165
 166         cmp = CMSG_FIRSTHDR(&msg);
 167         if (cmp->cmsg_level != SOL_SOCKET || cmp->cmsg_type != SCM_CREDS) {
 168                 printf("nocreds\n");
 169                 goto sc_err;
 170         }
 171
 172         sc = (struct sockcred *)(void *)CMSG_DATA(cmp);
 173
 174         *euid = sc->sc_euid;
 175         *egid = sc->sc_egid;
 176
 177         free(crmsg);
 178         return 0;
 179
 180 sc_err:
 181 #endif
 182 #endif /* LDAP_PF_LOCAL */
 183
 184         return -1;
 185 }
 186
 187 #endif /* HAVE_GETPEEREID */