自学教程：C++ socket_recv函数代码示例

intsys_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;}

AsyncStatusasyncReader_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 intMS_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 intnetPipe_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_tsocket_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);}