int
sys_channel_read( SysChannel channel, void* buffer, int size )
{
int len = size;
char* buf = (char*) buffer;
while (len > 0) {
int ret = socket_recv(channel->fd, buf, len);
if (ret < 0) {
if (errno == EINTR)
continue;
if (errno == EWOULDBLOCK || errno == EAGAIN)
break;
D( "%s: after reading %d bytes, recv() returned error %d: %s\n",
__FUNCTION__, size - len, errno, errno_str);
return -1;
} else if (ret == 0) {
break;
} else {
buf += ret;
len -= ret;
}
}
return size - len;
}
int test_tcp() {
int fd = socket_new(SOCK_STREAM);
fd =socket_bind(fd, "", 9000);
fd = socket_listen(fd);
printf("socket fd: %d\n", fd);
char cip[16] = {0};
int connfd = socket_accept(fd, cip);
if (connfd < 0) {
printf("accept failed\n");
return -1;
}
printf("start to recv\n");
char* msg = (char*)socket_recv(connfd);
printf("body=%s\n", msg);
socket_send(connfd, "back from server", strlen("back from server"));
free(msg);
close(connfd);
close(fd);
return 0;
}
AsyncStatus
asyncReader_read(AsyncReader* ar)
{
int ret;
if (ar->pos >= ar->buffsize) {
return ASYNC_COMPLETE;
}
do {
ret = socket_recv(ar->io->fd, ar->buffer + ar->pos, ar->buffsize - ar->pos);
if (ret == 0) {
/* disconnection ! */
errno = ECONNRESET;
return ASYNC_ERROR;
}
if (ret < 0) {
if (errno == EINTR) /* loop on EINTR */
continue;
if (errno == EWOULDBLOCK || errno == EAGAIN) {
loopIo_wantRead(ar->io);
return ASYNC_NEED_MORE;
}
return ASYNC_ERROR;
}
ar->pos += ret;
} while (ar->pos < ar->buffsize);
loopIo_dontWantRead(ar->io);
return ASYNC_COMPLETE;
}
int main(int argc, char *argv[])
{
//int clifd = -1;
int len = 0;
char buf[128] = {0};
struct socket_impl sck;
if (inet_server_create(&sck, SOCK_STREAM, NULL, 5001) == -1)
return -1;
//clifd = socket_accept(sck.fd);
//printf("accept succ\n");
//printf("fd = %d\n", clifd);
sleep(1);
socket_event_add(&sck.evl, SOCKET_ON_CLOSE, on_close, NULL);
socket_event_add(&sck.evl, SOCKET_ON_RECV, on_recv, NULL);
while (sck.cli_fd[0] == -1) usleep(200);
while ((len = socket_recv(sck.cli_fd[0], buf, sizeof(buf))))
{
if (len <= 0) break;
printf("len: %d, info: %s\n", len, buf);
socket_send(sck.cli_fd[0], "hi,cli!", sizeof("hi,cli!"));
//sleep(1);
}
printf("over\n");
return 0;
}
int http_get_file_size(int sockfd,char* path)
{
int ret = -1;
char buf_recv_temp[BUFFER_SIZE+1];
head_to_get_file_size(path);
#ifdef HTTP_DEBUG
printf("\nsend : \n%s \n",buf_send);
#endif
socket_send(sockfd,buf_send,strlen(buf_send),0);
memset(buf_recv_temp,0,sizeof(buf_recv_temp));
ret = socket_recv(sockfd, buf_recv_temp, sizeof(buf_recv_temp)-1, 0);
D(printf("recv len = %d\n",ret));
D(printf("recv = %s\n",buf_recv_temp));
if( ret <= 0 )
{
perror("ERROR: failed to get file size");
return -1;
}
ret = http_get_content_length(buf_recv_temp);
if( ret <= 0 )
return -1;
else
return ret;
}
/*-------------------------------------------------------------------------*\
* Receives data from a UDP socket
\*-------------------------------------------------------------------------*/
static int meth_receive(lua_State *L) {
p_udp udp = (p_udp) auxiliar_checkgroup(L, "udp{any}", 1);
char buf[UDP_DATAGRAMSIZE];
size_t got, wanted = (size_t) luaL_optnumber(L, 2, sizeof(buf));
char *dgram = wanted > sizeof(buf)? (char *) malloc(wanted): buf;
int err;
p_timeout tm = &udp->tm;
timeout_markstart(tm);
if (!dgram) {
lua_pushnil(L);
lua_pushliteral(L, "out of memory");
return 2;
}
err = socket_recv(&udp->sock, dgram, wanted, &got, tm);
/* Unlike TCP, recv() of zero is not closed, but a zero-length packet. */
if (err != IO_DONE && err != IO_CLOSED) {
lua_pushnil(L);
lua_pushstring(L, udp_strerror(err));
if (wanted > sizeof(buf)) free(dgram);
return 2;
}
lua_pushlstring(L, dgram, got);
if (wanted > sizeof(buf)) free(dgram);
return 1;
}
void on_recv(int fd, void *arg)
{
char buf[128] = {0};
int sock_type = get_socket_type(fd);
int proto_type = get_socket_protocol(fd);
switch (sock_type) {
case SOCK_STREAM:
if (proto_type == IPPROTO_TCP)
socket_recv(fd, buf, sizeof(buf));
else if (proto_type == IPPROTO_SCTP) ;
else return;
break;
case SOCK_DGRAM:
socket_addr_recvfrom(fd, buf, sizeof(buf),
(void *)&((struct socket_impl *)arg)->addr.in_addr);
break;
default:
return;
break;
}
printf("recv from %s: %s\n",
inet_ntoa(((struct socket_impl *)arg)->addr.in_addr.sin_addr),
buf);
}
void recv_packet(int sock)
{
ssize_t res;
while ((res = socket_recv(sock, &m_frame[0], m_frame.size())) >= 0) {
if (res == 0)
continue;
if (payload_hdr_is_done(m_payload_hdr)) {
stop();
return;
}
if (!payload_hdr_block_id_equal(m_payload_hdr))
continue;
if (payload_hdr_is_ack(m_payload_hdr) &&
packet_hdr_is_from_dest(m_packet_hdr)) {
m_packets = 0;
m_budget = 0;
payload_data_reset();
continue;
}
if (payload_hdr_is_enc(m_payload_hdr))
payload_data_read(m_payload_data);
if (payload_data_received() >= m_threshold)
send_budget();
if (payload_data_is_complete())
send_ack();
}
}
ssize_t recv(int sock, void * p_buf, size_t buf_size, int flags)
{
VERIFY_MODULE_IS_INITIALIZED();
VERIFY_SOCKET_ID(sock);
NULL_PARAM_CHECK(p_buf);
SOCKET_MUTEX_LOCK();
socket_entry_t * p_socket_entry = &m_socket_table[sock];
SOCKET_MUTEX_UNLOCK();
ssize_t ret = -1;
if (p_socket_entry->state == STATE_CONNECTED)
{
uint32_t recv_size = 0;
uint32_t err_code = socket_recv(&p_socket_entry->handle,
p_buf,
buf_size,
&recv_size,
flags);
if (err_code == NRF_SUCCESS)
{
ret = (ssize_t) recv_size;
}
socket_set_errno(err_code);
}
else
{
set_errno(ENOTCONN);
}
return ret;
}
bool pbpal_read_over(pubnub_t *pb)
{
unsigned to_read = 0;
WATCH_ENUM(pb->sock_state);
WATCH_USHORT(pb->readlen);
WATCH_USHORT(pb->left);
WATCH_UINT(pb->len);
if (pb->readlen == 0) {
int recvres;
to_read = pb->len - pbpal_read_len(pb);
if (to_read > pb->left) {
to_read = pb->left;
}
recvres = socket_recv(pb->pal.socket, (char*)pb->ptr, to_read, 0);
if (recvres <= 0) {
/* This is error or connection close, which may be handled
in some way...
*/
return false;
}
pb->sock_state = STATE_READ;
pb->readlen = recvres;
}
to_read = pb->len;
if (pb->readlen < to_read) {
to_read = pb->readlen;
}
pb->ptr += to_read;
pb->readlen -= to_read;
PUBNUB_ASSERT_OPT(pb->left >= to_read);
pb->left -= to_read;
pb->len -= to_read;
if (pb->len == 0) {
pb->sock_state = STATE_NONE;
return true;
}
if (pb->left == 0) {
/* Buffer has been filled, but the requested block has not been
* read. We have to "reset" this "mini-fsm", as otherwise we
* won't read anything any more. This means that we have lost
* the current contents of the buffer, which is bad. In some
* general code, that should be reported, as the caller could
* save the contents of the buffer somewhere else or simply
* decide to ignore this block (when it does end eventually).
*/
pb->sock_state = STATE_NONE;
}
else {
pb->sock_state = STATE_NEWDATA_EXHAUSTED;
return false;
}
return true;
}
/*
* Asynchronous I/O callback launched when framebuffer notifications are ready
* to be read.
* Param:
* opaque - FrameBufferImpl instance.
*/
static void
_fbUpdatesImpl_io_callback(void* opaque, int fd, unsigned events)
{
FrameBufferImpl* fbi = opaque;
int ret;
// Read updates while they are immediately available.
for (;;) {
// Read next chunk of data.
ret = HANDLE_EINTR(
socket_recv(fbi->sock,
fbi->reader_buffer + fbi->reader_offset,
fbi->reader_bytes - fbi->reader_offset));
if (ret < 0 && (errno == EWOULDBLOCK || errno == EAGAIN)) {
// Chunk is not avalable at this point. Come back later.
return;
}
if (ret <= 0) {
/* disconnection ! */
derror("Unable to receive framebuffer data: %s\n",
ret < 0 ? strerror(errno), "unexpected disconnection");
fbUpdatesImpl_destroy();
return;
}
fbi->reader_offset += ret;
if (fbi->reader_offset != fbi->reader_bytes) {
// There are still some data left in the pipe.
continue;
}
// All expected data has been read. Time to change the state.
if (fbi->fb_state == EXPECTS_HEADER) {
// Update header has been read. Prepare for the pixels.
fbi->fb_state = EXPECTS_PIXELS;
fbi->reader_offset = 0;
fbi->reader_bytes = fbi->update_header.w *
fbi->update_header.h *
(fbi->bits_per_pixel / 8);
fbi->reader_buffer = malloc(fbi->reader_bytes);
if (fbi->reader_buffer == NULL) {
APANIC("Unable to allocate memory for framebuffer update\n");
}
} else {
// Pixels have been read. Prepare for the header.
uint8_t* pixels = fbi->reader_buffer;
fbi->fb_state = EXPECTS_HEADER;
fbi->reader_offset = 0;
fbi->reader_bytes = sizeof(FBUpdateMessage);
fbi->reader_buffer = (uint8_t*)&fbi->update_header;
// Perform the update. Note that pixels buffer must be freed there.
_update_rect(fbi->fb, fbi->update_header.x,
fbi->update_header.y, fbi->update_header.w,
fbi->update_header.h, fbi->bits_per_pixel,
pixels);
}
}
static unsigned char client_read_byte(const remote_process_client *client)
{
unsigned char data;
if (0 != socket_recv(client->socket, (char*)&data, 1)) {
exit(10012);
}
return data;
}
/**
******************************************************************************
* @brief 1. 打开读卡器
* @param[in] None
* @param[out] None
*
* @retval 0 : 打开读卡器端口成功
* @retval 1 : 打开读卡器端口失败
******************************************************************************
*/
extern int
MS_OpenPort()
{
unsigned int socketfd = 0;
char buf[16] = {0};
int pos = 0;
int sendlen = 0;
int recvlen = 0;
int ret = 1;
if ((socketfd = connect_start()) == 0)
{
log_exit();
return 1;
}
memcpy(buf, the_head, 3); //3字节GET
pos += 3;
buf[pos] = 1;
pos += 1;
memcpy(buf + pos, &sendlen, sizeof(int));
pos += sizeof(int);
do
{
if ((sendlen + 8) != socket_send(socketfd, buf, sendlen + 8))
{
log_print("%s发送数据数据出错\n", __FUNCTION__);
break;
}
memset(buf, 0x00, sizeof(buf));
recvlen = socket_recv(socketfd, buf, 12); //len = 8 + 4
if ((recvlen == -1) || (recvlen != 12))
{
log_print("%s接收数据出错[recvlen:%d]\n", __FUNCTION__, recvlen);
break;
}
pos = 0;
if ((memcmp(buf, "PUT", 3) != 0) || (buf[3] != 1))
{
log_print("%s 头不合法\n", __FUNCTION__);
break;
}
pos += 4;
memcpy(&recvlen, buf + pos, sizeof(int));
if (recvlen != sizeof(int))
{
log_print("%s 长度不合法\n", __FUNCTION__);
break;
}
pos += 4;
memcpy(&ret, buf + pos, sizeof(int));
ret = (ret == 0) ? ret : 1;
} while(0);
connect_close(socketfd);
return ret;
}
int client_getc (client_t *c)
{
uint8_t b;
if (socket_recv (c->sock, &b, 1) <= 0) {
// No data available
return -1;
}
return b;
}
int ReadMessage( unsigned int* sock, int count , char* buffer , int*len , int*errorid , int timeout )
{
int error = 0;
fd_set set;
FD_ZERO(&set);
for( int i=0; i<count; i++ )
if( sock[i] != 0 )
FD_SET( sock[i] , &set);
struct timeval tv;
tv.tv_sec = 0;
tv.tv_usec = timeout*1000;
int num = select( FD_SETSIZE , &set, NULL, NULL, &tv);
if (num > 0)
{
for( int i=0; i<count; i++ )
{
if( sock[i] && FD_ISSET( sock[i] , &set ) )
{
int length;
TraceMsg( "to receive %d\n" , i );
if( socket_recv( sock[i], (char*)&length, sizeof(length)) == 0)
{
if ( socket_recv( sock[i], buffer , length) == 0)
{
*len = length;
return i;
}
else
error = -1;
}
else
error = -2;
if( error )
*errorid = i;
break;
}
}
}
else if( num < 0 )
error = -3;
return error;
}
enum pubnub_res pbpal_line_read_status(pubnub_t *pb)
{
uint8_t c;
if (pb->readlen == 0) {
int recvres = socket_recv(pb->pal.socket, (char*)pb->ptr, pb->left, 0);
if (recvres < 0) {
if (socket_timed_out()) {
return PNR_TIMEOUT;
}
if (PUBNUB_BLOCKING_IO_SETTABLE && pb->options.use_blocking_io) {
return PNR_IO_ERROR;
}
return socket_would_block() ? PNR_IN_PROGRESS : PNR_IO_ERROR;
}
else if (0 == recvres) {
return PNR_TIMEOUT;
}
PUBNUB_LOG_TRACE("have new data of length=%d: %s\n", recvres, pb->ptr);
pb->sock_state = STATE_READ_LINE;
pb->readlen = recvres;
}
while (pb->left > 0 && pb->readlen > 0) {
c = *pb->ptr++;
--pb->readlen;
--pb->left;
if (c == '\n') {
int read_len = pbpal_read_len(pb);
PUBNUB_LOG_TRACE("\n found: "); WATCH_INT(read_len); WATCH_USHORT(pb->readlen);
pb->sock_state = STATE_NONE;
return PNR_OK;
}
}
if (pb->left == 0) {
/* Buffer has been filled, but new-line char has not been
* found. We have to "reset" this "mini-fsm", as otherwise we
* won't read anything any more. This means that we have lost
* the current contents of the buffer, which is bad. In some
* general code, that should be reported, as the caller could
* save the contents of the buffer somewhere else or simply
* decide to ignore this line (when it does end eventually).
*/
pb->sock_state = STATE_NONE;
}
else {
pb->sock_state = STATE_NEWDATA_EXHAUSTED;
}
return PNR_IN_PROGRESS;
}
/*******************************************************************************
* Read from an open file descriptor into buffer.
*
* The caller should disable the default Apache SIGPIPE handler,
* otherwise a bad script could cause the request to abort and appear
* as though the client's fd caused it.
*
* Results:
* <0 error, errno is set
* =0 EOF reached
* >0 successful read or no room in buffer (NOT # of bytes read)
*/
int fcgi_buf_socket_recv(Buffer *buf, SOCKET fd)
{
int len;
fcgi_buf_check(buf);
if (buf->length == buf->size)
/* there's no room in the buffer, return "success" */
return 1;
if (buf->length == 0)
/* the buffer is empty so defrag */
buf->begin = buf->end = buf->data;
len = min(buf->size - buf->length, buf->data + buf->size - buf->end);
#ifndef NO_WRITEV
/* assume there is a readv() since there is a writev() */
if (len == buf->size - buf->length)
{
#endif
len = socket_recv(fd, buf->end, len);
#ifndef NO_WRITEV
}
else
{
/* the buffer is wrapped, use readv() */
struct iovec vec[2];
vec[0].iov_base = buf->end;
vec[0].iov_len = len;
vec[1].iov_base = buf->data;
vec[1].iov_len = buf->size - buf->length - len;
ASSERT(len);
ASSERT(vec[1].iov_len);
do
{
len = readv(fd, vec, 2);
}
while (len == -1 && errno == EINTR);
}
#endif
if (len <= 0) return len;
fcgi_buf_added(buf, len);
return len; /* this may not contain the number of bytes read */
}
bool DrainerObject::drainSocket() {
errno = 0;
char buff[1024];
int size = socket_recv(mSocket, buff, sizeof(buff));
if (size > 0) {
return true;
} else if (size < 0 && errno == EWOULDBLOCK) {
return true;
}
mSocketIsDrained = true;
return false;
}
/*
* Read a received packet into buffer buf (which is of maximum length len);
* store calling ip and port as well. Call available() to make sure data is
* ready first.
* NOTE: I don't believe len is ever checked in implementation of recvfrom(),
* so it's easy to overflow buffer. so we check and truncate.
* Returns number of bytes read, or negative number of bytes we would have
* needed if we truncated.
*/
int udp_read_packet (udp_t *u, uint8_t *buf, unsigned len,
uint8_t *ip, unsigned *port)
{
int nbytes = udp_available (u) - 8; /* skip UDP header */
if (nbytes < 0) {
/* No real data here. */
return 0;
}
if (nbytes > (int)len) {
/* Packet is too large - truncate.
* HACK: hand-parse the UDP packet using TCP recv method. */
uint8_t tmpBuf[8];
int i;
/* Read 8 header bytes and get IP and port from it. */
socket_recv (u->sock, tmpBuf, 8);
if (ip != 0) {
ip[0] = tmpBuf[0];
ip[1] = tmpBuf[1];
ip[2] = tmpBuf[2];
ip[3] = tmpBuf[3];
}
if (port != 0)
*port = (tmpBuf[4] << 8) + tmpBuf[5];
/* Now copy first (len) bytes into buf. */
for (i=0; i<(int)len; i++) {
socket_recv (u->sock, tmpBuf, 1);
buf[i] = tmpBuf[0];
}
/* And just read the rest byte by byte and throw it away. */
while (udp_available (u)) {
socket_recv (u->sock, tmpBuf, 1);
}
return -nbytes;
}
return socket_recvfrom (u->sock, buf, len, ip, port);
}
static int
netPipe_recvBuffers( void* opaque, GoldfishPipeBuffer* buffers, int numBuffers )
{
NetPipe* pipe = opaque;
int count = 0;
int ret = 0;
int buffStart = 0;
GoldfishPipeBuffer* buff = buffers;
GoldfishPipeBuffer* buffEnd = buff + numBuffers;
for (; buff < buffEnd; buff++)
count += buff->size;
buff = buffers;
while (count > 0) {
int avail = buff->size - buffStart;
int len = socket_recv(pipe->io->fd, buff->data + buffStart, avail);
/* the read succeeded */
if (len > 0) {
buffStart += len;
if (buffStart >= buff->size) {
buff++;
buffStart = 0;
}
count -= len;
ret += len;
continue;
}
/* we reached the end of stream? */
if (len == 0) {
if (ret == 0)
ret = PIPE_ERROR_IO;
break;
}
/* if we already read some stuff, simply return */
if (ret > 0) {
break;
}
/* need to return an appropriate error code */
if (errno == EAGAIN || errno == EWOULDBLOCK) {
ret = PIPE_ERROR_AGAIN;
} else {
ret = PIPE_ERROR_IO;
}
break;
}
return ret;
}
//TODO: Make so this warning goes away.
void * output_thread (void) {
printf("CIEL: Output thread started....\n");
//sion_entry testentry; //DEBUG
uint8_t ostring[SCANDALSTRINGSIZE];
printf("CIEL: Done initialising output thread, entering main loop...\n");
while(1) {
if (socket_readable(&sockfd_telemout) == 0) {//if there is data...
socket_recv(&sockfd_telemout, ostring, SCANDALSTRINGSIZE); //grab it
socket_send(&sockfd_sion, ostring, SCANDALSTRINGSIZE, sioninfo); //and pass it to SION
}
}
pthread_exit(NULL);
}
static bool read_callback(pb_istream_t *stream, uint8_t *buf, size_t count)
{
int result;
size_t got = 0;
p_socket socket = (p_socket) stream->state;
if (buf == NULL)
{
/* Well, this is a really inefficient way to skip input. */
/* It is only used when there are unknown fields. */
char dummy;
while (count-- && socket_recv(socket, &dummy, 1, &got, MSG_WAITALL, 0) == IO_DONE && got == 1);
return count == 0;
}
result = socket_recv(socket, (char *) buf, count, &got, MSG_WAITALL, 0);
if (result != IO_DONE)
stream->bytes_left = 0; /* EOF */
return got == count && result == IO_DONE;
}
ssize_t
socket_recv_timeout(const socket_st * socket, void *buffer, int buffer_size, unsigned ms)
{
int ret;
if (socket->secure)
gnutls_record_set_timeout(socket->session, ms);
ret = socket_recv(socket, buffer, buffer_size);
if (socket->secure)
gnutls_record_set_timeout(socket->session, 0);
return ret;
}
bool pbpal_read_over(pubnub_t *pb)
{
unsigned to_read = 0;
WATCH_ENUM(pb->sock_state);
WATCH_USHORT(pb->readlen);
WATCH_USHORT(pb->left);
WATCH_UINT(pb->len);
if (pb->readlen == 0) {
int recvres;
to_read = pb->len - pbpal_read_len(pb);
if (to_read > pb->left) {
to_read = pb->left;
}
recvres = socket_recv(pb->pal.socket, (char*)pb->ptr, to_read, 0);
if (recvres <= 0) {
/* This is error or connection close, which may be handled
in some way...
*/
return false;
}
pb->sock_state = STATE_READ;
pb->readlen = recvres;
}
pb->ptr += pb->readlen;
pb->left -= pb->readlen;
pb->readlen = 0;
if (pbpal_read_len(pb) >= (int)pb->len) {
/* If we have read all that was requested, we're done. */
PUBNUB_LOG_TRACE("Read all that was to be read.\n");
pb->sock_state = STATE_NONE;
return true;
}
if ((pb->left > 0)) {
pb->sock_state = STATE_NEWDATA_EXHAUSTED;
return false;
}
/* Otherwise, we just filled the buffer, but we return 'true', to
* enable the user to copy the data from the buffer to some other
* storage.
*/
PUBNUB_LOG_WARNING("Filled the buffer, but read %d and should %d\n", pbpal_read_len(pb), pb->len);
pb->sock_state = STATE_NONE;
return true;
}
DrainerObject::~DrainerObject() {
if (!mSocketIsDrained) {
char buff[1024];
while(socket_recv(mSocket, buff, sizeof(buff)) > 0) { ; }
mSocketIsDrained = true;
}
shutdownRead();
if (mLooper) {
loopIo_dontWantRead(mIo);
loopIo_done(mIo);
mLooper = 0;
}
closeSocket();
mSocket = -1;
mParent = 0;
}
bool ThreadedSocketConnection::read()
{
struct timeval timeout = { 1, 0 };
fd_set readset = m_fds;
try
{
// Wait for input (1 second timeout)
int result = select( 1 + m_socket, &readset, 0, 0, &timeout );
if( result > 0 ) // Something to read
{
// We can read without blocking
ssize_t size = socket_recv( m_socket, m_buffer, sizeof(m_buffer) );
if ( size <= 0 ) { throw SocketRecvFailed( size ); }
m_parser.addToStream( m_buffer, size );
}
else if( result == 0 && m_pSession ) // Timeout
{
m_pSession->next();
}
else if( result < 0 ) // Error
{
throw SocketRecvFailed( result );
}
processStream();
return true;
}
catch ( SocketRecvFailed& e )
{
if( m_disconnect )
return false;
if( m_pSession )
{
m_pSession->getLog()->onEvent( e.what() );
m_pSession->disconnect();
}
else
{
disconnect();
}
return false;
}
}
int http_recv(int sockfd,char* buf_recv)
{
int ret;
int recv_len = 0;
int download_len = 0;
char buf_recv_temp[BUFFER_SIZE];
int j = 0;
memset(buf_recv_temp,0,sizeof(buf_recv_temp));
while(1)
{
ret = socket_recv(sockfd,buf_recv_temp+recv_len,
sizeof(buf_recv_temp)-1,0);
if ( ret <= 0 )
{
perror("ERROR:recvive file fail");
return ret;
}
if ( recv_len == 0 )
{
D(printf("recvive length = %d\n",ret));
D(printf("\nrecvive : \n%s \n\n",buf_recv_temp));
download_len = http_get_res_length(buf_recv_temp);
D(printf("download length = %d\n",download_len));
}
recv_len += ret;
D(printf("total receive length = %d\n",recv_len));
if ( download_len == recv_len )
break;
}
memcpy(buf_recv,buf_recv_temp,download_len);
return recv_len;
}
/*-------------------------------------------------------------------------*\
* Receives data from a UDP socket
\*-------------------------------------------------------------------------*/
static int meth_receive(lua_State *L) {
p_udp udp = (p_udp) auxiliar_checkgroup(L, "udp{any}", 1);
char buffer[UDP_DATAGRAMSIZE];
size_t got, count = (size_t) luaL_optnumber(L, 2, sizeof(buffer));
int err;
p_timeout tm = &udp->tm;
count = MIN(count, sizeof(buffer));
timeout_markstart(tm);
err = socket_recv(&udp->sock, buffer, count, &got, tm);
if (err != IO_DONE) {
lua_pushnil(L);
lua_pushstring(L, udp_strerror(err));
return 2;
}
lua_pushlstring(L, buffer, got);
return 1;
}
int socket_recv_timeo(SOCKET sock, char *buf, int len, int *outlen, int msec)
{
if (sock == NULL || buf == NULL || len == 0)
return SSS_ERROR;
fd_set fdset;
FD_ZERO(&fdset);
FD_SET(sock, &fdset);
struct timeval timeout;
timeout.tv_sec = msec / 1000;
timeout.tv_usec = msec % 1000;
if (select(sock + 1, &fdset, NULL, NULL, &timeout) <= 0)
return SSS_ERROR;
return socket_recv(sock, buf, len, outlen);
}
static int my_read(int fd, char *ptr){
int read_cnt = 0;
char *read_ptr;
char read_buf[MAXLINE];
if (read_cnt <= 0) {
again:
if ((read_cnt = socket_recv(fd, read_buf, sizeof(read_buf), 0)) < 0) {
if (IS_INTERRUPTED)
goto again;
return(-1);
} else if (read_cnt == 0)
return(0);
read_ptr = read_buf;
}
read_cnt--;
*ptr = *read_ptr++;
return(1);
}
