src/rmr/si/src/si95/siestablish.c

   1 // vim: noet sw=4 ts=4:
   2 /*
   3 ==================================================================================
   4     Copyright (c) 2020 Nokia
   5     Copyright (c) 2020 AT&T Intellectual Property.
   6
   7    Licensed under the Apache License, Version 2.0 (the "License");
   8    you may not use this file except in compliance with the License.
   9    You may obtain a copy of the License at
  10
  11        http://www.apache.org/licenses/LICENSE-2.0
  12
  13    Unless required by applicable law or agreed to in writing, software
  14    distributed under the License is distributed on an "AS IS" BASIS,
  15    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16    See the License for the specific language governing permissions and
  17    limitations under the License.
  18 ==================================================================================
  19 */
  20
  21
  22 /*
  23 *-----------------------------------------------------------------------------------
  24 *
  25 * Mnemonic:             SIestablish
  26 * Abstract:i    Prep functions that set up a socket for listening or making a
  27 *                               connection.
  28 * Date:                 26 March 1995
  29 * Author:               E. Scott Daniels
  30 *
  31 * Modified:     19 Apr 1995 - To keep returned address of the port.
  32 *                               08 Mar 2007 - conversion for ipv6.
  33 *                               12 Oct 2020 - split into connect prep and listen prep
  34 *                                                               functions.
  35 *-----------------------------------------------------------------------------------
  36 */
  37
  38
  39 #include "sisetup.h"       //  include the necessary setup stuff
  40 #include "sitransport.h"
  41 #include <errno.h>
  42 #include <netinet/tcp.h>
  43
  44 #ifndef SO_REUSEPORT
  45 #define SO_REUSEPORT 0
  46 #endif
  47
  48 /*
  49         Prep a socket for "listening."
  50         This routine will open a socket and bind an address to it in
  51         preparation for listening for connections or inbound UDP
  52         datagrams. A file descriptor for the socket is captured and all
  53         related information is placed into a transport provider (tp) block.
  54
  55         Type is the SI constant UDP_DEVICE or TCP_DEVICE
  56         abuf points to the address that is to be bound to the socket.
  57         Family is one of the AF_* constants (AF_ANY, AF_INET or AF_INET6)
  58
  59         The address should be one of these forms:
  60                         [::1]:port                         v6 localhost device (loop back)
  61                         localhost:port             v4 or 6 loopback depending on /etc/hosts
  62                         0.0.0.0:port               any interface
  63                         addr:port                          an address assigned to one of the devices
  64
  65         Returns a transport struct which is the main context for the listener.
  66 */
  67 extern struct tp_blk *SIlisten_prep( int type, char* abuf, int family ) {
  68         struct tp_blk *tptr;        //  pointer at new tp block
  69         struct sockaddr *addr;          //  IP address we are requesting
  70         int optval = 0;
  71         int alen = 0;
  72         int status = SI_OK;          //  processing status
  73         int protocol;                //  protocol for socket call
  74
  75         tptr = (struct tp_blk *) SInew( TP_BLK );     // transport info
  76
  77         if( tptr != NULL ) {
  78                 addr = NULL;
  79
  80                 if( type == UDP_DEVICE ) {
  81                         tptr->type = SOCK_DGRAM;
  82                         protocol = IPPROTO_UDP;
  83                 } else {
  84                         tptr->type = SOCK_STREAM;
  85                         protocol = IPPROTO_TCP;
  86                 }
  87
  88                 alen = SIgenaddr( abuf, protocol, family, tptr->type, &addr );  //  family == 0 for type that suits the address passed in
  89                 if( alen <= 0 ) {
  90                         if( addr != NULL ) {
  91                                 free( addr );           // not needed, but scanners complain if we don't overtly do this
  92                         }
  93                         return NULL;
  94                 }
  95
  96                 tptr->family = addr->sa_family;
  97
  98                 if( (tptr->fd = SOCKET( tptr->family, tptr->type, protocol )) >= SI_OK ) {
  99                         optval = 1;
 100                         if( SO_REUSEPORT ) {
 101                                 SETSOCKOPT(tptr->fd, SOL_SOCKET, SO_REUSEPORT, (char *)&optval, sizeof( optval) ) ;
 102                         }
 103
 104                         status = BIND( tptr->fd, (struct sockaddr *) addr, alen );
 105                         if( status == SI_OK ) {
 106                                 tptr->addr = addr;                      //  save address
 107                         } else {
 108                                 fprintf( stderr, "<ERR> siestablish: bind failed: fam=%d type=%d pro=%d %s\n", tptr->family, tptr->type, protocol, strerror( errno ) );
 109                                 close( tptr->fd );
 110                         }
 111                 } else {
 112                         status = ! SI_OK;                               //  force bad return later
 113                         fprintf( stderr, "<ERR> siestablish: socket not esablished: fam=%d type=%d pro=%d %s\n", tptr->family, tptr->type, protocol, strerror( errno ) );
 114                 }
 115
 116                 if( status != SI_OK ) {                         //  socket or bind call failed - clean up stuff
 117                         fprintf( stderr, "<ERR> siestablish: bad state -- returning nil pointer\n" );
 118                         free( addr );
 119                         SItrash( TP_BLK, tptr );        //  free the trasnsport block
 120                         tptr = NULL;                            //  set to return nothing
 121                 }
 122         }
 123
 124         return tptr;
 125 }
 126
 127 /*
 128         Look at the address and determine if the connect attempt to this address must
 129         use safe_connect() rather than the system connect() call. On linux, a smart
 130         connect is needed if the target port is >32K and is even. This makes the assumption
 131         that the local port rage floor is 32K; we could read something in /proc, but
 132         at this point won't bother.  Returns true if we determine that it is best to
 133         use safe_connect().
 134 */
 135 static int need_smartc( char* abuf ) {
 136         char*   tok;
 137         int             state = 1;
 138         int             v;
 139
 140         if( (tok = strchr( abuf, ':')) != NULL ) {
 141                 v = atoi( tok+1 );
 142                 if( v < 32767  || v % 2 != 0 ) {
 143                         state = 0;
 144                 }
 145         }
 146
 147         return state;
 148 }
 149
 150 /*
 151         Prep a socket to use to connect to a listener.
 152         Establish a transport block and target address in prep to connect.
 153         Type is the SI constant UDP_DEVICE or TCP_DEVICE. The abuf pointer
 154         should point to either a name:port or IP:port string. Family should
 155         be 0 to select the family best suited to the address provided, or
 156         any (v4 or v6) if the address is a name. If a perticular type is
 157         desired family should be either AF_INET or AF_INET6.  Using a
 158         family of 0 (AF_ANY) is usually the best choice.
 159 */
 160 extern struct tp_blk *SIconn_prep( struct ginfo_blk *gptr, int type, char *abuf, int family ) {
 161         struct tp_blk *tptr;         //  pointer at new tp block
 162         struct sockaddr *addr;          //  IP address we are requesting
 163         int protocol;                //  protocol for socket call
 164         char buf[256];               //  buffer to build request address in
 165         int optval = 0;
 166         int alen = 0;
 167
 168         tptr = (struct tp_blk *) SInew( TP_BLK );     //  new transport info block
 169
 170         if( tptr != NULL )
 171         {
 172                 addr = NULL;
 173
 174                 switch( type )                  //  things specifc to tcp or udp
 175                 {
 176                         case UDP_DEVICE:
 177                                 tptr->type = SOCK_DGRAM;
 178                                 protocol = IPPROTO_UDP;
 179                                 break;
 180
 181                         case TCP_DEVICE:
 182                         default:
 183                                 tptr->type = SOCK_STREAM;
 184                                 protocol = IPPROTO_TCP;
 185                 }
 186
 187                 alen = SIgenaddr( abuf, protocol, family, tptr->type, &addr );  //  family == 0 for type that suits the address passed in
 188                 if( alen <= 0 ) {
 189                         if( addr != NULL ) {            // not needed, but scanners complain if we don't overtly do this
 190                                 free( addr );
 191                         }
 192                         return NULL;
 193                 }
 194
 195                 tptr->family = addr->sa_family;
 196                 tptr->palen = alen;
 197
 198                 if( (tptr->fd = SOCKET( tptr->family, tptr->type, protocol )) >= SI_OK ) {
 199                         optval = 1;
 200
 201                         if( gptr->tcp_flags & SI_TF_NODELAY ) {
 202                                 optval = 1;
 203                         } else {
 204                                 optval = 0;
 205                         }
 206                         SETSOCKOPT( tptr->fd, SOL_TCP, TCP_NODELAY, (void *)&optval, sizeof( optval) ) ;
 207
 208                         if( gptr->tcp_flags & SI_TF_FASTACK ) {
 209                                 optval = 1;
 210                         } else {
 211                                 optval = 0;
 212                         }
 213                         SETSOCKOPT( tptr->fd, SOL_TCP, TCP_QUICKACK, (void *)&optval, sizeof( optval) ) ;
 214
 215                         tptr->paddr = addr;                             // tuck the remote peer address away
 216                         if( need_smartc( abuf ) ) {
 217                                 tptr->flags |= TPF_SAFEC;
 218                         }
 219                 } else {
 220                         free( addr );
 221                         SItrash( TP_BLK, tptr );                // free the trasnsport block
 222                         tptr = NULL;                                    // we'll return nil
 223                 }
 224         }
 225
 226         return tptr;
 227 }