//-----------------------------------------------------------------------------
static void logic_tick(void *d)
{
TcpClientState *state = (TcpClientState *) d;
float currTime = glfwGetTime();
if (state->waiting || currTime < state->last_post_time + state->post_delay)
return;
state->last_post_time = currTime;
uint32_t packet_size = 5;
Netcmd *cmd;
while ((cmd = queue_first(state->out)) != NULL) {
memcpy(packet + packet_size, cmd, command_size(cmd));
packet_size += command_size(cmd);
queue_pop(state->out);
}
uint32_t data_size = packet_size - sizeof(uint32_t)-1;
packet[0] = TCP_MSG_CMDS;
memcpy(packet+1, &data_size, sizeof(uint32_t));
tcpclient_write(state->socket, packet, packet_size);
state->waiting = 1;
state->wait_start = glfwGetTime();
}
int
hokuyo::Laser::laserWrite(const char* msg)
{
#if HOKUYO_INTERFACE_ETHERNET
ssize_t len = strlen(msg);
ssize_t retval = tcpclient_write(&tcpclient, msg, len);
#else
// IO is currently non-blocking. This is what we want for the more common read case.
int origflags = fcntl(laser_fd_,F_GETFL,0);
fcntl(laser_fd_, F_SETFL, origflags & ~O_NONBLOCK); // @todo can we make this all work in non-blocking?
ssize_t len = strlen(msg);
ssize_t retval = write(laser_fd_, msg, len);
int fputserrno = errno;
fcntl(laser_fd_, F_SETFL, origflags | O_NONBLOCK);
errno = fputserrno; // Don't want to see the fcntl errno below.
#endif
if (retval != -1)
{
#ifdef USE_LOG_FILE
if (strlen(msg) > 1)
{
long long outtime = timeHelper();
fprintf(logfile, "Out: %lli.%09lli %s\n", outtime / 1000000000L, outtime % 1000000000L, msg);
}
#endif
return retval;
}
else
HOKUYO_EXCEPT(hokuyo::Exception, "fputs failed -- Error = %d: %s", errno, strerror(errno));
}
//-----------------------------------------------------------------------------
void tcpclientstate_login(void *d, void *login_data, uint32_t ldsize)
{
TcpClientState *state = (TcpClientState *) d;
packet[0] = TCP_MSG_LOGIN;
memcpy(packet+1, &ldsize, 4);
memcpy(packet+5, login_data, ldsize);
tcpclient_write(state->socket, packet, 5+ldsize);
tcpclientstate_wait_for_snapshot(d);
}
static void
_recv(void *env,rain_routine_t src,struct rainMsg msg,rain_session_t session)
{
tcpsvr_t * svr = (tcpsvr_t *)env;
tcp_cmd_t * p = (tcp_cmd_t *)(msg.data);
tcpclient_t *cli = tcpsvr_query(svr,p->id);
if(cli) {
if(p->cmd == CMD_SEND) {
int ret = tcpclient_write(cli,NULL,0);
if(ret < 0) {
printf("send:error");
}
} else if(p->cmd == CMD_CLOSE) {
tcpclient_destroy(cli);
}
} else if(session != RAIN_INVALID_SESSION) {
char buf[]="error_cmd";
struct rainMsg tmpmsg= {buf,sizeof(buf),-1};
rain_responce(svr->ctx,src,tmpmsg,RAIN_COPY,session);
}
free(msg.data);
}
//-----------------------------------------------------------------------------
static void send_confirmation(TcpClientState *state)
{
packet[0] = TCP_MSG_CONFIRM;
memset(packet+1, 0, 4);
tcpclient_write(state->socket, packet, 5);
}
