int
krb5_net_write(krb5_context context, int fd, const char *buf, int len)
{
sg_buf sg;
SG_SET(&sg, buf, len);
return krb5int_net_writev(context, fd, &sg, 1);
}
static void
set_conn_state_msg_length (struct conn_state *state, const krb5_data *message)
{
if (!message || message->length == 0)
return;
if (!state->is_udp) {
state->x.out.msg_len_buf[0] = (message->length >> 24) & 0xff;
state->x.out.msg_len_buf[1] = (message->length >> 16) & 0xff;
state->x.out.msg_len_buf[2] = (message->length >> 8) & 0xff;
state->x.out.msg_len_buf[3] = message->length & 0xff;
SG_SET(&state->x.out.sgbuf[0], state->x.out.msg_len_buf, 4);
SG_SET(&state->x.out.sgbuf[1], message->data, message->length);
state->x.out.sg_count = 2;
} else {
static krb5_error_code
add_connection(struct conn_state **conns, struct addrinfo *ai,
size_t server_index, const krb5_data *message, char **udpbufp)
{
struct conn_state *state, **tailptr;
state = calloc(1, sizeof(*state));
if (state == NULL)
return ENOMEM;
state->state = INITIALIZING;
state->err = 0;
state->x.out.sgp = state->x.out.sgbuf;
state->socktype = ai->ai_socktype;
state->family = ai->ai_family;
state->addrlen = ai->ai_addrlen;
memcpy(&state->addr, ai->ai_addr, ai->ai_addrlen);
state->fd = INVALID_SOCKET;
state->server_index = server_index;
SG_SET(&state->x.out.sgbuf[1], 0, 0);
if (ai->ai_socktype == SOCK_STREAM) {
/*
SG_SET(&state->x.out.sgbuf[0], message_len_buf, 4);
SG_SET(&state->x.out.sgbuf[1], message->data, message->length);
state->x.out.sg_count = 2;
*/
state->is_udp = 0;
state->service = service_tcp_fd;
set_conn_state_msg_length (state, message);
} else {
/*
SG_SET(&state->x.out.sgbuf[0], message->data, message->length);
SG_SET(&state->x.out.sgbuf[1], 0, 0);
state->x.out.sg_count = 1;
*/
state->is_udp = 1;
state->service = service_udp_fd;
set_conn_state_msg_length (state, message);
if (*udpbufp == NULL) {
*udpbufp = malloc(krb5_max_dgram_size);
if (*udpbufp == 0)
return ENOMEM;
}
state->x.in.buf = *udpbufp;
state->x.in.bufsize = krb5_max_dgram_size;
}
/* Chain the new state onto the tail of the list. */
for (tailptr = conns; *tailptr != NULL; tailptr = &(*tailptr)->next);
*tailptr = state;
return 0;
}
static void
set_conn_state_msg_length (struct conn_state *state, const krb5_data *message)
{
if (!message || message->length == 0)
return;
if (!state->is_udp) {
store_32_be(message->length, state->x.out.msg_len_buf);
SG_SET(&state->x.out.sgbuf[0], state->x.out.msg_len_buf, 4);
SG_SET(&state->x.out.sgbuf[1], message->data, message->length);
state->x.out.sg_count = 2;
} else {
SG_SET(&state->x.out.sgbuf[0], message->data, message->length);
SG_SET(&state->x.out.sgbuf[1], 0, 0);
state->x.out.sg_count = 1;
}
}
/* Set up the actual message we will send across the underlying transport to
* communicate the payload message, using one or both of state->out.sgbuf. */
static krb5_error_code
set_transport_message(struct conn_state *state, const krb5_data *realm,
const krb5_data *message)
{
struct outgoing_message *out = &state->out;
char *req = NULL;
size_t reqlen;
krb5_error_code ret;
if (message == NULL || message->length == 0)
return 0;
if (state->addr.transport == TCP) {
store_32_be(message->length, out->msg_len_buf);
SG_SET(&out->sgbuf[0], out->msg_len_buf, 4);
SG_SET(&out->sgbuf[1], message->data, message->length);
out->sg_count = 2;
return 0;
} else if (state->addr.transport == HTTPS) {
ret = make_proxy_request(state, realm, message, &req, &reqlen);
if (ret != 0)
return ret;
SG_SET(&state->out.sgbuf[0], req, reqlen);
SG_SET(&state->out.sgbuf[1], 0, 0);
state->out.sg_count = 1;
free(state->http.https_request);
state->http.https_request = req;
return 0;
} else {
SG_SET(&out->sgbuf[0], message->data, message->length);
SG_SET(&out->sgbuf[1], NULL, 0);
out->sg_count = 1;
return 0;
}
}
static krb5_error_code
add_connection(struct conn_state **conns, k5_transport transport,
krb5_boolean defer, struct addrinfo *ai, size_t server_index,
const krb5_data *realm, const char *hostname,
const char *uri_path, char **udpbufp)
{
struct conn_state *state, **tailptr;
state = calloc(1, sizeof(*state));
if (state == NULL)
return ENOMEM;
state->state = INITIALIZING;
state->out.sgp = state->out.sgbuf;
state->addr.transport = transport;
state->addr.family = ai->ai_family;
state->addr.len = ai->ai_addrlen;
memcpy(&state->addr.saddr, ai->ai_addr, ai->ai_addrlen);
state->defer = defer;
state->fd = INVALID_SOCKET;
state->server_index = server_index;
SG_SET(&state->out.sgbuf[1], NULL, 0);
if (transport == TCP) {
state->service_connect = service_tcp_connect;
state->service_write = service_tcp_write;
state->service_read = service_tcp_read;
} else if (transport == HTTPS) {
state->service_connect = service_tcp_connect;
state->service_write = service_https_write;
state->service_read = service_https_read;
state->http.uri_path = uri_path;
state->http.servername = hostname;
} else {
state->service_connect = NULL;
state->service_write = NULL;
state->service_read = service_udp_read;
if (*udpbufp == NULL) {
*udpbufp = malloc(MAX_DGRAM_SIZE);
if (*udpbufp == 0)
return ENOMEM;
}
state->in.buf = *udpbufp;
state->in.bufsize = MAX_DGRAM_SIZE;
}
/* Chain the new state onto the tail of the list. */
for (tailptr = conns; *tailptr != NULL; tailptr = &(*tailptr)->next);
*tailptr = state;
return 0;
}