ACE/ace/TLI.cpp

   1 // Defines the member functions for the base class of the ACE_TLI
   2 // abstraction.
   3
   4 #include "ace/TLI.h"
   5 #include "ace/Log_Category.h"
   6 #include "ace/OS_Memory.h"
   7 #include "ace/OS_TLI.h"
   8 #include "ace/OS_NS_string.h"
   9 #include "ace/OS_NS_sys_socket.h"
  10 #include "ace/Auto_Ptr.h"
  11
  12
  13
  14 #if defined (ACE_HAS_TLI)
  15
  16 #if !defined (__ACE_INLINE__)
  17 #include "ace/TLI.inl"
  18 #endif /* __ACE_INLINE__ */
  19
  20 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  21
  22 ACE_ALLOC_HOOK_DEFINE(ACE_TLI)
  23
  24 void
  25 ACE_TLI::dump (void) const
  26 {
  27 #if defined (ACE_HAS_DUMP)
  28   ACE_TRACE ("ACE_TLI::dump");
  29 #endif /* ACE_HAS_DUMP */
  30 }
  31
  32 ACE_TLI::ACE_TLI (void)
  33 {
  34   ACE_TRACE ("ACE_TLI::ACE_TLI");
  35 #if defined (ACE_HAS_SVR4_TLI)
  36 // Solaris 2.4 ACE_TLI option handling is broken.  Thus, we must do
  37 // the memory allocation ourselves...  Thanks to John P. Hearn
  38 // (jph@ccrl.nj.nec.com) for the help.
  39
  40   this->so_opt_req.opt.maxlen = sizeof (opthdr) + sizeof (long);
  41   ACE_NEW (this->so_opt_req.opt.buf,
  42            char[this->so_opt_req.opt.maxlen]);
  43
  44   this->so_opt_ret.opt.maxlen = sizeof (opthdr) + sizeof (long);
  45   ACE_NEW (this->so_opt_ret.opt.buf,
  46            char[this->so_opt_ret.opt.maxlen]);
  47
  48   if (this->so_opt_ret.opt.buf == 0)
  49     {
  50       delete [] this->so_opt_req.opt.buf;
  51       this->so_opt_req.opt.buf = 0;
  52     }
  53 #endif /* ACE_HAS_SVR4_TLI */
  54 }
  55
  56 ACE_HANDLE
  57 ACE_TLI::open (const char device[], int oflag, struct t_info *info)
  58 {
  59   ACE_TRACE ("ACE_TLI::open");
  60   if (oflag == 0)
  61     oflag = O_RDWR;
  62   this->set_handle (ACE_OS::t_open ((char *) device, oflag, info));
  63
  64   return this->get_handle ();
  65 }
  66
  67 ACE_TLI::~ACE_TLI (void)
  68 {
  69   ACE_TRACE ("ACE_TLI::~ACE_TLI");
  70 #if defined (ACE_HAS_SVR4_TLI)
  71   if (this->so_opt_req.opt.buf)
  72     {
  73       delete [] this->so_opt_req.opt.buf;
  74       delete [] this->so_opt_ret.opt.buf;
  75       this->so_opt_req.opt.buf = 0;
  76       this->so_opt_ret.opt.buf = 0;
  77     }
  78 #endif /* ACE_HAS_SVR4_TLI */
  79 }
  80
  81 ACE_TLI::ACE_TLI (const char device[], int oflag, struct t_info *info)
  82 {
  83   ACE_TRACE ("ACE_TLI::ACE_TLI");
  84   if (this->open (device, oflag, info) == ACE_INVALID_HANDLE)
  85     ACELIB_ERROR ((LM_ERROR,
  86                 ACE_TEXT ("%p\n"),
  87                 ACE_TEXT ("ACE_TLI::ACE_TLI")));
  88 }
  89
  90 int
  91 ACE_TLI::get_local_addr (ACE_Addr &sa) const
  92 {
  93   ACE_TRACE ("ACE_TLI::get_local_addr");
  94   struct netbuf name;
  95
  96   name.maxlen = sa.get_size ();
  97   name.buf    = (char *) sa.get_addr ();
  98
  99   if (ACE_OS::t_getname (this->get_handle (), &name, LOCALNAME) == -1)
 100     return -1;
 101   else
 102     return 0;
 103 }
 104
 105 int
 106 ACE_TLI::close (void)
 107 {
 108   ACE_TRACE ("ACE_TLI::close");
 109   int result = 0; // Geisler: result must be int
 110
 111   if (this->get_handle () != ACE_INVALID_HANDLE)
 112     {
 113       result = ACE_OS::t_close (this->get_handle ());
 114       this->set_handle (ACE_INVALID_HANDLE);
 115     }
 116   return result;
 117 }
 118
 119 int
 120 ACE_TLI::set_option (int level, int option, void *optval, int optlen)
 121 {
 122   /* Set up options for ACE_TLI */
 123   ACE_TRACE ("ACE_TLI::set_option");
 124
 125 #if defined (ACE_HAS_XTI)
 126   // ret will get the negotiated option back after attempting to set it.
 127   // Assume this will fit in the requested size.
 128   struct t_optmgmt req, ret;
 129   ACE_NEW_RETURN (req.opt.buf, char[sizeof (struct t_opthdr) + optlen], -1);
 130 #  if (_XOPEN_SOURCE - 0 >= 500)
 131   auto_ptr<char> req_opt_buf_p (reinterpret_cast<char*> (req.opt.buf));
 132 #  else
 133   ACE_Auto_Array_Ptr<char> req_opt_buf_p (req.opt.buf);
 134 #  endif /* XPG5 vs XPG4 */
 135   struct t_opthdr *opthdr =
 136     reinterpret_cast<struct t_opthdr *> (req.opt.buf);
 137   ACE_NEW_RETURN (ret.opt.buf, char[sizeof (struct t_opthdr) + optlen], -1);
 138 #  if (_XOPEN_SOURCE - 0 >= 500)
 139   auto_ptr<char> ret_opt_buf_p (reinterpret_cast<char*> (ret.opt.buf));
 140 #  else
 141   ACE_Auto_Array_Ptr<char> ret_opt_buf_p (ret.opt.buf);
 142 #  endif /* XPG5 vs XPG4 */
 143
 144   req.flags = T_NEGOTIATE;
 145   req.opt.len = sizeof *opthdr + optlen;
 146   ret.opt.maxlen = req.opt.len;
 147   opthdr->level = level;
 148   opthdr->name  = option;
 149   opthdr->len   = req.opt.len;   // We only request one option at a time.
 150   ACE_OS::memcpy (&opthdr[1], optval, optlen);
 151   return ACE_OS::t_optmgmt (this->get_handle (), &req, &ret);
 152
 153 #elif defined (ACE_HAS_SVR4_TLI)
 154   struct opthdr *opthdr = 0; /* See <sys/socket.h> for info on this format */
 155
 156   this->so_opt_req.flags = T_NEGOTIATE;
 157   this->so_opt_req.opt.len = sizeof *opthdr + OPTLEN (optlen);
 158
 159   if (this->so_opt_req.opt.len > this->so_opt_req.opt.maxlen)
 160     {
 161 #  if !defined (ACE_HAS_SET_T_ERRNO)
 162       t_errno = TBUFOVFLW;
 163 #  else
 164       set_t_errno (TBUFOVFLW);
 165 #  endif /* ACE_HAS_SET_T_ERRNO */
 166       return -1;
 167     }
 168
 169   opthdr = reinterpret_cast<struct opthdr *> (this->so_opt_req.opt.buf);
 170   opthdr->level = level;
 171   opthdr->name  = option;
 172   opthdr->len   = OPTLEN (optlen);
 173   ACE_OS::memcpy (OPTVAL (opthdr), optval, optlen);
 174
 175   return ACE_OS::t_optmgmt (this->get_handle (),
 176                             &this->so_opt_req,
 177                             &this->so_opt_ret);
 178 #else
 179   ACE_UNUSED_ARG (level);
 180   ACE_UNUSED_ARG (option);
 181   ACE_UNUSED_ARG (optval);
 182   ACE_UNUSED_ARG (optlen);
 183   return -1;
 184 #endif /* ACE_HAS_XTI, else ACE_HAS_SVR4_TLI */
 185 }
 186
 187 int
 188 ACE_TLI::get_option (int level, int option, void *optval, int &optlen)
 189 {
 190   ACE_TRACE ("ACE_TLI::get_option");
 191 #if defined (ACE_HAS_XTI)
 192   // ret will get the option requested in req.
 193   struct t_optmgmt req, ret;
 194   ACE_NEW_RETURN (req.opt.buf, char[sizeof (struct t_opthdr)], -1);
 195 #  if (_XOPEN_SOURCE - 0 >= 500)
 196   auto_ptr<char> req_opt_buf_p (reinterpret_cast<char*> (req.opt.buf));
 197 #  else
 198   ACE_Auto_Array_Ptr<char> req_opt_buf_p (req.opt.buf);
 199 #  endif /* XPG5 vs XPG4 */
 200   struct t_opthdr *opthdr =
 201     reinterpret_cast<struct t_opthdr *> (req.opt.buf);
 202   ACE_NEW_RETURN (ret.opt.buf, char[sizeof (struct t_opthdr) + optlen], -1);
 203 #  if (_XOPEN_SOURCE - 0 >= 500)
 204   auto_ptr<char> ret_opt_buf_p (reinterpret_cast<char*> (ret.opt.buf));
 205 #  else
 206   ACE_Auto_Array_Ptr<char> ret_opt_buf_p (ret.opt.buf);
 207 #  endif /* XPG5 vs XPG4 */
 208
 209   req.flags = T_CURRENT;
 210   req.opt.len = sizeof *opthdr;
 211   ret.opt.maxlen = sizeof (struct t_opthdr) + optlen;
 212   opthdr->level = level;
 213   opthdr->name  = option;
 214   opthdr->len   = sizeof (*opthdr);    // Just the header on the request
 215   if (ACE_OS::t_optmgmt (this->get_handle (), &req, &ret) == -1)
 216     return -1;
 217   else
 218     {
 219       opthdr = reinterpret_cast<struct t_opthdr *> (ret.opt.buf);
 220       if (opthdr->status == T_NOTSUPPORT)
 221         {
 222           errno = ENOTSUP;
 223           return -1;
 224         }
 225       else
 226         {
 227           ACE_OS::memcpy (optval, &opthdr[1], optlen);
 228           return 0;
 229         }
 230     }
 231
 232 #elif defined (ACE_HAS_SVR4_TLI)
 233   struct opthdr *opthdr = 0; /* See <sys/socket.h> for details on this format */
 234
 235   this->so_opt_req.flags = T_CHECK;
 236   this->so_opt_ret.opt.len = sizeof *opthdr + OPTLEN (optlen);
 237
 238   if (this->so_opt_ret.opt.len > this->so_opt_ret.opt.maxlen)
 239     {
 240 #if !defined (ACE_HAS_SET_T_ERRNO)
 241       t_errno = TBUFOVFLW;
 242 #else
 243       set_t_errno (TBUFOVFLW);
 244 #endif /* ACE_HAS_SET_T_ERRNO */
 245       return -1;
 246     }
 247
 248   opthdr        = (struct opthdr *) this->so_opt_req.opt.buf;
 249   opthdr->level = level;
 250   opthdr->name  = option;
 251   opthdr->len   = OPTLEN (optlen);
 252   if (ACE_OS::t_optmgmt (this->get_handle (), &this->so_opt_req, &this->so_opt_ret) == -1)
 253     return -1;
 254   else
 255     {
 256       ACE_OS::memcpy (optval, OPTVAL (opthdr), optlen);
 257       return 0;
 258     }
 259 #else
 260   ACE_UNUSED_ARG (level);
 261   ACE_UNUSED_ARG (option);
 262   ACE_UNUSED_ARG (optval);
 263   ACE_UNUSED_ARG (optlen);
 264   return -1;
 265 #endif /* ACE_HAS_SVR4_TLI */
 266 }
 267
 268 ACE_END_VERSIONED_NAMESPACE_DECL
 269
 270 #endif /* ACE_HAS_TLI */