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.SocketControlMessage; 26 27 private import gio.c.functions; 28 public import gio.c.types; 29 private import gobject.ObjectG; 30 public import gtkc.giotypes; 31 32 33 /** 34 * A #GSocketControlMessage is a special-purpose utility message that 35 * can be sent to or received from a #GSocket. These types of 36 * messages are often called "ancillary data". 37 * 38 * The message can represent some sort of special instruction to or 39 * information from the socket or can represent a special kind of 40 * transfer to the peer (for example, sending a file descriptor over 41 * a UNIX socket). 42 * 43 * These messages are sent with g_socket_send_message() and received 44 * with g_socket_receive_message(). 45 * 46 * To extend the set of control message that can be sent, subclass this 47 * class and override the get_size, get_level, get_type and serialize 48 * methods. 49 * 50 * To extend the set of control messages that can be received, subclass 51 * this class and implement the deserialize method. Also, make sure your 52 * class is registered with the GType typesystem before calling 53 * g_socket_receive_message() to read such a message. 54 */ 55 public class SocketControlMessage : ObjectG 56 { 57 /** the main Gtk struct */ 58 protected GSocketControlMessage* gSocketControlMessage; 59 60 /** Get the main Gtk struct */ 61 public GSocketControlMessage* getSocketControlMessageStruct(bool transferOwnership = false) 62 { 63 if (transferOwnership) 64 ownedRef = false; 65 return gSocketControlMessage; 66 } 67 68 /** the main Gtk struct as a void* */ 69 protected override void* getStruct() 70 { 71 return cast(void*)gSocketControlMessage; 72 } 73 74 protected override void setStruct(GObject* obj) 75 { 76 gSocketControlMessage = cast(GSocketControlMessage*)obj; 77 super.setStruct(obj); 78 } 79 80 /** 81 * Sets our main struct and passes it to the parent class. 82 */ 83 public this (GSocketControlMessage* gSocketControlMessage, bool ownedRef = false) 84 { 85 this.gSocketControlMessage = gSocketControlMessage; 86 super(cast(GObject*)gSocketControlMessage, ownedRef); 87 } 88 89 90 /** */ 91 public static GType getType() 92 { 93 return g_socket_control_message_get_type(); 94 } 95 96 /** 97 * Tries to deserialize a socket control message of a given 98 * @level and @type. This will ask all known (to GType) subclasses 99 * of #GSocketControlMessage if they can understand this kind 100 * of message and if so deserialize it into a #GSocketControlMessage. 101 * 102 * If there is no implementation for this kind of control message, %NULL 103 * will be returned. 104 * 105 * Params: 106 * level = a socket level 107 * type = a socket control message type for the given @level 108 * data = pointer to the message data 109 * 110 * Returns: the deserialized message or %NULL 111 * 112 * Since: 2.22 113 */ 114 public static SocketControlMessage deserialize(int level, int type, ubyte[] data) 115 { 116 auto p = g_socket_control_message_deserialize(level, type, cast(size_t)data.length, data.ptr); 117 118 if(p is null) 119 { 120 return null; 121 } 122 123 return ObjectG.getDObject!(SocketControlMessage)(cast(GSocketControlMessage*) p, true); 124 } 125 126 /** 127 * Returns the "level" (i.e. the originating protocol) of the control message. 128 * This is often SOL_SOCKET. 129 * 130 * Returns: an integer describing the level 131 * 132 * Since: 2.22 133 */ 134 public int getLevel() 135 { 136 return g_socket_control_message_get_level(gSocketControlMessage); 137 } 138 139 /** 140 * Returns the protocol specific type of the control message. 141 * For instance, for UNIX fd passing this would be SCM_RIGHTS. 142 * 143 * Returns: an integer describing the type of control message 144 * 145 * Since: 2.22 146 */ 147 public int getMsgType() 148 { 149 return g_socket_control_message_get_msg_type(gSocketControlMessage); 150 } 151 152 /** 153 * Returns the space required for the control message, not including 154 * headers or alignment. 155 * 156 * Returns: The number of bytes required. 157 * 158 * Since: 2.22 159 */ 160 public size_t getSize() 161 { 162 return g_socket_control_message_get_size(gSocketControlMessage); 163 } 164 165 /** 166 * Converts the data in the message to bytes placed in the 167 * message. 168 * 169 * @data is guaranteed to have enough space to fit the size 170 * returned by g_socket_control_message_get_size() on this 171 * object. 172 * 173 * Params: 174 * data = A buffer to write data to 175 * 176 * Since: 2.22 177 */ 178 public void serialize(void* data) 179 { 180 g_socket_control_message_serialize(gSocketControlMessage, data); 181 } 182 }