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

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