Beispiel #1
0
static int lcb_parse_single_with_packet_forward(lcb_server_t *c,
        hrtime_t stop)
{
    protocol_binary_request_header req;
    protocol_binary_response_header header;
    lcb_size_t nr;
    lcb_size_t avail;
    int was_connected = c->connection_ready;
    uint16_t status;
    lcb_size_t packetsize;
    struct lcb_command_data_st ct;
    lcb_connection_t conn = &c->connection;
    lcb_t instance = c->instance;

    /* Check if we have the entire packet */
    nr = lcb_ringbuffer_peek(&conn->input.buffer->ringbuffer,
                             header.bytes, sizeof(header));
    if (nr < sizeof(header)) {
        return 0;
    }

    packetsize = ntohl(header.response.bodylen) + (lcb_uint32_t)sizeof(header);
    avail = lcb_ringbuffer_get_nbytes(&conn->input.buffer->ringbuffer);

    if (avail < packetsize) {
        /* We need more data! */
        return 0;
    }

    /* Is it already timed out? */
    nr = lcb_ringbuffer_peek(&c->cmd_log, req.bytes, sizeof(req));
    if (nr < sizeof(req) || /* the command log doesn't know about it */
            (header.response.opaque < req.request.opaque &&
             header.response.opaque > 0)) { /* sasl comes with zero opaque */
        /* already processed. */
        lcb_ringbuffer_consumed(&conn->input.buffer->ringbuffer, packetsize);
        return 1;
    }

    /* We've got the entire packet!! */
    assert(header.response.magic == PROTOCOL_BINARY_RES);

    nr = lcb_ringbuffer_peek(&c->output_cookies, &ct, sizeof(ct));
    if (nr != sizeof(ct)) {
        lcb_error_handler(c->instance, LCB_EINTERNAL, NULL);
        return -1;
    }
    ct.vbucket = ntohs(req.request.vbucket);

    if (lcb_server_purge_implicit_responses(c, header.response.opaque, stop, 0)) {
        return -1;
    }

    if (c->instance->histogram) {
        lcb_record_metrics(c->instance, stop - ct.start,
                           header.response.opcode);
    }

    status = ntohs(header.response.status);
    if (status != PROTOCOL_BINARY_RESPONSE_NOT_MY_VBUCKET ||
            header.response.opcode == CMD_GET_REPLICA ||
            header.response.opcode == CMD_OBSERVE) {
        /* Prepare the callback data */
        lcb_packet_fwd_resp_t resp;
        lcb_error_t err = LCB_SUCCESS;
        resp.version = 0;
        resp.v.v0.buffer = conn->input.buffer;
        lcb_ringbuffer_get_iov(&resp.v.v0.buffer->ringbuffer,
                               LCB_RINGBUFFER_READ,
                               resp.v.v0.iov);
        /* The IOV should only contain the exact bits for the packet */
        if (resp.v.v0.iov[0].iov_len > packetsize) {
            resp.v.v0.iov[0].iov_len = packetsize;
            resp.v.v0.iov[1].iov_len = 0;
        } else {
            resp.v.v0.iov[1].iov_len = packetsize - resp.v.v0.iov[0].iov_len;
        }

        /* fire the callback */
        conn->input.locked |= instance->callbacks.packet_fwd(instance,
                              ct.cookie,
                              err,
                              &resp);
        lcb_ringbuffer_consumed(&conn->input.buffer->ringbuffer, packetsize);

        /* keep command and cookie until we get complete STAT response */
        swallow_command(c, &header, was_connected);

    } else {
        int rv = handle_not_my_vbucket(c, &req, &ct);
        if (rv == -1) {
            return -1;
        } else if (rv == 0) {
            /* Prepare the callback data */
            lcb_packet_fwd_resp_t resp;
            lcb_error_t err = LCB_SUCCESS;
            resp.version = 0;
            resp.v.v0.buffer = conn->input.buffer;
            lcb_ringbuffer_get_iov(&resp.v.v0.buffer->ringbuffer,
                                   LCB_RINGBUFFER_READ,
                                   resp.v.v0.iov);

            /* The IOV should only contain the exact bits for the packet */
            if (resp.v.v0.iov[0].iov_len > packetsize) {
                resp.v.v0.iov[0].iov_len = packetsize;
                resp.v.v0.iov[1].iov_len = 0;
            } else {
                resp.v.v0.iov[1].iov_len = packetsize - resp.v.v0.iov[0].iov_len;
            }

            /* fire the callback */
            conn->input.locked |= instance->callbacks.packet_fwd(instance,
                                  ct.cookie,
                                  err,
                                  &resp);
            lcb_ringbuffer_consumed(&conn->input.buffer->ringbuffer, packetsize);

            /* keep command and cookie until we get complete STAT response */
            swallow_command(c, &header, was_connected);
        }

    }

    return 1;
}
int lcb_proto_parse_single(lcb_server_t *c, hrtime_t stop)
{
    int rv;
    packet_info info;
    protocol_binary_request_header req;
    lcb_size_t nr;
    lcb_connection_t conn = &c->connection;

    rv = lcb_packet_read_ringbuffer(&info, conn->input);
    if (rv == -1) {
        return -1;
    } else if (rv == 0) {
        return 0;
    }

    /* Is it already timed out? */
    nr = ringbuffer_peek(&c->cmd_log, req.bytes, sizeof(req));
    if (nr < sizeof(req) || /* the command log doesn't know about it */
            (PACKET_OPAQUE(&info) < req.request.opaque &&
             PACKET_OPAQUE(&info) > 0)) { /* sasl comes with zero opaque */
        /* already processed. */
        lcb_packet_release_ringbuffer(&info, conn->input);
        return 1;
    }


    nr = ringbuffer_peek(&c->output_cookies, &info.ct, sizeof(info.ct));
    if (nr != sizeof(info.ct)) {
        lcb_error_handler(c->instance, LCB_EINTERNAL, NULL);
        lcb_packet_release_ringbuffer(&info, conn->input);
        return -1;
    }
    info.ct.vbucket = ntohs(req.request.vbucket);

    switch (info.res.response.magic) {
    case PROTOCOL_BINARY_REQ:
        /*
         * The only way to get request packets is if someone started
         * to send us TAP requests, and we don't support that anymore
         */
        lcb_error_handler(c->instance, LCB_EINTERNAL,
                          "Protocol error. someone sent us a command!");
        return -1;
    case PROTOCOL_BINARY_RES: {
        int was_connected = c->connection_ready;
        rv = lcb_server_purge_implicit_responses(c,
                PACKET_OPAQUE(&info),
                stop, 0);
        if (rv != 0) {
            lcb_packet_release_ringbuffer(&info, conn->input);
            return -1;
        }

        if (c->instance->histogram) {
            lcb_record_metrics(c->instance, stop - info.ct.start,
                               PACKET_OPCODE(&info));
        }

        if (PACKET_STATUS(&info) != PROTOCOL_BINARY_RESPONSE_NOT_MY_VBUCKET
                || PACKET_OPCODE(&info) == CMD_GET_REPLICA
                || PACKET_OPCODE(&info) == CMD_OBSERVE) {
            rv = lcb_dispatch_response(c, &info);
            if (rv == -1) {
                lcb_error_handler(c->instance, LCB_EINTERNAL,
                                  "Received unknown command response");
                abort();
                return -1;
            }

            /* keep command and cookie until we get complete STAT response */
            swallow_command(c, &info.res, was_connected);

        } else {
            rv = handle_not_my_vbucket(c, &info, &req, &info.ct);

            if (rv == -1) {
                return -1;

            } else if (rv == 0) {
                lcb_dispatch_response(c, &info);
                swallow_command(c, &info.res, was_connected);
            }

        }
        break;
    }

    default:
        lcb_error_handler(c->instance, LCB_PROTOCOL_ERROR, NULL);
        lcb_packet_release_ringbuffer(&info, conn->input);
        return -1;
    }

    lcb_packet_release_ringbuffer(&info, conn->input);
    return 1;
}
Beispiel #3
0
static int lcb_parse_single_with_specialized_callbacks(lcb_server_t *c,
        hrtime_t stop)
{
    protocol_binary_request_header req;
    protocol_binary_response_header header;
    lcb_size_t nr;
    char *packet;
    lcb_size_t packetsize;
    struct lcb_command_data_st ct;
    lcb_connection_t conn = &c->connection;

    if (lcb_ringbuffer_ensure_alignment(&conn->input.buffer->ringbuffer) != 0) {
        lcb_error_handler(c->instance, LCB_EINTERNAL,
                          NULL);
        return -1;
    }

    nr = lcb_ringbuffer_peek(&conn->input.buffer->ringbuffer,
                             header.bytes, sizeof(header));
    if (nr < sizeof(header)) {
        return 0;
    }

    packetsize = ntohl(header.response.bodylen) + (lcb_uint32_t)sizeof(header);
    if (conn->input.buffer->ringbuffer.nbytes < packetsize) {
        return 0;
    }

    /* Is it already timed out? */
    nr = lcb_ringbuffer_peek(&c->cmd_log, req.bytes, sizeof(req));
    if (nr < sizeof(req) || /* the command log doesn't know about it */
            (header.response.opaque < req.request.opaque &&
             header.response.opaque > 0)) { /* sasl comes with zero opaque */
        /* already processed. */
        lcb_ringbuffer_consumed(&conn->input.buffer->ringbuffer, packetsize);
        return 1;
    }

    packet = conn->input.buffer->ringbuffer.read_head;
    /* we have everything! */

    if (!lcb_ringbuffer_is_continous(&conn->input.buffer->ringbuffer,
                                     LCB_RINGBUFFER_READ, packetsize)) {
        /* The buffer isn't continous.. for now just copy it out and
        ** operate on the copy ;)
        */
        if ((packet = malloc(packetsize)) == NULL) {
            lcb_error_handler(c->instance, LCB_CLIENT_ENOMEM, NULL);
            return -1;
        }
        nr = lcb_ringbuffer_read(&conn->input.buffer->ringbuffer, packet, packetsize);
        if (nr != packetsize) {
            lcb_error_handler(c->instance, LCB_EINTERNAL,
                              NULL);
            free(packet);
            return -1;
        }
    }

    nr = lcb_ringbuffer_peek(&c->output_cookies, &ct, sizeof(ct));
    if (nr != sizeof(ct)) {
        lcb_error_handler(c->instance, LCB_EINTERNAL,
                          NULL);
        if (packet != conn->input.buffer->ringbuffer.read_head) {
            free(packet);
        }
        return -1;
    }
    ct.vbucket = ntohs(req.request.vbucket);

    switch (header.response.magic) {
    case PROTOCOL_BINARY_REQ:
        /*
         * The only way to get request packets is if someone started
         * to send us TAP requests, and we don't support that anymore
         */
        lcb_error_handler(c->instance, LCB_EINTERNAL,
                          "Protocol error. someone sent us a command!");
        return -1;
    case PROTOCOL_BINARY_RES: {
        int was_connected = c->connection_ready;
        if (lcb_server_purge_implicit_responses(c, header.response.opaque, stop, 0) != 0) {
            if (packet != conn->input.buffer->ringbuffer.read_head) {
                free(packet);
            }
            return -1;
        }

        if (c->instance->histogram) {
            lcb_record_metrics(c->instance, stop - ct.start,
                               header.response.opcode);
        }

        if (ntohs(header.response.status) != PROTOCOL_BINARY_RESPONSE_NOT_MY_VBUCKET
                || header.response.opcode == CMD_GET_REPLICA
                || header.response.opcode == CMD_OBSERVE) {
            if (lcb_dispatch_response(c, &ct, (void *)packet) == -1) {
                /*
                 * Internal error.. we received an unsupported response
                 * id. This should _ONLY_ happen at development time because
                 * we won't receive response packets with other opcodes
                 * than we send. Let's abort here to make it easy for
                 * the developer to know what happened..
                 */
                lcb_error_handler(c->instance, LCB_EINTERNAL,
                                  "Received unknown command response");
                abort();
                return -1;
            }

            /* keep command and cookie until we get complete STAT response */
            swallow_command(c, &header, was_connected);

        } else {
            int rv = handle_not_my_vbucket(c, &req, &ct);

            if (rv == -1) {
                return -1;

            } else if (rv == 0) {
                lcb_dispatch_response(c, &ct, (void *)packet);
                swallow_command(c, &header, was_connected);
            }

        }
        break;
    }

    default:
        lcb_error_handler(c->instance,
                          LCB_PROTOCOL_ERROR,
                          NULL);
        if (packet != conn->input.buffer->ringbuffer.read_head) {
            free(packet);
        }
        return -1;
    }

    if (packet != conn->input.buffer->ringbuffer.read_head) {
        free(packet);
    } else {
        lcb_ringbuffer_consumed(&conn->input.buffer->ringbuffer, packetsize);
    }
    return 1;
}