ACE/ace/SPIPE_Addr.cpp

   1 #include "ace/SPIPE_Addr.h"
   2 #include "ace/OS_NS_string.h"
   3 #include "ace/OS_NS_unistd.h"
   4 #include "ace/os_include/sys/os_socket.h"
   5
   6 #if !defined (__ACE_INLINE__)
   7 #include "ace/SPIPE_Addr.inl"
   8 #endif /* __ACE_INLINE__ */
   9
  10 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  11
  12 ACE_ALLOC_HOOK_DEFINE(ACE_SPIPE_Addr)
  13
  14 void
  15 ACE_SPIPE_Addr::dump (void) const
  16 {
  17 #if defined (ACE_HAS_DUMP)
  18 #endif /* ACE_HAS_DUMP */
  19 }
  20
  21 // Set a pointer to the address.
  22 void
  23 ACE_SPIPE_Addr::set_addr (const void *addr, int len)
  24 {
  25   ACE_TRACE ("ACE_SPIPE_Addr::set_addr");
  26
  27   this->ACE_Addr::base_set (AF_SPIPE, len);
  28   ACE_OS::memcpy (&this->SPIPE_addr_, addr, len);
  29 }
  30
  31 // Return the address.
  32
  33 void *
  34 ACE_SPIPE_Addr::get_addr (void) const
  35 {
  36   return (void *) &this->SPIPE_addr_;
  37 }
  38
  39
  40 // Do nothing constructor.
  41
  42 ACE_SPIPE_Addr::ACE_SPIPE_Addr (void)
  43   : ACE_Addr (AF_SPIPE, sizeof this->SPIPE_addr_)
  44 {
  45   (void) ACE_OS::memset ((void *) &this->SPIPE_addr_,
  46                          0,
  47                          sizeof this->SPIPE_addr_);
  48 }
  49
  50 int
  51 ACE_SPIPE_Addr::addr_to_string (ACE_TCHAR *s, size_t len) const
  52 {
  53   ACE_OS::strsncpy (s,
  54                     this->SPIPE_addr_.rendezvous_,
  55                     len);
  56   return 0;
  57 }
  58
  59 // Transform the string into the current addressing format.
  60
  61 int
  62 ACE_SPIPE_Addr::string_to_addr (const ACE_TCHAR *addr)
  63 {
  64   return this->set (addr);
  65 }
  66
  67 int
  68 ACE_SPIPE_Addr::set (const ACE_SPIPE_Addr &sa)
  69 {
  70   this->base_set (sa.get_type (), sa.get_size ());
  71
  72   if (sa.get_type () == AF_ANY)
  73     (void) ACE_OS::memset ((void *) &this->SPIPE_addr_,
  74                            0,
  75                            sizeof this->SPIPE_addr_);
  76   else
  77     (void) ACE_OS::memcpy ((void *) &this->SPIPE_addr_, (void *)
  78                            &sa.SPIPE_addr_,
  79                            sa.get_size ());
  80   return 0;
  81 }
  82
  83 // Copy constructor.
  84
  85 ACE_SPIPE_Addr::ACE_SPIPE_Addr (const ACE_SPIPE_Addr &sa)
  86   : ACE_Addr (AF_SPIPE, sizeof this->SPIPE_addr_)
  87 {
  88   this->set (sa);
  89 }
  90
  91 int
  92 ACE_SPIPE_Addr::set (const ACE_TCHAR *addr,
  93                      gid_t gid,
  94                      uid_t uid)
  95 {
  96   int len = sizeof (this->SPIPE_addr_.uid_);
  97   len += sizeof (this->SPIPE_addr_.gid_);
  98
  99 #if defined (ACE_WIN32)
 100   const ACE_TCHAR *colonp = ACE_OS::strchr (addr, ':');
 101   ACE_TCHAR temp[BUFSIZ];
 102
 103   if (colonp == 0) // Assume it's a local name.
 104     {
 105       ACE_OS::strcpy (temp, ACE_TEXT ( "\\\\.\\pipe\\"));
 106       ACE_OS::strcat (temp, addr);
 107     }
 108   else
 109     {
 110
 111       if (ACE_OS::strncmp (addr,
 112                            ACE_TEXT ("localhost"),
 113                            ACE_OS::strlen ("localhost")) == 0)
 114         // change "localhost" to "."
 115         ACE_OS::strcpy (temp, ACE_TEXT ("\\\\."));
 116       else
 117         {
 118           ACE_OS::strcpy (temp, ACE_TEXT ("\\\\"));
 119
 120           ACE_TCHAR *t;
 121
 122           // We need to allocate a duplicate so that we can write a
 123           // NUL character into it.
 124           ACE_ALLOCATOR_RETURN (t, ACE_OS::strdup (addr), -1);
 125
 126           t[colonp - addr] = ACE_TEXT ('\0');
 127           ACE_OS::strcat (temp, t);
 128
 129           ACE_OS::free (t);
 130         }
 131
 132       ACE_OS::strcat (temp, ACE_TEXT ("\\pipe\\"));
 133       ACE_OS::strcat (temp, colonp + 1);
 134     }
 135   len += static_cast<int> (ACE_OS::strlen (temp));
 136   this->ACE_Addr::base_set (AF_SPIPE, len);
 137
 138   ACE_OS::strcpy (this->SPIPE_addr_.rendezvous_, temp);
 139 #else
 140   this->ACE_Addr::base_set (AF_SPIPE,
 141                             ACE_OS::strlen (addr) + 1 + len);
 142   ACE_OS::strsncpy (this->SPIPE_addr_.rendezvous_,
 143                     addr,
 144                     sizeof this->SPIPE_addr_.rendezvous_);
 145 #endif /* ACE_WIN32 */
 146   this->SPIPE_addr_.gid_ = gid == 0 ? ACE_OS::getgid () : gid;
 147   this->SPIPE_addr_.uid_ = uid == 0 ? ACE_OS::getuid () : uid;
 148   return 0;
 149 }
 150
 151 // Create a ACE_Addr from a ACE_SPIPE pathname.
 152
 153 ACE_SPIPE_Addr::ACE_SPIPE_Addr (const ACE_TCHAR *addr,
 154                                 gid_t gid,
 155                                 uid_t uid)
 156   : ACE_Addr (AF_SPIPE, sizeof this->SPIPE_addr_)
 157 {
 158   this->set (addr, gid, uid);
 159 }
 160
 161 ACE_END_VERSIONED_NAMESPACE_DECL