contrib/bind-9.2.4rc7/lib/lwres/lwres_noop.c

   1 /*
   2  * Copyright (C) 2004  Internet Systems Consortium, Inc. ("ISC")
   3  * Copyright (C) 2000, 2001  Internet Software Consortium.
   4  *
   5  * Permission to use, copy, modify, and distribute this software for any
   6  * purpose with or without fee is hereby granted, provided that the above
   7  * copyright notice and this permission notice appear in all copies.
   8  *
   9  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
  10  * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  11  * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
  12  * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  13  * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  14  * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  15  * PERFORMANCE OF THIS SOFTWARE.
  16  */
  17
  18 /* $Id: lwres_noop.c,v 1.14.2.1 2004/03/09 06:12:35 marka Exp $ */
  19
  20 #include <config.h>
  21
  22 #include <assert.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25
  26 #include <lwres/lwbuffer.h>
  27 #include <lwres/lwpacket.h>
  28 #include <lwres/lwres.h>
  29 #include <lwres/result.h>
  30
  31 #include "context_p.h"
  32 #include "assert_p.h"
  33
  34 lwres_result_t
  35 lwres_nooprequest_render(lwres_context_t *ctx, lwres_nooprequest_t *req,
  36                          lwres_lwpacket_t *pkt, lwres_buffer_t *b)
  37 {
  38         unsigned char *buf;
  39         size_t buflen;
  40         int ret;
  41         size_t payload_length;
  42
  43         REQUIRE(ctx != NULL);
  44         REQUIRE(req != NULL);
  45         REQUIRE(pkt != NULL);
  46         REQUIRE(b != NULL);
  47
  48         payload_length = sizeof(lwres_uint16_t) + req->datalength;
  49
  50         buflen = LWRES_LWPACKET_LENGTH + payload_length;
  51         buf = CTXMALLOC(buflen);
  52         if (buf == NULL)
  53                 return (LWRES_R_NOMEMORY);
  54         lwres_buffer_init(b, buf, buflen);
  55
  56         pkt->length = buflen;
  57         pkt->version = LWRES_LWPACKETVERSION_0;
  58         pkt->pktflags &= ~LWRES_LWPACKETFLAG_RESPONSE;
  59         pkt->opcode = LWRES_OPCODE_NOOP;
  60         pkt->result = 0;
  61         pkt->authtype = 0;
  62         pkt->authlength = 0;
  63
  64         ret = lwres_lwpacket_renderheader(b, pkt);
  65         if (ret != LWRES_R_SUCCESS) {
  66                 lwres_buffer_invalidate(b);
  67                 CTXFREE(buf, buflen);
  68                 return (ret);
  69         }
  70
  71         INSIST(SPACE_OK(b, payload_length));
  72
  73         /*
  74          * Put the length and the data.  We know this will fit because we
  75          * just checked for it.
  76          */
  77         lwres_buffer_putuint16(b, req->datalength);
  78         lwres_buffer_putmem(b, req->data, req->datalength);
  79
  80         INSIST(LWRES_BUFFER_AVAILABLECOUNT(b) == 0);
  81
  82         return (LWRES_R_SUCCESS);
  83 }
  84
  85 lwres_result_t
  86 lwres_noopresponse_render(lwres_context_t *ctx, lwres_noopresponse_t *req,
  87                           lwres_lwpacket_t *pkt, lwres_buffer_t *b)
  88 {
  89         unsigned char *buf;
  90         size_t buflen;
  91         int ret;
  92         size_t payload_length;
  93
  94         REQUIRE(ctx != NULL);
  95         REQUIRE(req != NULL);
  96         REQUIRE(pkt != NULL);
  97         REQUIRE(b != NULL);
  98
  99         payload_length = sizeof(lwres_uint16_t) + req->datalength;
 100
 101         buflen = LWRES_LWPACKET_LENGTH + payload_length;
 102         buf = CTXMALLOC(buflen);
 103         if (buf == NULL)
 104                 return (LWRES_R_NOMEMORY);
 105         lwres_buffer_init(b, buf, buflen);
 106
 107         pkt->length = buflen;
 108         pkt->version = LWRES_LWPACKETVERSION_0;
 109         pkt->pktflags |= LWRES_LWPACKETFLAG_RESPONSE;
 110         pkt->opcode = LWRES_OPCODE_NOOP;
 111         pkt->authtype = 0;
 112         pkt->authlength = 0;
 113
 114         ret = lwres_lwpacket_renderheader(b, pkt);
 115         if (ret != LWRES_R_SUCCESS) {
 116                 lwres_buffer_invalidate(b);
 117                 CTXFREE(buf, buflen);
 118                 return (ret);
 119         }
 120
 121         INSIST(SPACE_OK(b, payload_length));
 122
 123         /*
 124          * Put the length and the data.  We know this will fit because we
 125          * just checked for it.
 126          */
 127         lwres_buffer_putuint16(b, req->datalength);
 128         lwres_buffer_putmem(b, req->data, req->datalength);
 129
 130         INSIST(LWRES_BUFFER_AVAILABLECOUNT(b) == 0);
 131
 132         return (LWRES_R_SUCCESS);
 133 }
 134
 135 lwres_result_t
 136 lwres_nooprequest_parse(lwres_context_t *ctx, lwres_buffer_t *b,
 137                         lwres_lwpacket_t *pkt, lwres_nooprequest_t **structp)
 138 {
 139         int ret;
 140         lwres_nooprequest_t *req;
 141
 142         REQUIRE(ctx != NULL);
 143         REQUIRE(b != NULL);
 144         REQUIRE(pkt != NULL);
 145         REQUIRE(structp != NULL && *structp == NULL);
 146
 147         if ((pkt->pktflags & LWRES_LWPACKETFLAG_RESPONSE) != 0)
 148                 return (LWRES_R_FAILURE);
 149
 150         req = CTXMALLOC(sizeof(lwres_nooprequest_t));
 151         if (req == NULL)
 152                 return (LWRES_R_NOMEMORY);
 153
 154         if (!SPACE_REMAINING(b, sizeof(lwres_uint16_t))) {
 155                 ret = LWRES_R_UNEXPECTEDEND;
 156                 goto out;
 157         }
 158         req->datalength = lwres_buffer_getuint16(b);
 159
 160         if (!SPACE_REMAINING(b, req->datalength)) {
 161                 ret = LWRES_R_UNEXPECTEDEND;
 162                 goto out;
 163         }
 164         req->data = b->base + b->current;
 165         lwres_buffer_forward(b, req->datalength);
 166
 167         if (LWRES_BUFFER_REMAINING(b) != 0) {
 168                 ret = LWRES_R_TRAILINGDATA;
 169                 goto out;
 170         }
 171
 172         /* success! */
 173         *structp = req;
 174         return (LWRES_R_SUCCESS);
 175
 176         /* Error return */
 177  out:
 178         CTXFREE(req, sizeof(lwres_nooprequest_t));
 179         return (ret);
 180 }
 181
 182 lwres_result_t
 183 lwres_noopresponse_parse(lwres_context_t *ctx, lwres_buffer_t *b,
 184                          lwres_lwpacket_t *pkt, lwres_noopresponse_t **structp)
 185 {
 186         int ret;
 187         lwres_noopresponse_t *req;
 188
 189         REQUIRE(ctx != NULL);
 190         REQUIRE(b != NULL);
 191         REQUIRE(pkt != NULL);
 192         REQUIRE(structp != NULL && *structp == NULL);
 193
 194         if ((pkt->pktflags & LWRES_LWPACKETFLAG_RESPONSE) == 0)
 195                 return (LWRES_R_FAILURE);
 196
 197         req = CTXMALLOC(sizeof(lwres_noopresponse_t));
 198         if (req == NULL)
 199                 return (LWRES_R_NOMEMORY);
 200
 201         if (!SPACE_REMAINING(b, sizeof(lwres_uint16_t))) {
 202                 ret = LWRES_R_UNEXPECTEDEND;
 203                 goto out;
 204         }
 205         req->datalength = lwres_buffer_getuint16(b);
 206
 207         if (!SPACE_REMAINING(b, req->datalength)) {
 208                 ret = LWRES_R_UNEXPECTEDEND;
 209                 goto out;
 210         }
 211         req->data = b->base + b->current;
 212
 213         lwres_buffer_forward(b, req->datalength);
 214         if (LWRES_BUFFER_REMAINING(b) != 0) {
 215                 ret = LWRES_R_TRAILINGDATA;
 216                 goto out;
 217         }
 218
 219         /* success! */
 220         *structp = req;
 221         return (LWRES_R_SUCCESS);
 222
 223         /* Error return */
 224  out:
 225         CTXFREE(req, sizeof(lwres_noopresponse_t));
 226         return (ret);
 227 }
 228
 229 void
 230 lwres_noopresponse_free(lwres_context_t *ctx, lwres_noopresponse_t **structp)
 231 {
 232         lwres_noopresponse_t *noop;
 233
 234         REQUIRE(ctx != NULL);
 235         REQUIRE(structp != NULL && *structp != NULL);
 236
 237         noop = *structp;
 238         *structp = NULL;
 239
 240         CTXFREE(noop, sizeof(lwres_noopresponse_t));
 241 }
 242
 243 void
 244 lwres_nooprequest_free(lwres_context_t *ctx, lwres_nooprequest_t **structp)
 245 {
 246         lwres_nooprequest_t *noop;
 247
 248         REQUIRE(ctx != NULL);
 249         REQUIRE(structp != NULL && *structp != NULL);
 250
 251         noop = *structp;
 252         *structp = NULL;
 253
 254         CTXFREE(noop, sizeof(lwres_nooprequest_t));
 255 }