1 /* 2 * Copyright 2009 VMware, Inc. 3 * All Rights Reserved. 4 * 5 * Permission is hereby granted, free of charge, to any person obtaining a 6 * copy of this software and associated documentation files (the "Software"), 7 * to deal in the Software without restriction, including without limitation 8 * on the rights to use, copy, modify, merge, publish, distribute, sub 9 * license, and/or sell copies of the Software, and to permit persons to whom 10 * the Software is furnished to do so, subject to the following conditions: 11 * 12 * The above copyright notice and this permission notice (including the next 13 * paragraph) shall be included in all copies or substantial portions of the 14 * Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL 19 * VMWARE AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, 20 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 21 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE 22 * USE OR OTHER DEALINGS IN THE SOFTWARE. 23 */ 24 25 /* 26 * This file holds the function implementation for one of the rbug extensions. 27 * Prototypes and declerations of functions and structs is in the same folder 28 * in the header file matching this file's name. 29 * 30 * The functions starting rbug_send_* encodes a call to the write format and 31 * sends that to the supplied connection, while functions starting with 32 * rbug_demarshal_* demarshal data in the wire protocol. 33 * 34 * Functions ending with _reply are replies to requests. 35 */ 36 37 #include "rbug_internal.h" 38 #include "rbug_core.h" 39 40 int rbug_send_noop(struct rbug_connection *__con, 41 uint32_t *__serial) 42 { 43 uint32_t __len = 0; 44 uint32_t __pos = 0; 45 uint8_t *__data = NULL; 46 int __ret = 0; 47 48 LEN(8); /* header */ 49 50 /* align */ 51 PAD(__len, 8); 52 53 __data = (uint8_t*)MALLOC(__len); 54 if (!__data) 55 return -ENOMEM; 56 57 WRITE(4, int32_t, ((int32_t)RBUG_OP_NOOP)); 58 WRITE(4, uint32_t, ((uint32_t)(__len / 4))); 59 60 /* final pad */ 61 PAD(__pos, 8); 62 63 if (__pos != __len) { 64 __ret = -EINVAL; 65 } else { 66 rbug_connection_send_start(__con, RBUG_OP_NOOP, __len); 67 rbug_connection_write(__con, __data, __len); 68 __ret = rbug_connection_send_finish(__con, __serial); 69 } 70 71 FREE(__data); 72 return __ret; 73 } 74 75 int rbug_send_ping(struct rbug_connection *__con, 76 uint32_t *__serial) 77 { 78 uint32_t __len = 0; 79 uint32_t __pos = 0; 80 uint8_t *__data = NULL; 81 int __ret = 0; 82 83 LEN(8); /* header */ 84 85 /* align */ 86 PAD(__len, 8); 87 88 __data = (uint8_t*)MALLOC(__len); 89 if (!__data) 90 return -ENOMEM; 91 92 WRITE(4, int32_t, ((int32_t)RBUG_OP_PING)); 93 WRITE(4, uint32_t, ((uint32_t)(__len / 4))); 94 95 /* final pad */ 96 PAD(__pos, 8); 97 98 if (__pos != __len) { 99 __ret = -EINVAL; 100 } else { 101 rbug_connection_send_start(__con, RBUG_OP_PING, __len); 102 rbug_connection_write(__con, __data, __len); 103 __ret = rbug_connection_send_finish(__con, __serial); 104 } 105 106 FREE(__data); 107 return __ret; 108 } 109 110 int rbug_send_error(struct rbug_connection *__con, 111 uint32_t error, 112 uint32_t *__serial) 113 { 114 uint32_t __len = 0; 115 uint32_t __pos = 0; 116 uint8_t *__data = NULL; 117 int __ret = 0; 118 119 LEN(8); /* header */ 120 LEN(4); /* error */ 121 122 /* align */ 123 PAD(__len, 8); 124 125 __data = (uint8_t*)MALLOC(__len); 126 if (!__data) 127 return -ENOMEM; 128 129 WRITE(4, int32_t, ((int32_t)RBUG_OP_ERROR)); 130 WRITE(4, uint32_t, ((uint32_t)(__len / 4))); 131 WRITE(4, uint32_t, error); /* error */ 132 133 /* final pad */ 134 PAD(__pos, 8); 135 136 if (__pos != __len) { 137 __ret = -EINVAL; 138 } else { 139 rbug_connection_send_start(__con, RBUG_OP_ERROR, __len); 140 rbug_connection_write(__con, __data, __len); 141 __ret = rbug_connection_send_finish(__con, __serial); 142 } 143 144 FREE(__data); 145 return __ret; 146 } 147 148 int rbug_send_ping_reply(struct rbug_connection *__con, 149 uint32_t serial, 150 uint32_t *__serial) 151 { 152 uint32_t __len = 0; 153 uint32_t __pos = 0; 154 uint8_t *__data = NULL; 155 int __ret = 0; 156 157 LEN(8); /* header */ 158 LEN(4); /* serial */ 159 160 /* align */ 161 PAD(__len, 8); 162 163 __data = (uint8_t*)MALLOC(__len); 164 if (!__data) 165 return -ENOMEM; 166 167 WRITE(4, int32_t, ((int32_t)RBUG_OP_PING_REPLY)); 168 WRITE(4, uint32_t, ((uint32_t)(__len / 4))); 169 WRITE(4, uint32_t, serial); /* serial */ 170 171 /* final pad */ 172 PAD(__pos, 8); 173 174 if (__pos != __len) { 175 __ret = -EINVAL; 176 } else { 177 rbug_connection_send_start(__con, RBUG_OP_PING_REPLY, __len); 178 rbug_connection_write(__con, __data, __len); 179 __ret = rbug_connection_send_finish(__con, __serial); 180 } 181 182 FREE(__data); 183 return __ret; 184 } 185 186 int rbug_send_error_reply(struct rbug_connection *__con, 187 uint32_t serial, 188 uint32_t error, 189 uint32_t *__serial) 190 { 191 uint32_t __len = 0; 192 uint32_t __pos = 0; 193 uint8_t *__data = NULL; 194 int __ret = 0; 195 196 LEN(8); /* header */ 197 LEN(4); /* serial */ 198 LEN(4); /* error */ 199 200 /* align */ 201 PAD(__len, 8); 202 203 __data = (uint8_t*)MALLOC(__len); 204 if (!__data) 205 return -ENOMEM; 206 207 WRITE(4, int32_t, ((int32_t)RBUG_OP_ERROR_REPLY)); 208 WRITE(4, uint32_t, ((uint32_t)(__len / 4))); 209 WRITE(4, uint32_t, serial); /* serial */ 210 WRITE(4, uint32_t, error); /* error */ 211 212 /* final pad */ 213 PAD(__pos, 8); 214 215 if (__pos != __len) { 216 __ret = -EINVAL; 217 } else { 218 rbug_connection_send_start(__con, RBUG_OP_ERROR_REPLY, __len); 219 rbug_connection_write(__con, __data, __len); 220 __ret = rbug_connection_send_finish(__con, __serial); 221 } 222 223 FREE(__data); 224 return __ret; 225 } 226 227 struct rbug_proto_noop * rbug_demarshal_noop(struct rbug_proto_header *header) 228 { 229 struct rbug_proto_noop *ret; 230 231 if (!header) 232 return NULL; 233 if (header->opcode != (int32_t)RBUG_OP_NOOP) 234 return NULL; 235 236 ret = MALLOC(sizeof(*ret)); 237 if (!ret) 238 return NULL; 239 240 ret->header.__message = header; 241 ret->header.opcode = header->opcode; 242 243 return ret; 244 } 245 246 struct rbug_proto_ping * rbug_demarshal_ping(struct rbug_proto_header *header) 247 { 248 struct rbug_proto_ping *ret; 249 250 if (!header) 251 return NULL; 252 if (header->opcode != (int32_t)RBUG_OP_PING) 253 return NULL; 254 255 ret = MALLOC(sizeof(*ret)); 256 if (!ret) 257 return NULL; 258 259 ret->header.__message = header; 260 ret->header.opcode = header->opcode; 261 262 return ret; 263 } 264 265 struct rbug_proto_error * rbug_demarshal_error(struct rbug_proto_header *header) 266 { 267 uint32_t len = 0; 268 uint32_t pos = 0; 269 uint8_t *data = NULL; 270 struct rbug_proto_error *ret; 271 272 if (!header) 273 return NULL; 274 if (header->opcode != (int32_t)RBUG_OP_ERROR) 275 return NULL; 276 277 pos = 0; 278 len = header->length * 4; 279 data = (uint8_t*)&header[1]; 280 ret = MALLOC(sizeof(*ret)); 281 if (!ret) 282 return NULL; 283 284 ret->header.__message = header; 285 ret->header.opcode = header->opcode; 286 287 READ(4, uint32_t, error); /* error */ 288 289 return ret; 290 } 291 292 struct rbug_proto_ping_reply * rbug_demarshal_ping_reply(struct rbug_proto_header *header) 293 { 294 uint32_t len = 0; 295 uint32_t pos = 0; 296 uint8_t *data = NULL; 297 struct rbug_proto_ping_reply *ret; 298 299 if (!header) 300 return NULL; 301 if (header->opcode != (int32_t)RBUG_OP_PING_REPLY) 302 return NULL; 303 304 pos = 0; 305 len = header->length * 4; 306 data = (uint8_t*)&header[1]; 307 ret = MALLOC(sizeof(*ret)); 308 if (!ret) 309 return NULL; 310 311 ret->header.__message = header; 312 ret->header.opcode = header->opcode; 313 314 READ(4, uint32_t, serial); /* serial */ 315 316 return ret; 317 } 318 319 struct rbug_proto_error_reply * rbug_demarshal_error_reply(struct rbug_proto_header *header) 320 { 321 uint32_t len = 0; 322 uint32_t pos = 0; 323 uint8_t *data = NULL; 324 struct rbug_proto_error_reply *ret; 325 326 if (!header) 327 return NULL; 328 if (header->opcode != (int32_t)RBUG_OP_ERROR_REPLY) 329 return NULL; 330 331 pos = 0; 332 len = header->length * 4; 333 data = (uint8_t*)&header[1]; 334 ret = MALLOC(sizeof(*ret)); 335 if (!ret) 336 return NULL; 337 338 ret->header.__message = header; 339 ret->header.opcode = header->opcode; 340 341 READ(4, uint32_t, serial); /* serial */ 342 READ(4, uint32_t, error); /* error */ 343 344 return ret; 345 } 346
