| /* |
| Copyright (c) 2013 250bpm s.r.o. All rights reserved. |
| Copyright (c) 2014 Wirebird Labs LLC. All rights reserved. |
| |
| Permission is hereby granted, free of charge, to any person obtaining a copy |
| of this software and associated documentation files (the "Software"), |
| to deal in the Software without restriction, including without limitation |
| the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| and/or sell copies of the Software, and to permit persons to whom |
| the Software is furnished to do so, subject to the following conditions: |
| |
| The above copyright notice and this permission notice shall be included |
| in all copies or substantial portions of the Software. |
| |
| THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS |
| IN THE SOFTWARE. |
| */ |
| |
| #include "wshdr.h" |
| #include "sha1.h" |
| |
| #include "../../aio/timer.h" |
| |
| #include "../../core/sock.h" |
| |
| #include "../utils/base64.h" |
| |
| #include "../../utils/alloc.h" |
| #include "../../utils/err.h" |
| #include "../../utils/cont.h" |
| #include "../../utils/fast.h" |
| #include "../../utils/wire.h" |
| #include "../../utils/attr.h" |
| #include "../../utils/random.h" |
| |
| #include <stddef.h> |
| #include <string.h> |
| #include <ctype.h> |
| |
| /* State machine finite states. */ |
| #define NN_WSHDR_STATE_IDLE 1 |
| #define NN_WSHDR_STATE_SERVER_RECV 2 |
| #define NN_WSHDR_STATE_SERVER_REPLY 3 |
| #define NN_WSHDR_STATE_CLIENT_SEND 4 |
| #define NN_WSHDR_STATE_CLIENT_RECV 5 |
| #define NN_WSHDR_STATE_HANDSHAKE_SENT 6 |
| #define NN_WSHDR_STATE_STOPPING_TIMER_ERROR 7 |
| #define NN_WSHDR_STATE_STOPPING_TIMER_DONE 8 |
| #define NN_WSHDR_STATE_DONE 9 |
| #define NN_WSHDR_STATE_STOPPING 10 |
| |
| /* Subordinate srcptr objects. */ |
| #define NN_WSHDR_SRC_USOCK 1 |
| #define NN_WSHDR_SRC_TIMER 2 |
| |
| /* Time allowed to complete handshake. */ |
| #define NN_WSHDR_TIMEOUT 5000 |
| |
| /* Possible return codes internal to the parsing operations. */ |
| #define NN_WSHDR_NOMATCH 0 |
| #define NN_WSHDR_MATCH 1 |
| |
| /* Possible return codes from parsing opening handshake from peer. */ |
| #define NN_WSHDR_VALID 0 |
| #define NN_WSHDR_RECV_MORE 1 |
| #define NN_WSHDR_INVALID -1 |
| |
| /* Possible handshake responses to send to client when acting as server. */ |
| #define NN_WSHDR_RESPONSE_NULL -1 |
| #define NN_WSHDR_RESPONSE_OK 0 |
| #define NN_WSHDR_RESPONSE_TOO_BIG 1 |
| #define NN_WSHDR_RESPONSE_UNUSED2 2 |
| #define NN_WSHDR_RESPONSE_WSPROTO 3 |
| #define NN_WSHDR_RESPONSE_WSVERSION 4 |
| #define NN_WSHDR_RESPONSE_NNPROTO 5 |
| #define NN_WSHDR_RESPONSE_NOTPEER 6 |
| #define NN_WSHDR_RESPONSE_UNKNOWNTYPE 7 |
| |
| /* WebSocket protocol tokens as per RFC 6455. */ |
| #define NN_WSHDR_CRLF "\r\n" |
| #define NN_WSHDR_TERMSEQ "\r\n\r\n" |
| #define NN_WSHDR_TERMSEQ_LEN 4 |
| |
| /* Size of minimal valid handshare request and reply. This amount of bytes |
| is read initially so that we don't have to read the whole handshake |
| in one-byte-at-a-time manner. */ |
| #define NN_WSHDR_REQ_MIN_SIZE 150 |
| #define NN_WSHDR_REP_MIN_SIZE 16 |
| |
| /* Private functions. */ |
| static void nn_wshdr_handler (struct nn_fsm *self, int src, int type, |
| void *srcptr); |
| static void nn_wshdr_shutdown (struct nn_fsm *self, int src, int type, |
| void *srcptr); |
| static void nn_wshdr_leave (struct nn_wshdr *self, int rc); |
| |
| /* Private functions. */ |
| static int nn_wshdr_parse_client_opening (struct nn_wshdr *self); |
| static void nn_wshdr_server_reply (struct nn_wshdr *self); |
| static void nn_wshdr_client_request (struct nn_wshdr *self); |
| static int nn_wshdr_parse_server_response (struct nn_wshdr *self); |
| static int nn_wshdr_hash_key (const uint8_t *key, size_t key_len, |
| uint8_t *hashed, size_t hashed_len); |
| static int nn_ws_match_token (const char* token, const char **subj, |
| int case_insensitive); |
| static int nn_ws_match_value (const char* termseq, const char **subj, |
| int ignore_leading_sp, int ignore_trailing_sp, const uint8_t **addr, |
| size_t* const len); |
| static int nn_ws_validate_value (const char* expected, const uint8_t *subj, |
| size_t subj_len, int case_insensitive); |
| |
| void nn_wshdr_init (struct nn_wshdr *self, int src, |
| struct nn_fsm *owner) |
| { |
| nn_fsm_init (&self->fsm, nn_wshdr_handler, nn_wshdr_shutdown, |
| src, self, owner); |
| self->state = NN_WSHDR_STATE_IDLE; |
| nn_timer_init (&self->timer, NN_WSHDR_SRC_TIMER, &self->fsm); |
| nn_fsm_event_init (&self->done); |
| self->timeout = NN_WSHDR_TIMEOUT; |
| self->usock = NULL; |
| self->usock_owner.src = -1; |
| self->usock_owner.fsm = NULL; |
| self->pipebase = NULL; |
| } |
| |
| void nn_wshdr_term (struct nn_wshdr *self) |
| { |
| nn_assert_state (self, NN_WSHDR_STATE_IDLE); |
| |
| nn_fsm_event_term (&self->done); |
| nn_timer_term (&self->timer); |
| nn_fsm_term (&self->fsm); |
| } |
| |
| int nn_wshdr_isidle (struct nn_wshdr *self) |
| { |
| return nn_fsm_isidle (&self->fsm); |
| } |
| |
| void nn_wshdr_start (struct nn_wshdr *self, |
| struct nn_usock *usock, struct nn_pipebase *pipebase, |
| int mode, const char *resource, const char *host) |
| { |
| /* It's expected this resource has been allocated during intial connect. */ |
| if (mode == NN_WS_CLIENT) |
| nn_assert (strlen (resource) >= 1); |
| |
| /* Take ownership of the underlying socket. */ |
| nn_assert (self->usock == NULL && self->usock_owner.fsm == NULL); |
| self->usock_owner.src = NN_WSHDR_SRC_USOCK; |
| self->usock_owner.fsm = &self->fsm; |
| nn_usock_swap_owner (usock, &self->usock_owner); |
| self->usock = usock; |
| self->pipebase = pipebase; |
| self->mode = mode; |
| self->resource = resource; |
| self->remote_host = host; |
| |
| memset (self->opening_hs, 0, sizeof (self->opening_hs)); |
| memset (self->response, 0, sizeof (self->response)); |
| |
| self->recv_pos = 0; |
| self->retries = 0; |
| |
| /* Launch the state machine. */ |
| nn_fsm_start (&self->fsm); |
| } |
| |
| void nn_wshdr_stop (struct nn_wshdr *self) |
| { |
| nn_fsm_stop (&self->fsm); |
| } |
| |
| static void nn_wshdr_shutdown (struct nn_fsm *self, int src, int type, |
| NN_UNUSED void *srcptr) |
| { |
| struct nn_wshdr *wshdr; |
| |
| wshdr = nn_cont (self, struct nn_wshdr, fsm); |
| |
| if (nn_slow (src == NN_FSM_ACTION && type == NN_FSM_STOP)) { |
| nn_timer_stop (&wshdr->timer); |
| wshdr->state = NN_WSHDR_STATE_STOPPING; |
| } |
| if (nn_slow (wshdr->state == NN_WSHDR_STATE_STOPPING)) { |
| if (!nn_timer_isidle (&wshdr->timer)) |
| return; |
| wshdr->state = NN_WSHDR_STATE_IDLE; |
| nn_fsm_stopped (&wshdr->fsm, NN_WSHDR_STOPPED); |
| return; |
| } |
| |
| nn_fsm_bad_state (wshdr->state, src, type); |
| } |
| |
| static void nn_wshdr_handler (struct nn_fsm *self, int src, int type, |
| NN_UNUSED void *srcptr) |
| { |
| struct nn_wshdr *wshdr; |
| |
| unsigned i; |
| |
| wshdr = nn_cont (self, struct nn_wshdr, fsm); |
| |
| switch (wshdr->state) { |
| |
| /******************************************************************************/ |
| /* IDLE state. */ |
| /******************************************************************************/ |
| case NN_WSHDR_STATE_IDLE: |
| switch (src) { |
| |
| case NN_FSM_ACTION: |
| switch (type) { |
| case NN_FSM_START: |
| |
| /* The timeout for the handshake to get rid of stuck or |
| DoS-attacking peers. */ |
| nn_timer_start (&wshdr->timer, wshdr->timeout); |
| |
| switch (wshdr->mode) { |
| case NN_WS_CLIENT: |
| |
| /* Send opening handshake to server. */ |
| wshdr->recv_len = NN_WSHDR_REP_MIN_SIZE; |
| nn_wshdr_client_request (wshdr); |
| wshdr->state = NN_WSHDR_STATE_CLIENT_SEND; |
| return; |
| |
| case NN_WS_SERVER: |
| |
| /* Begin receiving opening handshake from client. */ |
| wshdr->recv_len = NN_WSHDR_REQ_MIN_SIZE; |
| nn_usock_recv (wshdr->usock, wshdr->opening_hs, |
| wshdr->recv_len, NULL); |
| wshdr->state = NN_WSHDR_STATE_SERVER_RECV; |
| return; |
| |
| default: |
| /* Unexpected mode. */ |
| nn_assert (0); |
| return; |
| } |
| |
| default: |
| nn_fsm_bad_action (wshdr->state, src, type); |
| } |
| |
| default: |
| nn_fsm_bad_source (wshdr->state, src, type); |
| } |
| |
| /******************************************************************************/ |
| /* SERVER_RECV state. */ |
| /******************************************************************************/ |
| case NN_WSHDR_STATE_SERVER_RECV: |
| switch (src) { |
| |
| case NN_WSHDR_SRC_USOCK: |
| switch (type) { |
| case NN_USOCK_RECEIVED: |
| /* Parse bytes received thus far. */ |
| switch (nn_wshdr_parse_client_opening (wshdr)) { |
| case NN_WSHDR_INVALID: |
| /* Opening handshake parsed successfully but does not |
| contain valid values. Respond failure to client. */ |
| wshdr->state = NN_WSHDR_STATE_SERVER_REPLY; |
| nn_wshdr_server_reply (wshdr); |
| return; |
| case NN_WSHDR_VALID: |
| /* Opening handshake parsed successfully, and is valid. |
| Respond success to client. */ |
| wshdr->state = NN_WSHDR_STATE_SERVER_REPLY; |
| nn_wshdr_server_reply (wshdr); |
| return; |
| case NN_WSHDR_RECV_MORE: |
| /* Not enough bytes have been received to determine |
| validity; remain in the receive state, and retrieve |
| more bytes from client. */ |
| wshdr->recv_pos += wshdr->recv_len; |
| |
| /* Validate the previous recv operation. */ |
| nn_assert (wshdr->recv_pos < |
| sizeof (wshdr->opening_hs)); |
| |
| /* Ensure we can back-track at least the length of the |
| termination sequence to determine how many bytes to |
| receive on the next retry. This is an assertion, not |
| a conditional, since under no condition is it |
| necessary to initially receive so few bytes. */ |
| nn_assert (wshdr->recv_pos >= |
| (int) NN_WSHDR_TERMSEQ_LEN); |
| |
| for (i = NN_WSHDR_TERMSEQ_LEN; i >= 0; i--) { |
| if (memcmp (NN_WSHDR_TERMSEQ, |
| wshdr->opening_hs + wshdr->recv_pos - i, |
| i) == 0) { |
| break; |
| } |
| } |
| |
| nn_assert (i < NN_WSHDR_TERMSEQ_LEN); |
| |
| wshdr->recv_len = NN_WSHDR_TERMSEQ_LEN - i; |
| |
| /* In the unlikely case the client would overflow what we |
| assumed was a sufficiently-large buffer to receive the |
| handshake, we fail the client. */ |
| if (wshdr->recv_len + wshdr->recv_pos > |
| sizeof (wshdr->opening_hs)) { |
| wshdr->response_code = |
| NN_WSHDR_RESPONSE_TOO_BIG; |
| wshdr->state = |
| NN_WSHDR_STATE_SERVER_REPLY; |
| nn_wshdr_server_reply (wshdr); |
| } |
| else { |
| wshdr->retries++; |
| nn_usock_recv (wshdr->usock, |
| wshdr->opening_hs + wshdr->recv_pos, |
| wshdr->recv_len, NULL); |
| } |
| return; |
| default: |
| nn_fsm_error ("Unexpected handshake result", |
| wshdr->state, src, type); |
| } |
| return; |
| case NN_USOCK_SHUTDOWN: |
| /* Ignore it and wait for ERROR event. */ |
| return; |
| case NN_USOCK_ERROR: |
| nn_timer_stop (&wshdr->timer); |
| wshdr->state = NN_WSHDR_STATE_STOPPING_TIMER_ERROR; |
| return; |
| default: |
| nn_fsm_bad_action (wshdr->state, src, type); |
| } |
| |
| case NN_WSHDR_SRC_TIMER: |
| switch (type) { |
| case NN_TIMER_TIMEOUT: |
| nn_timer_stop (&wshdr->timer); |
| wshdr->state = NN_WSHDR_STATE_STOPPING_TIMER_ERROR; |
| return; |
| default: |
| nn_fsm_bad_action (wshdr->state, src, type); |
| } |
| |
| default: |
| nn_fsm_bad_source (wshdr->state, src, type); |
| } |
| |
| /******************************************************************************/ |
| /* SERVER_REPLY state. */ |
| /******************************************************************************/ |
| case NN_WSHDR_STATE_SERVER_REPLY: |
| switch (src) { |
| |
| case NN_WSHDR_SRC_USOCK: |
| switch (type) { |
| case NN_USOCK_SENT: |
| /* As per RFC 6455 4.2.2, the handshake is now complete |
| and the connection is immediately ready for send/recv. */ |
| nn_timer_stop (&wshdr->timer); |
| wshdr->state = NN_WSHDR_STATE_STOPPING_TIMER_DONE; |
| case NN_USOCK_SHUTDOWN: |
| /* Ignore it and wait for ERROR event. */ |
| return; |
| case NN_USOCK_ERROR: |
| nn_timer_stop (&wshdr->timer); |
| wshdr->state = NN_WSHDR_STATE_STOPPING_TIMER_ERROR; |
| return; |
| default: |
| nn_fsm_bad_action (wshdr->state, src, type); |
| } |
| |
| case NN_WSHDR_SRC_TIMER: |
| switch (type) { |
| case NN_TIMER_TIMEOUT: |
| nn_timer_stop (&wshdr->timer); |
| wshdr->state = NN_WSHDR_STATE_STOPPING_TIMER_ERROR; |
| return; |
| default: |
| nn_fsm_bad_action (wshdr->state, src, type); |
| } |
| |
| default: |
| nn_fsm_bad_source (wshdr->state, src, type); |
| } |
| |
| /******************************************************************************/ |
| /* CLIENT_SEND state. */ |
| /******************************************************************************/ |
| case NN_WSHDR_STATE_CLIENT_SEND: |
| switch (src) { |
| |
| case NN_WSHDR_SRC_USOCK: |
| switch (type) { |
| case NN_USOCK_SENT: |
| wshdr->state = NN_WSHDR_STATE_CLIENT_RECV; |
| nn_usock_recv (wshdr->usock, wshdr->response, |
| wshdr->recv_len, NULL); |
| return; |
| case NN_USOCK_SHUTDOWN: |
| /* Ignore it and wait for ERROR event. */ |
| return; |
| case NN_USOCK_ERROR: |
| nn_timer_stop (&wshdr->timer); |
| wshdr->state = NN_WSHDR_STATE_STOPPING_TIMER_ERROR; |
| return; |
| default: |
| nn_fsm_bad_action (wshdr->state, src, type); |
| } |
| |
| case NN_WSHDR_SRC_TIMER: |
| switch (type) { |
| case NN_TIMER_TIMEOUT: |
| nn_timer_stop (&wshdr->timer); |
| wshdr->state = NN_WSHDR_STATE_STOPPING_TIMER_ERROR; |
| return; |
| default: |
| nn_fsm_bad_action (wshdr->state, src, type); |
| } |
| |
| default: |
| nn_fsm_bad_source (wshdr->state, src, type); |
| } |
| |
| /******************************************************************************/ |
| /* CLIENT_RECV state. */ |
| /******************************************************************************/ |
| case NN_WSHDR_STATE_CLIENT_RECV: |
| switch (src) { |
| |
| case NN_WSHDR_SRC_USOCK: |
| switch (type) { |
| case NN_USOCK_RECEIVED: |
| /* Parse bytes received thus far. */ |
| switch (nn_wshdr_parse_server_response (wshdr)) { |
| case NN_WSHDR_INVALID: |
| /* Opening handshake parsed successfully but does not |
| contain valid values. Fail connection. */ |
| nn_timer_stop (&wshdr->timer); |
| wshdr->state = |
| NN_WSHDR_STATE_STOPPING_TIMER_ERROR; |
| return; |
| case NN_WSHDR_VALID: |
| /* As per RFC 6455 4.2.2, the handshake is now complete |
| and the connection is immediately ready for send/recv. */ |
| nn_timer_stop (&wshdr->timer); |
| wshdr->state = NN_WSHDR_STATE_STOPPING_TIMER_DONE; |
| return; |
| case NN_WSHDR_RECV_MORE: |
| /* Not enough bytes have been received to determine |
| validity; remain in the receive state, and retrieve |
| more bytes from client. */ |
| wshdr->recv_pos += wshdr->recv_len; |
| |
| /* Validate the previous recv operation. */ |
| nn_assert (wshdr->recv_pos < |
| sizeof (wshdr->response)); |
| |
| /* Ensure we can back-track at least the length of the |
| termination sequence to determine how many bytes to |
| receive on the next retry. This is an assertion, not |
| a conditional, since under no condition is it |
| necessary to initially receive so few bytes. */ |
| nn_assert (wshdr->recv_pos >= |
| (int) NN_WSHDR_TERMSEQ_LEN); |
| |
| for (i = NN_WSHDR_TERMSEQ_LEN; i >= 0; i--) { |
| if (memcmp (NN_WSHDR_TERMSEQ, |
| wshdr->response + wshdr->recv_pos - i, |
| i) == 0) { |
| break; |
| } |
| } |
| |
| nn_assert (i < NN_WSHDR_TERMSEQ_LEN); |
| |
| wshdr->recv_len = NN_WSHDR_TERMSEQ_LEN - i; |
| |
| /* In the unlikely case the client would overflow what we |
| assumed was a sufficiently-large buffer to receive the |
| handshake, we fail the connection. */ |
| if (wshdr->recv_len + wshdr->recv_pos > |
| sizeof (wshdr->response)) { |
| nn_timer_stop (&wshdr->timer); |
| wshdr->state = |
| NN_WSHDR_STATE_STOPPING_TIMER_ERROR; |
| } |
| else { |
| wshdr->retries++; |
| nn_usock_recv (wshdr->usock, |
| wshdr->response + wshdr->recv_pos, |
| wshdr->recv_len, NULL); |
| } |
| return; |
| default: |
| nn_fsm_error ("Unexpected handshake result", |
| wshdr->state, src, type); |
| } |
| return; |
| case NN_USOCK_SHUTDOWN: |
| /* Ignore it and wait for ERROR event. */ |
| return; |
| case NN_USOCK_ERROR: |
| nn_timer_stop (&wshdr->timer); |
| wshdr->state = NN_WSHDR_STATE_STOPPING_TIMER_ERROR; |
| return; |
| default: |
| nn_fsm_bad_action (wshdr->state, src, type); |
| } |
| |
| case NN_WSHDR_SRC_TIMER: |
| switch (type) { |
| case NN_TIMER_TIMEOUT: |
| nn_timer_stop (&wshdr->timer); |
| wshdr->state = NN_WSHDR_STATE_STOPPING_TIMER_ERROR; |
| return; |
| default: |
| nn_fsm_bad_action (wshdr->state, src, type); |
| } |
| |
| default: |
| nn_fsm_bad_source (wshdr->state, src, type); |
| } |
| |
| /******************************************************************************/ |
| /* HANDSHAKE_SENT state. */ |
| /******************************************************************************/ |
| case NN_WSHDR_STATE_HANDSHAKE_SENT: |
| switch (src) { |
| |
| case NN_WSHDR_SRC_USOCK: |
| switch (type) { |
| case NN_USOCK_SENT: |
| /* As per RFC 6455 4.2.2, the handshake is now complete |
| and the connection is immediately ready for send/recv. */ |
| nn_timer_stop (&wshdr->timer); |
| wshdr->state = NN_WSHDR_STATE_STOPPING_TIMER_DONE; |
| return; |
| case NN_USOCK_SHUTDOWN: |
| /* Ignore it and wait for ERROR event. */ |
| return; |
| case NN_USOCK_ERROR: |
| nn_timer_stop (&wshdr->timer); |
| wshdr->state = NN_WSHDR_STATE_STOPPING_TIMER_ERROR; |
| return; |
| default: |
| nn_fsm_bad_action (wshdr->state, src, type); |
| } |
| |
| case NN_WSHDR_SRC_TIMER: |
| switch (type) { |
| case NN_TIMER_TIMEOUT: |
| nn_timer_stop (&wshdr->timer); |
| wshdr->state = NN_WSHDR_STATE_STOPPING_TIMER_ERROR; |
| return; |
| default: |
| nn_fsm_bad_action (wshdr->state, src, type); |
| } |
| |
| default: |
| nn_fsm_bad_source (wshdr->state, src, type); |
| } |
| |
| /******************************************************************************/ |
| /* STOPPING_TIMER_ERROR state. */ |
| /******************************************************************************/ |
| case NN_WSHDR_STATE_STOPPING_TIMER_ERROR: |
| switch (src) { |
| |
| case NN_WSHDR_SRC_USOCK: |
| /* Ignore. The only circumstance the client would send bytes is |
| to notify the server it is closing the connection. Wait for the |
| socket to eventually error. */ |
| return; |
| |
| case NN_WSHDR_SRC_TIMER: |
| switch (type) { |
| case NN_TIMER_STOPPED: |
| nn_wshdr_leave (wshdr, NN_WSHDR_ERROR); |
| return; |
| default: |
| nn_fsm_bad_action (wshdr->state, src, type); |
| } |
| |
| default: |
| nn_fsm_bad_source (wshdr->state, src, type); |
| } |
| |
| /******************************************************************************/ |
| /* STOPPING_TIMER_DONE state. */ |
| /******************************************************************************/ |
| case NN_WSHDR_STATE_STOPPING_TIMER_DONE: |
| switch (src) { |
| |
| case NN_WSHDR_SRC_USOCK: |
| /* Ignore. The only circumstance the client would send bytes is |
| to notify the server it is closing the connection. Wait for the |
| socket to eventually error. */ |
| return; |
| |
| case NN_WSHDR_SRC_TIMER: |
| switch (type) { |
| case NN_TIMER_STOPPED: |
| nn_wshdr_leave (wshdr, NN_WSHDR_OK); |
| return; |
| default: |
| nn_fsm_bad_action (wshdr->state, src, type); |
| } |
| |
| default: |
| nn_fsm_bad_source (wshdr->state, src, type); |
| } |
| |
| /******************************************************************************/ |
| /* DONE state. */ |
| /* The header exchange was either done successfully of failed. There's */ |
| /* nothing that can be done in this state except stopping the object. */ |
| /******************************************************************************/ |
| case NN_WSHDR_STATE_DONE: |
| nn_fsm_bad_source (wshdr->state, src, type); |
| |
| /******************************************************************************/ |
| /* Invalid state. */ |
| /******************************************************************************/ |
| default: |
| nn_fsm_bad_state (wshdr->state, src, type); |
| } |
| } |
| |
| /******************************************************************************/ |
| /* State machine actions. */ |
| /******************************************************************************/ |
| |
| /* Get the state machine into the terminal state. */ |
| static void nn_wshdr_leave (struct nn_wshdr *self, int rc) |
| { |
| nn_usock_swap_owner (self->usock, &self->usock_owner); |
| self->usock = NULL; |
| self->usock_owner.src = -1; |
| self->usock_owner.fsm = NULL; |
| self->state = NN_WSHDR_STATE_DONE; |
| nn_fsm_raise (&self->fsm, &self->done, rc); |
| } |
| |
| static int nn_wshdr_parse_client_opening (struct nn_wshdr *self) |
| { |
| /* As per RFC 6455 section 1.7, this parser is not intended to be a |
| general-purpose parser for arbitrary HTTP headers. As with the design |
| philosophy of nanomsg, application-specific exchanges are better |
| reserved for accepted connections, not as fields within these |
| headers. */ |
| |
| int rc; |
| const char *pos; |
| unsigned i; |
| int id; |
| |
| /* Guarantee that a NULL terminator exists to enable treating this |
| recv buffer like a string. */ |
| nn_assert (memchr (self->opening_hs, '\0', sizeof (self->opening_hs))); |
| |
| /* Having found the NULL terminator, from this point forward string |
| functions may be used. */ |
| nn_assert (strlen (self->opening_hs) < sizeof (self->opening_hs)); |
| |
| pos = self->opening_hs; |
| |
| /* Is the opening handshake from the client fully received? */ |
| if (!strstr (pos, NN_WSHDR_TERMSEQ)) |
| return NN_WSHDR_RECV_MORE; |
| |
| self->host = NULL; |
| self->origin = NULL; |
| self->key = NULL; |
| self->upgrade = NULL; |
| self->conn = NULL; |
| self->version = NULL; |
| self->protocol = NULL; |
| self->uri = NULL; |
| |
| self->host_len = 0; |
| self->origin_len = 0; |
| self->key_len = 0; |
| self->upgrade_len = 0; |
| self->conn_len = 0; |
| self->version_len = 0; |
| self->protocol_len = 0; |
| self->uri_len = 0; |
| |
| /* This function, if generating a return value that triggers |
| a response to the client, should replace this sentinel value |
| with a proper response code. */ |
| self->response_code = NN_WSHDR_RESPONSE_NULL; |
| |
| /* RFC 7230 3.1.1 Request Line: HTTP Method |
| Note requirement of one space and case sensitivity. */ |
| if (!nn_ws_match_token ("GET\x20", &pos, 0)) |
| return NN_WSHDR_RECV_MORE; |
| |
| /* RFC 7230 3.1.1 Request Line: Requested Resource. */ |
| if (!nn_ws_match_value ("\x20", &pos, 0, 0, &self->uri, &self->uri_len)) |
| return NN_WSHDR_RECV_MORE; |
| |
| /* RFC 7230 3.1.1 Request Line: HTTP version. Note case sensitivity. */ |
| if (!nn_ws_match_token ("HTTP/1.1", &pos, 0)) |
| return NN_WSHDR_RECV_MORE; |
| if (!nn_ws_match_token (NN_WSHDR_CRLF, &pos, 0)) |
| return NN_WSHDR_RECV_MORE; |
| |
| /* It's expected the current position is now at the first |
| header field. Match them one by one. */ |
| while (strlen (pos)) |
| { |
| if (nn_ws_match_token ("Host:", &pos, 1)) { |
| rc = nn_ws_match_value (NN_WSHDR_CRLF, &pos, 1, 1, |
| &self->host, &self->host_len); |
| } |
| else if (nn_ws_match_token ("Origin:", |
| &pos, 1) == NN_WSHDR_MATCH) { |
| rc = nn_ws_match_value (NN_WSHDR_CRLF, &pos, 1, 1, |
| &self->origin, &self->origin_len); |
| } |
| else if (nn_ws_match_token ("Sec-WebSocket-Key:", |
| &pos, 1) == NN_WSHDR_MATCH) { |
| rc = nn_ws_match_value (NN_WSHDR_CRLF, &pos, 1, 1, |
| &self->key, &self->key_len); |
| } |
| else if (nn_ws_match_token ("Upgrade:", |
| &pos, 1) == NN_WSHDR_MATCH) { |
| rc = nn_ws_match_value (NN_WSHDR_CRLF, &pos, 1, 1, |
| &self->upgrade, &self->upgrade_len); |
| } |
| else if (nn_ws_match_token ("Connection:", |
| &pos, 1) == NN_WSHDR_MATCH) { |
| rc = nn_ws_match_value (NN_WSHDR_CRLF, &pos, 1, 1, |
| &self->conn, &self->conn_len); |
| } |
| else if (nn_ws_match_token ("Sec-WebSocket-Version:", |
| &pos, 1) == NN_WSHDR_MATCH) { |
| rc = nn_ws_match_value (NN_WSHDR_CRLF, &pos, 1, 1, |
| &self->version, &self->version_len); |
| } |
| else if (nn_ws_match_token ("Sec-WebSocket-Protocol:", |
| &pos, 1) == NN_WSHDR_MATCH) { |
| rc = nn_ws_match_value (NN_WSHDR_CRLF, &pos, 1, 1, |
| &self->protocol, &self->protocol_len); |
| } |
| else if (nn_ws_match_token ("Sec-WebSocket-Extensions:", |
| &pos, 1) == NN_WSHDR_MATCH) { |
| rc = nn_ws_match_value (NN_WSHDR_CRLF, &pos, 1, 1, |
| &self->extensions, &self->extensions_len); |
| } |
| else if (nn_ws_match_token (NN_WSHDR_CRLF, |
| &pos, 1) == NN_WSHDR_MATCH) { |
| /* Exit loop since all headers are parsed. */ |
| break; |
| } |
| else { |
| /* Skip unknown headers. */ |
| rc = nn_ws_match_value (NN_WSHDR_CRLF, &pos, 1, 1, |
| NULL, NULL); |
| } |
| |
| if (rc != NN_WSHDR_MATCH) |
| return NN_WSHDR_RECV_MORE; |
| } |
| |
| /* Validate the opening handshake is now fully parsed. Additionally, |
| as per RFC 6455 section 4.1, the client should not send additional data |
| after the opening handshake, so this assertion validates upstream recv |
| logic prevented this case. */ |
| nn_assert (strlen (pos) == 0); |
| |
| /* TODO: protocol expectations below this point are hard-coded here as |
| an initial design decision. Perhaps in the future these values should |
| be settable via compile time (or run-time socket) options? */ |
| |
| /* These header fields are required as per RFC 6455 section 4.1. */ |
| if (!self->host || !self->upgrade || !self->conn || |
| !self->key || !self->version || !self->protocol) { |
| self->response_code = NN_WSHDR_RESPONSE_WSPROTO; |
| return NN_WSHDR_INVALID; |
| } |
| |
| /* RFC 6455 section 4.2.1.6 (version December 2011). */ |
| if (nn_ws_validate_value ("13", self->version, |
| self->version_len, 1) != NN_WSHDR_MATCH) { |
| self->response_code = NN_WSHDR_RESPONSE_WSVERSION; |
| return NN_WSHDR_INVALID; |
| } |
| |
| /* RFC 6455 section 4.2.1.3 (version December 2011). */ |
| if (nn_ws_validate_value ("websocket", self->upgrade, |
| self->upgrade_len, 1) != NN_WSHDR_MATCH) { |
| self->response_code = NN_WSHDR_RESPONSE_WSPROTO; |
| return NN_WSHDR_INVALID; |
| } |
| |
| /* RFC 6455 section 4.2.1.4 (version December 2011). */ |
| if (nn_ws_validate_value ("Upgrade", self->conn, |
| self->conn_len, 1) != NN_WSHDR_MATCH) { |
| self->response_code = NN_WSHDR_RESPONSE_WSPROTO; |
| return NN_WSHDR_INVALID; |
| } |
| |
| /* At this point, client meets RFC 6455 compliance for opening handshake. |
| Now it's time to check nanomsg-imposed required handshake values. */ |
| |
| /* Valid protocol values start with SP- prefix. */ |
| if (self->protocol_len < 4 || memcmp (self->protocol, "SP-", 3) != 0) |
| return NN_WSHDR_INVALID; |
| |
| /* After the prefix there should be only decimal digits. |
| Compute the protocol ID along the way. */ |
| id = 0; |
| for (i = 3; i != self->protocol_len; ++i) { |
| if (self->protocol [i] < '0' || self->protocol [i] > '9') |
| return NN_WSHDR_INVALID; |
| id *= 10; |
| id += self->protocol [i] - '0'; |
| } |
| |
| /* No leading zeroes. */ |
| if (self->protocol_len > 4 && self->protocol [3] == '0') |
| return NN_WSHDR_INVALID; |
| |
| /* Check whether the peer speaks compatible SP protocol. */ |
| if (!nn_pipebase_ispeer (self->pipebase, id)) { |
| self->response_code = NN_WSHDR_RESPONSE_NOTPEER; |
| return NN_WSHDR_INVALID; |
| } |
| |
| /* Done. Handshake is valid. */ |
| self->response_code = NN_WSHDR_RESPONSE_OK; |
| return NN_WSHDR_VALID; |
| } |
| |
| static int nn_wshdr_parse_server_response (struct nn_wshdr *self) |
| { |
| /* As per RFC 6455 section 1.7, this parser is not intended to be a |
| general-purpose parser for arbitrary HTTP headers. As with the design |
| philosophy of nanomsg, application-specific exchanges are better |
| reserved for accepted connections, not as fields within these |
| headers. */ |
| |
| int rc; |
| const char *pos; |
| |
| /* Guarantee that a NULL terminator exists to enable treating this |
| recv buffer like a string. The lack of such would indicate a failure |
| upstream to catch a buffer overflow. */ |
| nn_assert (memchr (self->response, '\0', sizeof (self->response))); |
| |
| /* Having found the NULL terminator, from this point forward string |
| functions may be used. */ |
| nn_assert (strlen (self->response) < sizeof (self->response)); |
| |
| pos = self->response; |
| |
| /* Is the response from the server fully received? */ |
| if (!strstr (pos, NN_WSHDR_TERMSEQ)) |
| return NN_WSHDR_RECV_MORE; |
| |
| self->status_code = NULL; |
| self->reason_phrase = NULL; |
| self->server = NULL; |
| self->accept_key = NULL; |
| self->upgrade = NULL; |
| self->conn = NULL; |
| self->version = NULL; |
| self->protocol = NULL; |
| |
| self->status_code_len = 0; |
| self->reason_phrase_len = 0; |
| self->server_len = 0; |
| self->accept_key_len = 0; |
| self->upgrade_len = 0; |
| self->conn_len = 0; |
| self->version_len = 0; |
| self->protocol_len = 0; |
| |
| /* RFC 7230 3.1.2 Status Line: HTTP Version. */ |
| if (!nn_ws_match_token ("HTTP/1.1\x20", &pos, 0)) |
| return NN_WSHDR_RECV_MORE; |
| |
| /* RFC 7230 3.1.2 Status Line: Status Code. */ |
| if (!nn_ws_match_value ("\x20", &pos, 0, 0, &self->status_code, |
| &self->status_code_len)) |
| return NN_WSHDR_RECV_MORE; |
| |
| /* RFC 7230 3.1.2 Status Line: Reason Phrase. */ |
| if (!nn_ws_match_value (NN_WSHDR_CRLF, &pos, 0, 0, |
| &self->reason_phrase, &self->reason_phrase_len)) |
| return NN_WSHDR_RECV_MORE; |
| |
| /* It's expected the current position is now at the first |
| header field. Match them one by one. */ |
| while (strlen (pos)) |
| { |
| if (nn_ws_match_token ("Server:", &pos, 1)) { |
| rc = nn_ws_match_value (NN_WSHDR_CRLF, &pos, 1, 1, |
| &self->server, &self->server_len); |
| } |
| else if (nn_ws_match_token ("Sec-WebSocket-Accept:", |
| &pos, 1) == NN_WSHDR_MATCH) { |
| rc = nn_ws_match_value (NN_WSHDR_CRLF, &pos, 1, 1, |
| &self->accept_key, &self->accept_key_len); |
| } |
| else if (nn_ws_match_token ("Upgrade:", |
| &pos, 1) == NN_WSHDR_MATCH) { |
| rc = nn_ws_match_value (NN_WSHDR_CRLF, &pos, 1, 1, |
| &self->upgrade, &self->upgrade_len); |
| } |
| else if (nn_ws_match_token ("Connection:", |
| &pos, 1) == NN_WSHDR_MATCH) { |
| rc = nn_ws_match_value (NN_WSHDR_CRLF, &pos, 1, 1, |
| &self->conn, &self->conn_len); |
| } |
| else if (nn_ws_match_token ("Sec-WebSocket-Version-Server:", |
| &pos, 1) == NN_WSHDR_MATCH) { |
| rc = nn_ws_match_value (NN_WSHDR_CRLF, &pos, 1, 1, |
| &self->version, &self->version_len); |
| } |
| else if (nn_ws_match_token ("Sec-WebSocket-Protocol-Server:", |
| &pos, 1) == NN_WSHDR_MATCH) { |
| rc = nn_ws_match_value (NN_WSHDR_CRLF, &pos, 1, 1, |
| &self->protocol, &self->protocol_len); |
| } |
| else if (nn_ws_match_token ("Sec-WebSocket-Extensions:", |
| &pos, 1) == NN_WSHDR_MATCH) { |
| rc = nn_ws_match_value (NN_WSHDR_CRLF, &pos, 1, 1, |
| &self->extensions, &self->extensions_len); |
| } |
| else if (nn_ws_match_token (NN_WSHDR_CRLF, |
| &pos, 1) == NN_WSHDR_MATCH) { |
| /* Exit loop since all headers are parsed. */ |
| break; |
| } |
| else { |
| /* Skip unknown headers. */ |
| rc = nn_ws_match_value (NN_WSHDR_CRLF, &pos, 1, 1, |
| NULL, NULL); |
| } |
| |
| if (rc != NN_WSHDR_MATCH) |
| return NN_WSHDR_RECV_MORE; |
| } |
| |
| /* Validate the opening handshake is now fully parsed. Additionally, |
| as per RFC 6455 section 4.1, the client should not send additional data |
| after the opening handshake, so this assertion validates upstream recv |
| logic prevented this case. */ |
| nn_assert (strlen (pos) == 0); |
| |
| /* TODO: protocol expectations below this point are hard-coded here as |
| an initial design decision. Perhaps in the future these values should |
| be settable via compile time (or run-time socket) options? */ |
| |
| /* These header fields are required as per RFC 6455 4.2.2. */ |
| if (!self->status_code || !self->upgrade || !self->conn || |
| !self->accept_key) |
| return NN_WSHDR_INVALID; |
| |
| /* TODO: Currently, we only handle a successful connection upgrade. |
| Anything else is treated as a failed connection. |
| Consider handling other scenarios like 3xx redirects. */ |
| if (nn_ws_validate_value ("101", self->status_code, |
| self->status_code_len, 1) != NN_WSHDR_MATCH) |
| return NN_WSHDR_INVALID; |
| |
| /* RFC 6455 section 4.2.2.5.2 (version December 2011). */ |
| if (nn_ws_validate_value ("websocket", self->upgrade, |
| self->upgrade_len, 1) != NN_WSHDR_MATCH) |
| return NN_WSHDR_INVALID; |
| |
| /* RFC 6455 section 4.2.2.5.3 (version December 2011). */ |
| if (nn_ws_validate_value ("Upgrade", self->conn, |
| self->conn_len, 1) != NN_WSHDR_MATCH) |
| return NN_WSHDR_INVALID; |
| |
| /* RFC 6455 section 4.2.2.5.4 (version December 2011). */ |
| if (nn_ws_validate_value (self->expected_accept_key, self->accept_key, |
| self->accept_key_len, 1) != NN_WSHDR_MATCH) |
| return NN_WSHDR_INVALID; |
| |
| /* Server response meets RFC 6455 compliance for opening handshake. */ |
| return NN_WSHDR_VALID; |
| } |
| |
| /* Send the initial part of the handshake from client to server. */ |
| static void nn_wshdr_client_request (struct nn_wshdr *self) |
| { |
| int rc; |
| struct nn_iovec iov; |
| size_t encoded_key_len; |
| uint8_t rand_key [16]; |
| char encoded_key [25]; |
| |
| /* Generate random 16-byte key as per RFC 6455 4.1 */ |
| nn_random_generate (rand_key, sizeof (rand_key)); |
| |
| /* Convert the key into Base64. */ |
| rc = nn_base64_encode (rand_key, sizeof (rand_key), |
| encoded_key, sizeof (encoded_key)); |
| encoded_key_len = strlen (encoded_key); |
| nn_assert (encoded_key_len == sizeof (encoded_key) - 1); |
| |
| /* Pre-calculated expected Accept Key value as per |
| RFC 6455 section 4.2.2.5.4 (version December 2011). */ |
| rc = nn_wshdr_hash_key (encoded_key, encoded_key_len, |
| self->expected_accept_key, sizeof (self->expected_accept_key)); |
| nn_assert (rc == NN_WSHDR_ACCEPT_KEY_LEN); |
| |
| /* Generate the request. */ |
| iov.iov_base = self->opening_hs; |
| iov.iov_len = snprintf (self->opening_hs, |
| sizeof (self->opening_hs), |
| "GET %s HTTP/1.1\r\n" |
| "Host: %s\r\n" |
| "Upgrade: websocket\r\n" |
| "Connection: Upgrade\r\n" |
| "Sec-WebSocket-Key: %s\r\n" |
| "Sec-WebSocket-Version: 13\r\n" |
| "Sec-WebSocket-Protocol: SP-%d\r\n\r\n", |
| self->resource, |
| self->remote_host, |
| encoded_key, |
| (int) self->pipebase->sock->socktype->protocol); |
| nn_assert (iov.iov_len < sizeof (self->opening_hs)); |
| |
| /* Send the request to the peer. */ |
| nn_usock_send (self->usock, &iov, 1); |
| } |
| |
| static void nn_wshdr_server_reply (struct nn_wshdr *self) |
| { |
| struct nn_iovec iov; |
| char *code; |
| int rc; |
| |
| /* Allow room for NULL terminator. */ |
| char accept_key [NN_WSHDR_ACCEPT_KEY_LEN + 1]; |
| |
| if (self->response_code == NN_WSHDR_RESPONSE_OK) { |
| |
| /* Upgrade connection as per RFC 6455 section 4.2.2. */ |
| |
| rc = nn_wshdr_hash_key (self->key, self->key_len, |
| accept_key, sizeof (accept_key)); |
| nn_assert (strlen (accept_key) == NN_WSHDR_ACCEPT_KEY_LEN); |
| |
| iov.iov_base = &self->response; |
| iov.iov_len = snprintf (self->response, |
| sizeof (self->response), |
| "HTTP/1.1 101 Switching Protocols\r\n" |
| "Upgrade: websocket\r\n" |
| "Connection: Upgrade\r\n" |
| "Sec-WebSocket-Accept: %s\r\n" |
| "Sec-WebSocket-Protocol: %.*s\r\n\r\n", |
| accept_key, |
| (int) self->protocol_len, self->protocol); |
| nn_assert (iov.iov_len < sizeof (self->response)); |
| } |
| else { |
| |
| /* Fail the connection with a helpful hint. */ |
| switch (self->response_code) { |
| case NN_WSHDR_RESPONSE_TOO_BIG: |
| code = "400 Opening Handshake Too Long"; |
| break; |
| case NN_WSHDR_RESPONSE_WSPROTO: |
| code = "400 Cannot Have Body"; |
| break; |
| case NN_WSHDR_RESPONSE_WSVERSION: |
| code = "400 Unsupported WebSocket Version"; |
| break; |
| case NN_WSHDR_RESPONSE_NNPROTO: |
| code = "400 Missing nanomsg Required Headers"; |
| break; |
| case NN_WSHDR_RESPONSE_NOTPEER: |
| code = "400 Incompatible Socket Type"; |
| break; |
| case NN_WSHDR_RESPONSE_UNKNOWNTYPE: |
| code = "400 Unrecognized Socket Type"; |
| break; |
| default: |
| /* Unexpected failure response. */ |
| nn_assert (0); |
| break; |
| } |
| |
| /* Fail connection as per RFC 6455 4.4. */ |
| iov.iov_base = &self->response; |
| iov.iov_len = snprintf (self->response, |
| sizeof (self->response), |
| "HTTP/1.1 %s\r\n" |
| "Sec-WebSocket-Version: %.*s\r\n", |
| code, |
| (int) self->version_len, self->version); |
| nn_assert (iov.iov_len < sizeof (self->response)); |
| } |
| |
| /* Send the reply. */ |
| nn_usock_send (self->usock, &iov, 1); |
| } |
| |
| static int nn_wshdr_hash_key (const uint8_t *key, size_t key_len, |
| uint8_t *hashed, size_t hashed_len) |
| { |
| int rc; |
| unsigned i; |
| struct nn_sha1 hash; |
| const char *magic = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"; |
| |
| nn_sha1_init (&hash); |
| |
| for (i = 0; i < key_len; i++) |
| nn_sha1_hashbyte (&hash, key [i]); |
| |
| for (i = 0; i < 36; i++) |
| nn_sha1_hashbyte (&hash, magic [i]); |
| |
| rc = nn_base64_encode (nn_sha1_result (&hash), |
| sizeof (hash.state), hashed, hashed_len); |
| |
| return rc; |
| } |
| |
| /* Scans for reference token against subject string, optionally ignoring |
| case sensitivity. On match, advances the subject pointer to the next |
| non-ignored character past match. Both strings must be NULL terminated to |
| avoid undefined behavior. Returns NN_WSHDR_MATCH on match; else, |
| NN_WSHDR_NOMATCH. */ |
| static int nn_ws_match_token (const char* token, const char **subj, |
| int case_insensitive) |
| { |
| const char *pos; |
| |
| nn_assert (token && *subj); |
| |
| pos = *subj; |
| |
| if (case_insensitive) { |
| while (*token && *pos) { |
| if (tolower (*token) != tolower (*pos)) |
| return NN_WSHDR_NOMATCH; |
| token++; |
| pos++; |
| } |
| } |
| else { |
| while (*token && *pos) { |
| if (*token != *pos) |
| return NN_WSHDR_NOMATCH; |
| token++; |
| pos++; |
| } |
| } |
| |
| /* Encountered end of subject before matching completed. */ |
| if (!*pos && *token) |
| return NN_WSHDR_NOMATCH; |
| |
| /* Entire token has been matched. */ |
| nn_assert (!*token); |
| |
| /* On success, advance subject position. */ |
| *subj = pos; |
| |
| return NN_WSHDR_MATCH; |
| } |
| |
| /* Scans subject string for termination sequence, optionally ignoring |
| leading and/or trailing spaces in subject. On match, advances |
| the subject pointer to the next character past match. Both |
| strings must be NULL terminated to avoid undefined behavior. If the |
| match succeeds, values are stored into *addr and *len. */ |
| static int nn_ws_match_value (const char* termseq, const char **subj, |
| int ignore_leading_sp, int ignore_trailing_sp, const uint8_t **addr, |
| size_t* const len) |
| { |
| const char *start; |
| const char *end; |
| |
| nn_assert (termseq && *subj); |
| |
| start = *subj; |
| if (addr) |
| *addr = NULL; |
| if (len) |
| *len = 0; |
| |
| /* Find first occurence of termination sequence. */ |
| end = strstr (start, termseq); |
| |
| /* Was a termination sequence found? */ |
| if (end) { |
| *subj = end + strlen (termseq); |
| } |
| else { |
| return NN_WSHDR_NOMATCH; |
| } |
| |
| if (ignore_leading_sp) { |
| while (*start == '\x20' && start < end) { |
| start++; |
| } |
| } |
| |
| if (addr) |
| *addr = start; |
| |
| /* In this special case, the value was "found", but is just empty or |
| ignored space. */ |
| if (start == end) |
| return NN_WSHDR_MATCH; |
| |
| if (ignore_trailing_sp) { |
| while (*(end - 1) == '\x20' && start < end) { |
| end--; |
| } |
| } |
| |
| if (len) |
| *len = end - start; |
| |
| return NN_WSHDR_MATCH; |
| } |
| |
| /* Compares subject octet stream to expected value, optionally ignoring |
| case sensitivity. Returns non-zero on success, zero on failure. */ |
| static int nn_ws_validate_value (const char* expected, const uint8_t *subj, |
| size_t subj_len, int case_insensitive) |
| { |
| if (strlen (expected) != subj_len) |
| return NN_WSHDR_NOMATCH; |
| |
| if (case_insensitive) { |
| while (*expected && *subj) { |
| if (tolower (*expected) != tolower (*subj)) |
| return NN_WSHDR_NOMATCH; |
| expected++; |
| subj++; |
| } |
| } |
| else { |
| while (*expected && *subj) { |
| if (*expected != *subj) |
| return NN_WSHDR_NOMATCH; |
| expected++; |
| subj++; |
| } |
| } |
| |
| return NN_WSHDR_MATCH; |
| } |
| |
