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 glib.ConstructionException; 29 private import glib.Str; 30 private import gobject.ObjectG; 31 private import gtkc.gio; 32 public import gtkc.giotypes; 33 34 35 /** 36 * Support for UNIX-domain (also known as local) sockets. 37 * 38 * UNIX domain sockets are generally visible in the filesystem. 39 * However, some systems support abstract socket names which are not 40 * visible in the filesystem and not affected by the filesystem 41 * permissions, visibility, etc. Currently this is only supported 42 * under Linux. If you attempt to use abstract sockets on other 43 * systems, function calls may return %G_IO_ERROR_NOT_SUPPORTED 44 * errors. You can use g_unix_socket_address_abstract_names_supported() 45 * to see if abstract names are supported. 46 * 47 * Note that `<gio/gunixsocketaddress.h>` belongs to the UNIX-specific GIO 48 * interfaces, thus you have to use the `gio-unix-2.0.pc` pkg-config file 49 * when using it. 50 */ 51 public class UnixSocketAddress : SocketAddress 52 { 53 /** the main Gtk struct */ 54 protected GUnixSocketAddress* gUnixSocketAddress; 55 56 /** Get the main Gtk struct */ 57 public GUnixSocketAddress* getUnixSocketAddressStruct() 58 { 59 return gUnixSocketAddress; 60 } 61 62 /** the main Gtk struct as a void* */ 63 protected override void* getStruct() 64 { 65 return cast(void*)gUnixSocketAddress; 66 } 67 68 protected override void setStruct(GObject* obj) 69 { 70 gUnixSocketAddress = cast(GUnixSocketAddress*)obj; 71 super.setStruct(obj); 72 } 73 74 /** 75 * Sets our main struct and passes it to the parent class. 76 */ 77 public this (GUnixSocketAddress* gUnixSocketAddress, bool ownedRef = false) 78 { 79 this.gUnixSocketAddress = gUnixSocketAddress; 80 super(cast(GSocketAddress*)gUnixSocketAddress, ownedRef); 81 } 82 83 /** 84 */ 85 86 public static GType getType() 87 { 88 return g_unix_socket_address_get_type(); 89 } 90 91 /** 92 * Creates a new #GUnixSocketAddress for @path. 93 * 94 * To create abstract socket addresses, on systems that support that, 95 * use g_unix_socket_address_new_abstract(). 96 * 97 * Params: 98 * path = the socket path 99 * 100 * Return: a new #GUnixSocketAddress 101 * 102 * Since: 2.22 103 * 104 * Throws: ConstructionException GTK+ fails to create the object. 105 */ 106 public this(string path) 107 { 108 auto p = g_unix_socket_address_new(Str.toStringz(path)); 109 110 if(p is null) 111 { 112 throw new ConstructionException("null returned by new"); 113 } 114 115 this(cast(GUnixSocketAddress*) p, true); 116 } 117 118 /** 119 * Creates a new #GUnixSocketAddress of type @type with name @path. 120 * 121 * If @type is %G_UNIX_SOCKET_ADDRESS_PATH, this is equivalent to 122 * calling g_unix_socket_address_new(). 123 * 124 * If @path_type is %G_UNIX_SOCKET_ADDRESS_ABSTRACT, then @path_len 125 * bytes of @path will be copied to the socket's path, and only those 126 * bytes will be considered part of the name. (If @path_len is -1, 127 * then @path is assumed to be NUL-terminated.) For example, if @path 128 * was "test", then calling g_socket_address_get_native_size() on the 129 * returned socket would return 7 (2 bytes of overhead, 1 byte for the 130 * abstract-socket indicator byte, and 4 bytes for the name "test"). 131 * 132 * If @path_type is %G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED, then 133 * @path_len bytes of @path will be copied to the socket's path, the 134 * rest of the path will be padded with 0 bytes, and the entire 135 * zero-padded buffer will be considered the name. (As above, if 136 * @path_len is -1, then @path is assumed to be NUL-terminated.) In 137 * this case, g_socket_address_get_native_size() will always return 138 * the full size of a `struct sockaddr_un`, although 139 * g_unix_socket_address_get_path_len() will still return just the 140 * length of @path. 141 * 142 * %G_UNIX_SOCKET_ADDRESS_ABSTRACT is preferred over 143 * %G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED for new programs. Of course, 144 * when connecting to a server created by another process, you must 145 * use the appropriate type corresponding to how that process created 146 * its listening socket. 147 * 148 * Params: 149 * path = the name 150 * pathLen = the length of @path, or -1 151 * type = a #GUnixSocketAddressType 152 * 153 * Return: a new #GUnixSocketAddress 154 * 155 * Since: 2.26 156 * 157 * Throws: ConstructionException GTK+ fails to create the object. 158 */ 159 public this(string path, GUnixSocketAddressType type) 160 { 161 auto p = g_unix_socket_address_new_with_type(Str.toStringz(path), cast(int)path.length, type); 162 163 if(p is null) 164 { 165 throw new ConstructionException("null returned by new_with_type"); 166 } 167 168 this(cast(GUnixSocketAddress*) p, true); 169 } 170 171 /** 172 * Checks if abstract UNIX domain socket names are supported. 173 * 174 * Return: %TRUE if supported, %FALSE otherwise 175 * 176 * Since: 2.22 177 */ 178 public static bool abstractNamesSupported() 179 { 180 return g_unix_socket_address_abstract_names_supported() != 0; 181 } 182 183 /** 184 * Gets @address's type. 185 * 186 * Return: a #GUnixSocketAddressType 187 * 188 * Since: 2.26 189 */ 190 public GUnixSocketAddressType getAddressType() 191 { 192 return g_unix_socket_address_get_address_type(gUnixSocketAddress); 193 } 194 195 /** 196 * Tests if @address is abstract. 197 * 198 * Deprecated: Use g_unix_socket_address_get_address_type() 199 * 200 * Return: %TRUE if the address is abstract, %FALSE otherwise 201 * 202 * Since: 2.22 203 */ 204 public bool getIsAbstract() 205 { 206 return g_unix_socket_address_get_is_abstract(gUnixSocketAddress) != 0; 207 } 208 209 /** 210 * Gets @address's path, or for abstract sockets the "name". 211 * 212 * Guaranteed to be zero-terminated, but an abstract socket 213 * may contain embedded zeros, and thus you should use 214 * g_unix_socket_address_get_path_len() to get the true length 215 * of this string. 216 * 217 * Return: the path for @address 218 * 219 * Since: 2.22 220 */ 221 public string getPath() 222 { 223 return Str.toString(g_unix_socket_address_get_path(gUnixSocketAddress)); 224 } 225 226 /** 227 * Gets the length of @address's path. 228 * 229 * For details, see g_unix_socket_address_get_path(). 230 * 231 * Return: the length of the path 232 * 233 * Since: 2.22 234 */ 235 public size_t getPathLen() 236 { 237 return g_unix_socket_address_get_path_len(gUnixSocketAddress); 238 } 239 }