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