Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  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.