1 /* 2 * This file is part of gtkD. 3 * 4 * gtkD is free software; you can redistribute it and/or modify 5 * it under the terms of the GNU Lesser General Public License 6 * as published by the Free Software Foundation; either version 3 7 * of the License, or (at your option) any later version, with 8 * some exceptions, please read the COPYING file. 9 * 10 * gtkD is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU Lesser General Public License for more details. 14 * 15 * You should have received a copy of the GNU Lesser General Public License 16 * along with gtkD; if not, write to the Free Software 17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA 18 */ 19 20 // generated automatically - do not change 21 // find conversion definition on APILookup.txt 22 // implement new conversion functionalities on the wrap.utils pakage 23 24 25 module gio.UnixSocketAddress; 26 27 private import gio.SocketAddress; 28 private import gio.c.functions; 29 public import gio.c.types; 30 private import glib.ConstructionException; 31 private import glib.Str; 32 private import glib.c.functions; 33 private import gobject.ObjectG; 34 35 36 /** 37 * Support for UNIX-domain (also known as local) sockets. 38 * 39 * UNIX domain sockets are generally visible in the filesystem. 40 * However, some systems support abstract socket names which are not 41 * visible in the filesystem and not affected by the filesystem 42 * permissions, visibility, etc. Currently this is only supported 43 * under Linux. If you attempt to use abstract sockets on other 44 * systems, function calls may return %G_IO_ERROR_NOT_SUPPORTED 45 * errors. You can use g_unix_socket_address_abstract_names_supported() 46 * to see if abstract names are supported. 47 * 48 * Note that `<gio/gunixsocketaddress.h>` belongs to the UNIX-specific GIO 49 * interfaces, thus you have to use the `gio-unix-2.0.pc` pkg-config file 50 * when using it. 51 */ 52 public class UnixSocketAddress : SocketAddress 53 { 54 /** the main Gtk struct */ 55 protected GUnixSocketAddress* gUnixSocketAddress; 56 57 /** Get the main Gtk struct */ 58 public GUnixSocketAddress* getUnixSocketAddressStruct(bool transferOwnership = false) 59 { 60 if (transferOwnership) 61 ownedRef = false; 62 return gUnixSocketAddress; 63 } 64 65 /** the main Gtk struct as a void* */ 66 protected override void* getStruct() 67 { 68 return cast(void*)gUnixSocketAddress; 69 } 70 71 /** 72 * Sets our main struct and passes it to the parent class. 73 */ 74 public this (GUnixSocketAddress* gUnixSocketAddress, bool ownedRef = false) 75 { 76 this.gUnixSocketAddress = gUnixSocketAddress; 77 super(cast(GSocketAddress*)gUnixSocketAddress, ownedRef); 78 } 79 80 81 /** */ 82 public static GType getType() 83 { 84 return g_unix_socket_address_get_type(); 85 } 86 87 /** 88 * Creates a new #GUnixSocketAddress for @path. 89 * 90 * To create abstract socket addresses, on systems that support that, 91 * use g_unix_socket_address_new_abstract(). 92 * 93 * Params: 94 * path = the socket path 95 * 96 * Returns: a new #GUnixSocketAddress 97 * 98 * Since: 2.22 99 * 100 * Throws: ConstructionException GTK+ fails to create the object. 101 */ 102 public this(string path) 103 { 104 auto __p = g_unix_socket_address_new(Str.toStringz(path)); 105 106 if(__p is null) 107 { 108 throw new ConstructionException("null returned by new"); 109 } 110 111 this(cast(GUnixSocketAddress*) __p, true); 112 } 113 114 /** 115 * Creates a new #GUnixSocketAddress of type @type with name @path. 116 * 117 * If @type is %G_UNIX_SOCKET_ADDRESS_PATH, this is equivalent to 118 * calling g_unix_socket_address_new(). 119 * 120 * If @type is %G_UNIX_SOCKET_ADDRESS_ANONYMOUS, @path and @path_len will be 121 * ignored. 122 * 123 * If @path_type is %G_UNIX_SOCKET_ADDRESS_ABSTRACT, then @path_len 124 * bytes of @path will be copied to the socket's path, and only those 125 * bytes will be considered part of the name. (If @path_len is -1, 126 * then @path is assumed to be NUL-terminated.) For example, if @path 127 * was "test", then calling g_socket_address_get_native_size() on the 128 * returned socket would return 7 (2 bytes of overhead, 1 byte for the 129 * abstract-socket indicator byte, and 4 bytes for the name "test"). 130 * 131 * If @path_type is %G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED, then 132 * @path_len bytes of @path will be copied to the socket's path, the 133 * rest of the path will be padded with 0 bytes, and the entire 134 * zero-padded buffer will be considered the name. (As above, if 135 * @path_len is -1, then @path is assumed to be NUL-terminated.) In 136 * this case, g_socket_address_get_native_size() will always return 137 * the full size of a `struct sockaddr_un`, although 138 * g_unix_socket_address_get_path_len() will still return just the 139 * length of @path. 140 * 141 * %G_UNIX_SOCKET_ADDRESS_ABSTRACT is preferred over 142 * %G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED for new programs. Of course, 143 * when connecting to a server created by another process, you must 144 * use the appropriate type corresponding to how that process created 145 * its listening socket. 146 * 147 * Params: 148 * path = the name 149 * type = a #GUnixSocketAddressType 150 * 151 * Returns: a new #GUnixSocketAddress 152 * 153 * Since: 2.26 154 * 155 * Throws: ConstructionException GTK+ fails to create the object. 156 */ 157 public this(string path, GUnixSocketAddressType type) 158 { 159 auto __p = g_unix_socket_address_new_with_type(Str.toStringz(path), cast(int)path.length, type); 160 161 if(__p is null) 162 { 163 throw new ConstructionException("null returned by new_with_type"); 164 } 165 166 this(cast(GUnixSocketAddress*) __p, true); 167 } 168 169 /** 170 * Checks if abstract UNIX domain socket names are supported. 171 * 172 * Returns: %TRUE if supported, %FALSE otherwise 173 * 174 * Since: 2.22 175 */ 176 public static bool abstractNamesSupported() 177 { 178 return g_unix_socket_address_abstract_names_supported() != 0; 179 } 180 181 /** 182 * Gets @address's type. 183 * 184 * Returns: a #GUnixSocketAddressType 185 * 186 * Since: 2.26 187 */ 188 public GUnixSocketAddressType getAddressType() 189 { 190 return g_unix_socket_address_get_address_type(gUnixSocketAddress); 191 } 192 193 /** 194 * Tests if @address is abstract. 195 * 196 * Deprecated: Use g_unix_socket_address_get_address_type() 197 * 198 * Returns: %TRUE if the address is abstract, %FALSE otherwise 199 * 200 * Since: 2.22 201 */ 202 public bool getIsAbstract() 203 { 204 return g_unix_socket_address_get_is_abstract(gUnixSocketAddress) != 0; 205 } 206 207 /** 208 * Gets @address's path, or for abstract sockets the "name". 209 * 210 * Guaranteed to be zero-terminated, but an abstract socket 211 * may contain embedded zeros, and thus you should use 212 * g_unix_socket_address_get_path_len() to get the true length 213 * of this string. 214 * 215 * Returns: the path for @address 216 * 217 * Since: 2.22 218 */ 219 public string getPath() 220 { 221 return Str.toString(g_unix_socket_address_get_path(gUnixSocketAddress)); 222 } 223 224 /** 225 * Gets the length of @address's path. 226 * 227 * For details, see g_unix_socket_address_get_path(). 228 * 229 * Returns: the length of the path 230 * 231 * Since: 2.22 232 */ 233 public size_t getPathLen() 234 { 235 return g_unix_socket_address_get_path_len(gUnixSocketAddress); 236 } 237 }