pxcloud/spice
6
0
Fork 0
mirror of https://gitlab.uni-freiburg.de/opensourcevdi/spice synced 2026-08-21 00:05:17 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Fix 'recive' typo throughout the code base

Browse Source 
'receive' was mispelt 'recive' in multiple places.
This commit is contained in:
Christophe Fergeau 2013-10-02 18:42:49 +02:00
parent 394fd0e6b7
commit df96538e1f
4 changed files with 63 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
server/red_worker.c
View File

@ -383,7 +383,7 @@ typedef struct LocalCursor {
} LocalCursor;
#define MAX_PIPE_SIZE 50
#define CHANNEL_RECIVE_BUF_SIZE 1024
#define CHANNEL_RECEIVE_BUF_SIZE 1024
#define WIDE_CLIENT_ACK_WINDOW 40
#define NARROW_CLIENT_ACK_WINDOW 20
@ -654,7 +654,7 @@ typedef struct GlzSharedDictionary {
typedef struct CommonChannel {
RedChannel base; // Must be the first thing
struct RedWorker *worker;
uint8_t recv_buf[CHANNEL_RECIVE_BUF_SIZE];
uint8_t recv_buf[CHANNEL_RECEIVE_BUF_SIZE];
uint32_t id_alloc; // bitfield. TODO - use this instead of shift scheme.
int during_target_migrate; /* TRUE when the client that is associated with the channel
is during migration. Turned off when the vm is started.
@ -1591,8 +1591,8 @@ static uint8_t *common_alloc_recv_buf(RedChannelClient *rcc, uint16_t type, uint
return spice_malloc(size);
}
if (size > CHANNEL_RECIVE_BUF_SIZE) {
spice_critical("unexpected message size %u (max is %d)", size, CHANNEL_RECIVE_BUF_SIZE);
if (size > CHANNEL_RECEIVE_BUF_SIZE) {
spice_critical("unexpected message size %u (max is %d)", size, CHANNEL_RECEIVE_BUF_SIZE);
return NULL;
}
return common->recv_buf;

6
server/reds-private.h
View File

@ -57,9 +57,9 @@ typedef struct VDIPortState {
/* read from agent */
Ring read_bufs;
uint32_t read_state;
uint32_t message_recive_len;
uint8_t *recive_pos;
uint32_t recive_len;
uint32_t message_receive_len;
uint8_t *receive_pos;
uint32_t receive_len;
VDIReadBuf *current_read_buf;
AgentMsgFilter read_filter;

72
server/reds.c
View File

@ -476,9 +476,9 @@ static void reds_reset_vdp(void)
SpiceCharDeviceInterface *sif;
state->read_state = VDI_PORT_READ_STATE_READ_HEADER;
state->recive_pos = (uint8_t *)&state->vdi_chunk_header;
state->recive_len = sizeof(state->vdi_chunk_header);
state->message_recive_len = 0;
state->receive_pos = (uint8_t *)&state->vdi_chunk_header;
state->receive_len = sizeof(state->vdi_chunk_header);
state->message_receive_len = 0;
if (state->current_read_buf) {
vdi_port_read_buf_unref(state->current_read_buf);
state->current_read_buf = NULL;
@ -786,43 +786,43 @@ static SpiceCharDeviceMsgToClient *vdi_port_read_one_msg_from_device(SpiceCharDe
while (vdagent) {
switch (state->read_state) {
case VDI_PORT_READ_STATE_READ_HEADER:
n = sif->read(vdagent, state->recive_pos, state->recive_len);
n = sif->read(vdagent, state->receive_pos, state->receive_len);
if (!n) {
return NULL;
}
if ((state->recive_len -= n)) {
state->recive_pos += n;
if ((state->receive_len -= n)) {
state->receive_pos += n;
return NULL;
}
state->message_recive_len = state->vdi_chunk_header.size;
state->message_receive_len = state->vdi_chunk_header.size;
state->read_state = VDI_PORT_READ_STATE_GET_BUFF;
case VDI_PORT_READ_STATE_GET_BUFF: {
if (!(state->current_read_buf = vdi_port_read_buf_get())) {
return NULL;
}
state->recive_pos = state->current_read_buf->data;
state->recive_len = MIN(state->message_recive_len,
state->receive_pos = state->current_read_buf->data;
state->receive_len = MIN(state->message_receive_len,
sizeof(state->current_read_buf->data));
state->current_read_buf->len = state->recive_len;
state->message_recive_len -= state->recive_len;
state->current_read_buf->len = state->receive_len;
state->message_receive_len -= state->receive_len;
state->read_state = VDI_PORT_READ_STATE_READ_DATA;
}
case VDI_PORT_READ_STATE_READ_DATA:
n = sif->read(vdagent, state->recive_pos, state->recive_len);
n = sif->read(vdagent, state->receive_pos, state->receive_len);
if (!n) {
return NULL;
}
if ((state->recive_len -= n)) {
state->recive_pos += n;
if ((state->receive_len -= n)) {
state->receive_pos += n;
break;
}
dispatch_buf = state->current_read_buf;
state->current_read_buf = NULL;
state->recive_pos = NULL;
if (state->message_recive_len == 0) {
state->receive_pos = NULL;
if (state->message_receive_len == 0) {
state->read_state = VDI_PORT_READ_STATE_READ_HEADER;
state->recive_pos = (uint8_t *)&state->vdi_chunk_header;
state->recive_len = sizeof(state->vdi_chunk_header);
state->receive_pos = (uint8_t *)&state->vdi_chunk_header;
state->receive_len = sizeof(state->vdi_chunk_header);
} else {
state->read_state = VDI_PORT_READ_STATE_GET_BUFF;
}
@ -1184,8 +1184,8 @@ void reds_on_main_channel_migrate(MainChannelClient *mcc)
return;
}
spice_assert(agent_state->current_read_buf->data &&
agent_state->recive_pos > agent_state->current_read_buf->data);
read_data_len = agent_state->recive_pos - agent_state->current_read_buf->data;
agent_state->receive_pos > agent_state->current_read_buf->data);
read_data_len = agent_state->receive_pos - agent_state->current_read_buf->data;
if (agent_state->read_filter.msg_data_to_read ||
read_data_len > sizeof(VDAgentMessage)) { /* msg header has been read */
@ -1205,11 +1205,11 @@ void reds_on_main_channel_migrate(MainChannelClient *mcc)
vdi_port_read_buf_unref(read_buf);
}
spice_assert(agent_state->recive_len);
agent_state->message_recive_len += agent_state->recive_len;
spice_assert(agent_state->receive_len);
agent_state->message_receive_len += agent_state->receive_len;
agent_state->read_state = VDI_PORT_READ_STATE_GET_BUFF;
agent_state->current_read_buf = NULL;
agent_state->recive_pos = NULL;
agent_state->receive_pos = NULL;
}
}
@ -1248,7 +1248,7 @@ void reds_marshall_migrate_data(SpiceMarshaller *m)
/* agent to client partial msg */
if (agent_state->read_state == VDI_PORT_READ_STATE_READ_HEADER) {
mig_data.agent2client.chunk_header_size = agent_state->recive_pos -
mig_data.agent2client.chunk_header_size = agent_state->receive_pos -
(uint8_t *)&agent_state->vdi_chunk_header;
mig_data.agent2client.msg_header_done = FALSE;
@ -1256,12 +1256,12 @@ void reds_marshall_migrate_data(SpiceMarshaller *m)
spice_assert(!agent_state->read_filter.msg_data_to_read);
} else {
mig_data.agent2client.chunk_header_size = sizeof(VDIChunkHeader);
mig_data.agent2client.chunk_header.size = agent_state->message_recive_len;
mig_data.agent2client.chunk_header.size = agent_state->message_receive_len;
if (agent_state->read_state == VDI_PORT_READ_STATE_READ_DATA) {
/* in the middle of reading the message header (see reds_on_main_channel_migrate) */
mig_data.agent2client.msg_header_done = FALSE;
mig_data.agent2client.msg_header_partial_len =
agent_state->recive_pos - agent_state->current_read_buf->data;
agent_state->receive_pos - agent_state->current_read_buf->data;
spice_assert(mig_data.agent2client.msg_header_partial_len < sizeof(VDAgentMessage));
spice_assert(!agent_state->read_filter.msg_data_to_read);
} else {
@ -1306,11 +1306,11 @@ static int reds_agent_state_restore(SpiceMigrateDataMain *mig_data)
chunk_header_remaining = sizeof(VDIChunkHeader) - mig_data->agent2client.chunk_header_size;
if (chunk_header_remaining) {
agent_state->read_state = VDI_PORT_READ_STATE_READ_HEADER;
agent_state->recive_pos = (uint8_t *)&agent_state->vdi_chunk_header +
agent_state->receive_pos = (uint8_t *)&agent_state->vdi_chunk_header +
mig_data->agent2client.chunk_header_size;
agent_state->recive_len = chunk_header_remaining;
agent_state->receive_len = chunk_header_remaining;
} else {
agent_state->message_recive_len = agent_state->vdi_chunk_header.size;
agent_state->message_receive_len = agent_state->vdi_chunk_header.size;
}
if (!mig_data->agent2client.msg_header_done) {
@ -1327,21 +1327,21 @@ static int reds_agent_state_restore(SpiceMigrateDataMain *mig_data)
memcpy(agent_state->current_read_buf->data,
partial_msg_header,
mig_data->agent2client.msg_header_partial_len);
agent_state->recive_pos = agent_state->current_read_buf->data +
agent_state->receive_pos = agent_state->current_read_buf->data +
mig_data->agent2client.msg_header_partial_len;
cur_buf_size = sizeof(agent_state->current_read_buf->data) -
mig_data->agent2client.msg_header_partial_len;
agent_state->recive_len = MIN(agent_state->message_recive_len, cur_buf_size);
agent_state->current_read_buf->len = agent_state->recive_len +
agent_state->receive_len = MIN(agent_state->message_receive_len, cur_buf_size);
agent_state->current_read_buf->len = agent_state->receive_len +
mig_data->agent2client.msg_header_partial_len;
agent_state->message_recive_len -= agent_state->recive_len;
agent_state->message_receive_len -= agent_state->receive_len;
} else {
spice_assert(mig_data->agent2client.msg_header_partial_len == 0);
}
} else {
agent_state->read_state = VDI_PORT_READ_STATE_GET_BUFF;
agent_state->current_read_buf = NULL;
agent_state->recive_pos = NULL;
agent_state->receive_pos = NULL;
agent_state->read_filter.msg_data_to_read = mig_data->agent2client.msg_remaining;
agent_state->read_filter.result = mig_data->agent2client.msg_filter_result;
}
@ -3889,8 +3889,8 @@ static void init_vd_agent_resources(void)
agent_file_xfer, TRUE);
state->read_state = VDI_PORT_READ_STATE_READ_HEADER;
state->recive_pos = (uint8_t *)&state->vdi_chunk_header;
state->recive_len = sizeof(state->vdi_chunk_header);
state->receive_pos = (uint8_t *)&state->vdi_chunk_header;
state->receive_len = sizeof(state->vdi_chunk_header);
for (i = 0; i < REDS_VDI_PORT_NUM_RECEIVE_BUFFS; i++) {
VDIReadBuf *buf = spice_new0(VDIReadBuf, 1);

40
server/snd_worker.c
View File

@ -42,7 +42,7 @@
#define IOV_MAX 1024
#endif
#define SND_RECIVE_BUF_SIZE (16 * 1024 * 2)
#define SND_RECEIVE_BUF_SIZE (16 * 1024 * 2)
#define FRAME_SIZE 256
#define PLAYBACK_BUF_SIZE (FRAME_SIZE * 4)
@ -50,7 +50,7 @@
#define CELT_BIT_RATE (64 * 1024)
#define CELT_COMPRESSED_FRAME_BYTES (FRAME_SIZE * CELT_BIT_RATE / SPICE_INTERFACE_PLAYBACK_FREQ / 8)
#define RECORD_SAMPLES_SIZE (SND_RECIVE_BUF_SIZE >> 2)
#define RECORD_SAMPLES_SIZE (SND_RECEIVE_BUF_SIZE >> 2)
enum PlaybackeCommand {
SND_PLAYBACK_MIGRATE,
@ -112,11 +112,11 @@ struct SndChannel {
} send_data;
struct {
uint8_t buf[SND_RECIVE_BUF_SIZE];
uint8_t buf[SND_RECEIVE_BUF_SIZE];
uint8_t *message_start;
uint8_t *now;
uint8_t *end;
} recive_data;
} receive_data;
snd_channel_send_messages_proc send_messages;
snd_channel_handle_message_proc handle_message;
@ -420,9 +420,9 @@ static void snd_receive(void* data)
for (;;) {
ssize_t n;
n = channel->recive_data.end - channel->recive_data.now;
n = channel->receive_data.end - channel->receive_data.now;
spice_assert(n);
n = reds_stream_read(channel->stream, channel->recive_data.now, n);
n = reds_stream_read(channel->stream, channel->receive_data.now, n);
if (n <= 0) {
if (n == 0) {
snd_disconnect_channel(channel);
@ -443,16 +443,16 @@ static void snd_receive(void* data)
return;
}
} else {
channel->recive_data.now += n;
channel->receive_data.now += n;
for (;;) {
uint8_t *msg_start = channel->recive_data.message_start;
uint8_t *msg_start = channel->receive_data.message_start;
uint8_t *data = msg_start + header->header_size;
size_t parsed_size;
uint8_t *parsed;
message_destructor_t parsed_free;
header->data = msg_start;
n = channel->recive_data.now - msg_start;
n = channel->receive_data.now - msg_start;
if (n < header->header_size ||
n < header->header_size + header->get_msg_size(header)) {
@ -473,16 +473,16 @@ static void snd_receive(void* data)
return;
}
parsed_free(parsed);
channel->recive_data.message_start = msg_start + header->header_size +
channel->receive_data.message_start = msg_start + header->header_size +
header->get_msg_size(header);
}
if (channel->recive_data.now == channel->recive_data.message_start) {
channel->recive_data.now = channel->recive_data.buf;
channel->recive_data.message_start = channel->recive_data.buf;
} else if (channel->recive_data.now == channel->recive_data.end) {
memcpy(channel->recive_data.buf, channel->recive_data.message_start, n);
channel->recive_data.now = channel->recive_data.buf + n;
channel->recive_data.message_start = channel->recive_data.buf;
if (channel->receive_data.now == channel->receive_data.message_start) {
channel->receive_data.now = channel->receive_data.buf;
channel->receive_data.message_start = channel->receive_data.buf;
} else if (channel->receive_data.now == channel->receive_data.end) {
memcpy(channel->receive_data.buf, channel->receive_data.message_start, n);
channel->receive_data.now = channel->receive_data.buf + n;
channel->receive_data.message_start = channel->receive_data.buf;
}
}
}
@ -938,9 +938,9 @@ static SndChannel *__new_channel(SndWorker *worker, int size, uint32_t channel_i
channel->parser = spice_get_client_channel_parser(channel_id, NULL);
channel->stream = stream;
channel->worker = worker;
channel->recive_data.message_start = channel->recive_data.buf;
channel->recive_data.now = channel->recive_data.buf;
channel->recive_data.end = channel->recive_data.buf + sizeof(channel->recive_data.buf);
channel->receive_data.message_start = channel->receive_data.buf;
channel->receive_data.now = channel->receive_data.buf;
channel->receive_data.end = channel->receive_data.buf + sizeof(channel->receive_data.buf);
channel->send_data.marshaller = spice_marshaller_new();
stream->watch = core->watch_add(stream->socket, SPICE_WATCH_EVENT_READ,