ACE/ace/OS_TLI.inl

   1 // -*- C++ -*-
   2 #include "ace/OS_NS_errno.h"
   3
   4 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
   5
   6 namespace ACE_OS {
   7
   8 ACE_INLINE int
   9 t_accept (ACE_HANDLE handle, ACE_HANDLE reshandle, struct t_call *call)
  10 {
  11 #if defined (ACE_HAS_TLI)
  12   return ::t_accept (handle, reshandle, call);
  13 #else
  14   ACE_UNUSED_ARG (call);
  15   ACE_UNUSED_ARG (reshandle);
  16   ACE_UNUSED_ARG (handle);
  17
  18   ACE_NOTSUP_RETURN (-1);
  19 #endif /* ACE_HAS_TLI */
  20 }
  21
  22 ACE_INLINE char *
  23 t_alloc (ACE_HANDLE handle, int struct_type, int fields)
  24 {
  25 #if defined (ACE_HAS_TLI)
  26 #  if (defined _XOPEN_SOURCE && (_XOPEN_SOURCE - 0) >= 500)
  27   // XPG5 changes t_alloc() return from char* to void*, so ACE_OSCALL_RETURN
  28   // doesn't compile correctly.
  29   char *result;
  30   ACE_OSCALL (::t_alloc (handle, struct_type, fields), char *, result);
  31   return result;
  32 #  else
  33   return ::t_alloc (handle, struct_type, fields);
  34 #  endif /* XPG4 vs XPG5 */
  35 #else
  36   ACE_UNUSED_ARG (fields);
  37   ACE_UNUSED_ARG (struct_type);
  38   ACE_UNUSED_ARG (handle);
  39
  40   ACE_NOTSUP_RETURN (0);
  41 #endif /* ACE_HAS_TLI */
  42 }
  43
  44 ACE_INLINE int
  45 t_bind (ACE_HANDLE handle, ACE_TBIND *req, ACE_TBIND *ret)
  46 {
  47 #if defined (ACE_HAS_TLI)
  48   return ::t_bind (handle, req, ret);
  49 #else
  50   ACE_UNUSED_ARG (ret);
  51   ACE_UNUSED_ARG (req);
  52   ACE_UNUSED_ARG (handle);
  53
  54   ACE_NOTSUP_RETURN (-1);
  55 #endif /* ACE_HAS_TLI */
  56 }
  57
  58 ACE_INLINE int
  59 t_close (ACE_HANDLE handle)
  60 {
  61 #if defined (ACE_HAS_TLI)
  62   return ::t_close (handle);
  63 #else
  64   ACE_UNUSED_ARG (handle);
  65
  66   ACE_NOTSUP_RETURN (-1);
  67 #endif /* ACE_HAS_TLI */
  68 }
  69
  70 ACE_INLINE int
  71 t_connect(ACE_HANDLE fildes,
  72           struct t_call *sndcall,
  73           struct t_call *rcvcall)
  74 {
  75 #if defined (ACE_HAS_TLI)
  76   return ::t_connect (fildes, sndcall, rcvcall);
  77 #else
  78   ACE_UNUSED_ARG (fildes);
  79   ACE_UNUSED_ARG (sndcall);
  80   ACE_UNUSED_ARG (rcvcall);
  81
  82   ACE_NOTSUP_RETURN (-1);
  83 #endif /* ACE_HAS_TLI */
  84 }
  85
  86 ACE_INLINE void
  87 t_error (const char *errmsg)
  88 {
  89 #if defined (ACE_HAS_TLI)
  90   ::t_error (errmsg);
  91 #else
  92   ACE_UNUSED_ARG (errmsg);
  93 #endif /* ACE_HAS_TLI */
  94 }
  95
  96 ACE_INLINE int
  97 t_free (char *ptr, int struct_type)
  98 {
  99 #if defined (ACE_HAS_TLI)
 100   if (!ptr)
 101     return 0;
 102   return ::t_free (ptr, struct_type);
 103 #else
 104   ACE_UNUSED_ARG (struct_type);
 105   ACE_UNUSED_ARG (ptr);
 106
 107   ACE_NOTSUP_RETURN (-1);
 108 #endif /* ACE_HAS_TLI */
 109 }
 110
 111 ACE_INLINE int
 112 t_getinfo (ACE_HANDLE handle, struct t_info *info)
 113 {
 114 #if defined (ACE_HAS_TLI)
 115   return ::t_getinfo (handle, info);
 116 #else
 117   ACE_UNUSED_ARG (info);
 118   ACE_UNUSED_ARG (handle);
 119
 120   ACE_NOTSUP_RETURN (-1);
 121 #endif /* ACE_HAS_TLI */
 122 }
 123
 124 ACE_INLINE int
 125 t_getname (ACE_HANDLE handle, struct netbuf *namep, int type)
 126 {
 127 #if defined (ACE_HAS_XTI)
 128   ACE_TBIND bound, peer;
 129   // Depending on which address the caller wants, fill caller's values
 130   // into one of the t_bind netbufs. The other is set up to ignore that
 131   // address.
 132   switch (type)
 133     {
 134     case LOCALNAME:
 135       bound.addr.buf = namep->buf;
 136       bound.addr.maxlen = namep->maxlen;
 137       bound.addr.len = 0;
 138       peer.addr.buf = 0;
 139       peer.addr.maxlen = 0;
 140       peer.addr.len = 0;
 141       break;
 142     case REMOTENAME:
 143       bound.addr.buf = 0;
 144       bound.addr.maxlen = 0;
 145       bound.addr.len = 0;
 146       peer.addr.buf = namep->buf;
 147       peer.addr.maxlen = namep->maxlen;
 148       peer.addr.len = 0;
 149       break;
 150     default:
 151       ACE_OS::last_error (EINVAL);
 152       return -1;
 153     }
 154   if (t_getprotaddr (handle, &bound, &peer) == -1)
 155     return -1;
 156   // Call succeeded; put the caller's desired address length in his netbuf.
 157   if (type == LOCALNAME)
 158     namep->len = bound.addr.len;
 159   else
 160     namep->len = peer.addr.len;
 161   return 0;
 162 #else
 163   ACE_UNUSED_ARG (handle);
 164   ACE_UNUSED_ARG (namep);
 165   ACE_UNUSED_ARG (type);
 166
 167   ACE_NOTSUP_RETURN (-1);
 168 #endif /* ACE_HAS_XTI */
 169 }
 170
 171 ACE_INLINE int
 172 t_getstate (ACE_HANDLE handle)
 173 {
 174 #if defined (ACE_HAS_TLI)
 175   return ::t_getstate (handle);
 176 #else
 177   ACE_UNUSED_ARG (handle);
 178
 179   ACE_NOTSUP_RETURN (-1);
 180 #endif /* ACE_HAS_TLI */
 181 }
 182
 183 ACE_INLINE int
 184 t_listen (ACE_HANDLE handle, struct t_call *call)
 185 {
 186 #if defined (ACE_HAS_TLI)
 187   return ::t_listen (handle, call);
 188 #else
 189   ACE_UNUSED_ARG (handle);
 190   ACE_UNUSED_ARG (call);
 191
 192   ACE_NOTSUP_RETURN (-1);
 193 #endif /* ACE_HAS_TLI */
 194 }
 195
 196 ACE_INLINE int
 197 t_look (ACE_HANDLE handle)
 198 {
 199 #if defined (ACE_HAS_TLI)
 200   return ::t_look (handle);
 201 #else
 202   ACE_UNUSED_ARG (handle);
 203
 204   ACE_NOTSUP_RETURN (-1);
 205 #endif /* ACE_HAS_TLI */
 206 }
 207
 208 ACE_INLINE ACE_HANDLE
 209 t_open (char *path, int oflag, struct t_info *info)
 210 {
 211 #if defined (ACE_HAS_TLI)
 212   return ::t_open (path, oflag, info);
 213 #else
 214   ACE_UNUSED_ARG (path);
 215   ACE_UNUSED_ARG (oflag);
 216   ACE_UNUSED_ARG (info);
 217
 218   ACE_NOTSUP_RETURN (ACE_INVALID_HANDLE);
 219 #endif /* ACE_HAS_TLI */
 220 }
 221
 222 ACE_INLINE int
 223 t_optmgmt (ACE_HANDLE handle, ACE_TOPTMGMT *req, ACE_TOPTMGMT *ret)
 224 {
 225 #if defined (ACE_HAS_TLI)
 226   return ::t_optmgmt (handle, req, ret);
 227 #else
 228   ACE_UNUSED_ARG (handle);
 229   ACE_UNUSED_ARG (req);
 230   ACE_UNUSED_ARG (ret);
 231
 232   ACE_NOTSUP_RETURN (-1);
 233 #endif /* ACE_HAS_TLI */
 234 }
 235
 236 ACE_INLINE int
 237 t_rcv (ACE_HANDLE handle,
 238        char *buf,
 239        unsigned int nbytes,
 240        int *flags)
 241 {
 242 #if defined (ACE_HAS_TLI)
 243   return ::t_rcv (handle, buf, nbytes, flags);
 244 #else
 245   ACE_UNUSED_ARG (handle);
 246   ACE_UNUSED_ARG (buf);
 247   ACE_UNUSED_ARG (nbytes);
 248   ACE_UNUSED_ARG (flags);
 249
 250   ACE_NOTSUP_RETURN (-1);
 251 #endif /* ACE_HAS_TLI */
 252 }
 253
 254 ACE_INLINE int
 255 t_rcvdis (ACE_HANDLE handle, struct t_discon *discon)
 256 {
 257 #if defined (ACE_HAS_TLI)
 258   return ::t_rcvdis (handle, discon);
 259 #else
 260   ACE_UNUSED_ARG (handle);
 261   ACE_UNUSED_ARG (discon);
 262
 263   ACE_NOTSUP_RETURN (-1);
 264 #endif /* ACE_HAS_TLI */
 265 }
 266
 267 ACE_INLINE int
 268 t_rcvrel (ACE_HANDLE handle)
 269 {
 270 #if defined (ACE_HAS_TLI)
 271   return ::t_rcvrel (handle);
 272 #else
 273   ACE_UNUSED_ARG (handle);
 274
 275   ACE_NOTSUP_RETURN (-1);
 276 #endif /* ACE_HAS_TLI */
 277 }
 278
 279 ACE_INLINE int
 280 t_rcvudata (ACE_HANDLE handle,
 281             struct t_unitdata *unitdata,
 282             int *flags)
 283 {
 284 #if defined (ACE_HAS_TLI)
 285   return ::t_rcvudata (handle, unitdata, flags);
 286 #else
 287   ACE_UNUSED_ARG (handle);
 288   ACE_UNUSED_ARG (unitdata);
 289   ACE_UNUSED_ARG (flags);
 290
 291   ACE_NOTSUP_RETURN (-1);
 292 #endif /* ACE_HAS_TLI */
 293 }
 294
 295 ACE_INLINE int
 296 t_rcvuderr (ACE_HANDLE handle, struct t_uderr *uderr)
 297 {
 298 #if defined (ACE_HAS_TLI)
 299   return ::t_rcvuderr (handle, uderr);
 300 #else
 301   ACE_UNUSED_ARG (handle);
 302   ACE_UNUSED_ARG (uderr);
 303
 304   ACE_NOTSUP_RETURN (-1);
 305 #endif /* ACE_HAS_TLI */
 306 }
 307
 308 ACE_INLINE int
 309 t_snd (ACE_HANDLE handle,
 310        const char *buf,
 311        unsigned int nbytes,
 312        int flags)
 313 {
 314 #if defined (ACE_HAS_TLI)
 315   return ::t_snd (handle, (char *) buf, nbytes, flags);
 316 #else
 317   ACE_UNUSED_ARG (handle);
 318   ACE_UNUSED_ARG (buf);
 319   ACE_UNUSED_ARG (nbytes);
 320   ACE_UNUSED_ARG (flags);
 321
 322   ACE_NOTSUP_RETURN (-1);
 323 #endif /* ACE_HAS_TLI */
 324 }
 325
 326 ACE_INLINE int
 327 t_snddis (ACE_HANDLE handle, struct t_call *call)
 328 {
 329 #if defined (ACE_HAS_TLI)
 330   return ::t_snddis (handle, call);
 331 #else
 332   ACE_UNUSED_ARG (handle);
 333   ACE_UNUSED_ARG (call);
 334
 335   ACE_NOTSUP_RETURN (-1);
 336 #endif /* ACE_HAS_TLI */
 337 }
 338
 339 ACE_INLINE int
 340 t_sndrel (ACE_HANDLE handle)
 341 {
 342 #if defined (ACE_HAS_TLI)
 343   return ::t_sndrel (handle);
 344 #else
 345   ACE_UNUSED_ARG (handle);
 346
 347   ACE_NOTSUP_RETURN (-1);
 348 #endif /* ACE_HAS_TLI */
 349 }
 350
 351 ACE_INLINE int
 352 t_sync (ACE_HANDLE handle)
 353 {
 354 #if defined (ACE_HAS_TLI)
 355   return ::t_sync (handle);
 356 #else
 357   ACE_UNUSED_ARG (handle);
 358
 359   ACE_NOTSUP_RETURN (-1);
 360 #endif /* ACE_HAS_TLI */
 361 }
 362
 363 ACE_INLINE int
 364 t_unbind (ACE_HANDLE handle)
 365 {
 366 #if defined (ACE_HAS_TLI)
 367   return ::t_unbind (handle);
 368 #else
 369   ACE_UNUSED_ARG (handle);
 370
 371   ACE_NOTSUP_RETURN (-1);
 372 #endif /* ACE_HAS_TLI */
 373 }
 374
 375 }  /* end namespace ACE_OS */
 376
 377 ACE_END_VERSIONED_NAMESPACE_DECL