usr/src/lib/libsocket/socket/weaks.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 /* Copyright (c) 2013, OmniTI Computer Consulting, Inc. All rights reserved. */
  28
  29 #include <sys/types.h>
  30 #include <sys/socket.h>
  31 #include <sys/stropts.h>
  32 #include <sys/stream.h>
  33 #include <sys/socketvar.h>
  34 #include <sys/sockio.h>
  35
  36 #include <errno.h>
  37 #include <stdlib.h>
  38 #include <unistd.h>
  39 #include <stropts.h>
  40 #include <stdio.h>
  41 #include <strings.h>
  42 #include <netinet/sctp.h>
  43
  44 #pragma weak bind = _bind
  45 #pragma weak listen = _listen
  46 #pragma weak accept = _accept
  47 #pragma weak accept4 = _accept4
  48 #pragma weak connect = _connect
  49 #pragma weak shutdown = _shutdown
  50 #pragma weak recv = _recv
  51 #pragma weak recvfrom = _recvfrom
  52 #pragma weak recvmsg = _recvmsg
  53 #pragma weak send = _send
  54 #pragma weak sendmsg = _sendmsg
  55 #pragma weak sendto = _sendto
  56 #pragma weak getpeername = _getpeername
  57 #pragma weak getsockname = _getsockname
  58 #pragma weak getsockopt = _getsockopt
  59 #pragma weak setsockopt = _setsockopt
  60
  61 extern int _so_bind();
  62 extern int _so_listen();
  63 extern int _so_accept();
  64 extern int _so_connect();
  65 extern int _so_shutdown();
  66 extern int _so_recv();
  67 extern int _so_recvfrom();
  68 extern int _so_recvmsg();
  69 extern int _so_send();
  70 extern int _so_sendmsg();
  71 extern int _so_sendto();
  72 extern int _so_getpeername();
  73 extern int _so_getsockopt();
  74 extern int _so_setsockopt();
  75 extern int _so_getsockname();
  76
  77 /*
  78  * Note that regular sockets use SOV_SOCKBSD here to not allow a rebind of an
  79  * already bound socket.
  80  */
  81 int
  82 _bind(int sock, struct sockaddr *addr, int addrlen)
  83 {
  84         return (_so_bind(sock, addr, addrlen, SOV_SOCKBSD));
  85 }
  86
  87 int
  88 _listen(int sock, int backlog)
  89 {
  90         return (_so_listen(sock, backlog, SOV_DEFAULT));
  91 }
  92
  93 int
  94 _accept(int sock, struct sockaddr *addr, int *addrlen)
  95 {
  96         return (_so_accept(sock, addr, addrlen, SOV_DEFAULT, 0));
  97 }
  98
  99 int
 100 _accept4(int sock, struct sockaddr *addr, int *addrlen, int flags)
 101 {
 102         return (_so_accept(sock, addr, addrlen, SOV_DEFAULT, flags));
 103 }
 104
 105 int
 106 _connect(int sock, struct sockaddr *addr, int addrlen)
 107 {
 108         return (_so_connect(sock, addr, addrlen, SOV_DEFAULT));
 109 }
 110
 111 int
 112 _shutdown(int sock, int how)
 113 {
 114         return (_so_shutdown(sock, how, SOV_DEFAULT));
 115 }
 116
 117 int
 118 _recv(int sock, char *buf, int len, int flags)
 119 {
 120         return (_so_recv(sock, buf, len, flags & ~MSG_XPG4_2));
 121 }
 122
 123 int
 124 _recvfrom(int sock, char *buf, int len, int flags,
 125         struct sockaddr *addr, int *addrlen)
 126 {
 127         return (_so_recvfrom(sock, buf, len, flags & ~MSG_XPG4_2,
 128             addr, addrlen));
 129 }
 130
 131 int
 132 _recvmsg(int sock, struct msghdr *msg, int flags)
 133 {
 134         return (_so_recvmsg(sock, msg, flags & ~MSG_XPG4_2));
 135 }
 136
 137 int
 138 _send(int sock, char *buf, int len, int flags)
 139 {
 140         return (_so_send(sock, buf, len, flags & ~MSG_XPG4_2));
 141 }
 142
 143 int
 144 _sendmsg(int sock, struct msghdr *msg, int flags)
 145 {
 146         return (_so_sendmsg(sock, msg, flags & ~MSG_XPG4_2));
 147 }
 148
 149 int
 150 _sendto(int sock, char *buf, int len, int flags,
 151         struct sockaddr *addr, int *addrlen)
 152 {
 153         return (_so_sendto(sock, buf, len, flags & ~MSG_XPG4_2,
 154             addr, addrlen));
 155 }
 156
 157 int
 158 _getpeername(int sock, struct sockaddr *name, int *namelen)
 159 {
 160         return (_so_getpeername(sock, name, namelen, SOV_DEFAULT));
 161 }
 162
 163 int
 164 _getsockname(int sock, struct sockaddr *name, int *namelen)
 165 {
 166         return (_so_getsockname(sock, name, namelen, SOV_DEFAULT));
 167 }
 168
 169 int
 170 _getsockopt(int sock, int level, int optname, char *optval, int *optlen)
 171 {
 172         if (level == IPPROTO_SCTP) {
 173                 sctp_assoc_t id = 0;
 174                 socklen_t len = *optlen;
 175                 int err = 0;
 176                 struct sctpopt sopt;
 177
 178                 switch (optname) {
 179                 case SCTP_RTOINFO:
 180                 case SCTP_ASSOCINFO:
 181                 case SCTP_SET_PEER_PRIMARY_ADDR:
 182                 case SCTP_PRIMARY_ADDR:
 183                 case SCTP_PEER_ADDR_PARAMS:
 184                 case SCTP_STATUS:
 185                 case SCTP_GET_PEER_ADDR_INFO:
 186                         /*
 187                          * Association ID is the first element params struct
 188                          */
 189                         bcopy(optval, &id, sizeof (id));
 190                         break;
 191                 case SCTP_DEFAULT_SEND_PARAM:
 192                         bcopy(&((struct sctp_sndrcvinfo *)
 193                             optval)->sinfo_assoc_id, &id, sizeof (id));
 194                         break;
 195                 }
 196
 197                 sopt.sopt_aid = id;
 198                 sopt.sopt_name = optname;
 199                 sopt.sopt_val = optval;
 200                 sopt.sopt_len = len;
 201                 if (ioctl(sock, SIOCSCTPGOPT, &sopt) == -1) {
 202                         err = -1;
 203                 } else {
 204                         *optlen = sopt.sopt_len;
 205                 }
 206                 return (err);
 207         } else {
 208                 return (_so_getsockopt(sock, level, optname, optval, optlen,
 209                     SOV_DEFAULT));
 210         }
 211 }
 212
 213 int
 214 _setsockopt(int sock, int level, int optname, char *optval, int optlen)
 215 {
 216         return (_so_setsockopt(sock, level, optname, optval, optlen,
 217             SOV_DEFAULT));
 218 }
 219
 220 int
 221 __xnet_bind(int sock, const struct sockaddr *addr, socklen_t addrlen)
 222 {
 223         return (_so_bind(sock, addr, addrlen, SOV_XPG4_2));
 224 }
 225
 226
 227 int
 228 __xnet_listen(int sock, int backlog)
 229 {
 230         return (_so_listen(sock, backlog, SOV_XPG4_2));
 231 }
 232
 233 int
 234 __xnet_connect(int sock, const struct sockaddr *addr, socklen_t addrlen)
 235 {
 236         return (_so_connect(sock, addr, addrlen, SOV_XPG4_2));
 237 }
 238
 239 int
 240 __xnet_recvmsg(int sock, struct msghdr *msg, int flags)
 241 {
 242         return (_so_recvmsg(sock, msg, flags | MSG_XPG4_2));
 243 }
 244
 245 int
 246 __xnet_sendmsg(int sock, const struct msghdr *msg, int flags)
 247 {
 248         return (_so_sendmsg(sock, msg, flags | MSG_XPG4_2));
 249 }
 250
 251 int
 252 __xnet_sendto(int sock, const void *buf, size_t len, int flags,
 253         const struct sockaddr *addr, socklen_t addrlen)
 254 {
 255         return (_so_sendto(sock, buf, len, flags | MSG_XPG4_2,
 256             addr, addrlen));
 257 }
 258
 259 int
 260 __xnet_getsockopt(int sock, int level, int option_name,
 261         void *option_value, socklen_t *option_lenp)
 262 {
 263         if (level == IPPROTO_SCTP) {
 264                 return (_getsockopt(sock, level, option_name, option_value,
 265                     (int *)option_lenp));
 266         } else {
 267                 return (_so_getsockopt(sock, level, option_name, option_value,
 268                     option_lenp, SOV_XPG4_2));
 269         }
 270 }